
/**
 * Client
**/

import * as runtime from '@prisma/client/runtime/library';
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 latestNews
 * 
 */
export type latestNews = $Result.DefaultSelection<Prisma.$latestNewsPayload>
/**
 * Model sliderImages
 * 
 */
export type sliderImages = $Result.DefaultSelection<Prisma.$sliderImagesPayload>
/**
 * Model missions
 * 
 */
export type missions = $Result.DefaultSelection<Prisma.$missionsPayload>
/**
 * Model objectives
 * 
 */
export type objectives = $Result.DefaultSelection<Prisma.$objectivesPayload>
/**
 * Model homeData
 * 
 */
export type homeData = $Result.DefaultSelection<Prisma.$homeDataPayload>
/**
 * Model briefData
 * 
 */
export type briefData = $Result.DefaultSelection<Prisma.$briefDataPayload>
/**
 * Model serviceData
 * 
 */
export type serviceData = $Result.DefaultSelection<Prisma.$serviceDataPayload>
/**
 * Model activitiesData
 * 
 */
export type activitiesData = $Result.DefaultSelection<Prisma.$activitiesDataPayload>
/**
 * Model formerChairman
 * 
 */
export type formerChairman = $Result.DefaultSelection<Prisma.$formerChairmanPayload>
/**
 * Model formerSrViceChairman
 * 
 */
export type formerSrViceChairman = $Result.DefaultSelection<Prisma.$formerSrViceChairmanPayload>
/**
 * Model formerViceChairman
 * 
 */
export type formerViceChairman = $Result.DefaultSelection<Prisma.$formerViceChairmanPayload>
/**
 * Model ChairmanProfile
 * 
 */
export type ChairmanProfile = $Result.DefaultSelection<Prisma.$ChairmanProfilePayload>
/**
 * Model ChairmanAssociation
 * 
 */
export type ChairmanAssociation = $Result.DefaultSelection<Prisma.$ChairmanAssociationPayload>
/**
 * Model ChairmanClubs
 * 
 */
export type ChairmanClubs = $Result.DefaultSelection<Prisma.$ChairmanClubsPayload>
/**
 * Model ChairmanMessage
 * 
 */
export type ChairmanMessage = $Result.DefaultSelection<Prisma.$ChairmanMessagePayload>
/**
 * Model ChairmanSpeech
 * 
 */
export type ChairmanSpeech = $Result.DefaultSelection<Prisma.$ChairmanSpeechPayload>
/**
 * Model ChairmanInterviewPrint
 * 
 */
export type ChairmanInterviewPrint = $Result.DefaultSelection<Prisma.$ChairmanInterviewPrintPayload>
/**
 * Model ChairmanInterviewElectronic
 * 
 */
export type ChairmanInterviewElectronic = $Result.DefaultSelection<Prisma.$ChairmanInterviewElectronicPayload>
/**
 * Model ChairmanPresentation
 * 
 */
export type ChairmanPresentation = $Result.DefaultSelection<Prisma.$ChairmanPresentationPayload>
/**
 * Model memorandum
 * 
 */
export type memorandum = $Result.DefaultSelection<Prisma.$memorandumPayload>
/**
 * Model BoardOfDirectors
 * 
 */
export type BoardOfDirectors = $Result.DefaultSelection<Prisma.$BoardOfDirectorsPayload>
/**
 * Model ShippersNews
 * 
 */
export type ShippersNews = $Result.DefaultSelection<Prisma.$ShippersNewsPayload>
/**
 * Model AnnualReport
 * 
 */
export type AnnualReport = $Result.DefaultSelection<Prisma.$AnnualReportPayload>
/**
 * Model OtherPublications
 * 
 */
export type OtherPublications = $Result.DefaultSelection<Prisma.$OtherPublicationsPayload>
/**
 * Model SCBRecommendations
 * 
 */
export type SCBRecommendations = $Result.DefaultSelection<Prisma.$SCBRecommendationsPayload>
/**
 * Model SCBSeminar
 * 
 */
export type SCBSeminar = $Result.DefaultSelection<Prisma.$SCBSeminarPayload>
/**
 * Model Eligibility
 * 
 */
export type Eligibility = $Result.DefaultSelection<Prisma.$EligibilityPayload>
/**
 * Model RelevantPapers
 * 
 */
export type RelevantPapers = $Result.DefaultSelection<Prisma.$RelevantPapersPayload>
/**
 * Model MembersList
 * 
 */
export type MembersList = $Result.DefaultSelection<Prisma.$MembersListPayload>
/**
 * Model UsefulLinks
 * 
 */
export type UsefulLinks = $Result.DefaultSelection<Prisma.$UsefulLinksPayload>
/**
 * Model ContactUs
 * 
 */
export type ContactUs = $Result.DefaultSelection<Prisma.$ContactUsPayload>
/**
 * Model Secretariat
 * 
 */
export type Secretariat = $Result.DefaultSelection<Prisma.$SecretariatPayload>
/**
 * Model PDFs
 * 
 */
export type PDFs = $Result.DefaultSelection<Prisma.$PDFsPayload>
/**
 * Model Forms
 * 
 */
export type Forms = $Result.DefaultSelection<Prisma.$FormsPayload>
/**
 * Model MembershipText
 * 
 */
export type MembershipText = $Result.DefaultSelection<Prisma.$MembershipTextPayload>
/**
 * Model ApplicationProcedure
 * 
 */
export type ApplicationProcedure = $Result.DefaultSelection<Prisma.$ApplicationProcedurePayload>
/**
 * Model Benefits
 * 
 */
export type Benefits = $Result.DefaultSelection<Prisma.$BenefitsPayload>
/**
 * Model PhotoAlbum
 * 
 */
export type PhotoAlbum = $Result.DefaultSelection<Prisma.$PhotoAlbumPayload>
/**
 * Model GalleryPhoto
 * 
 */
export type GalleryPhoto = $Result.DefaultSelection<Prisma.$GalleryPhotoPayload>
/**
 * Model GalleryVideo
 * 
 */
export type GalleryVideo = $Result.DefaultSelection<Prisma.$GalleryVideoPayload>
/**
 * Model Condolence
 * 
 */
export type Condolence = $Result.DefaultSelection<Prisma.$CondolencePayload>
/**
 * Model Affiliates
 * 
 */
export type Affiliates = $Result.DefaultSelection<Prisma.$AffiliatesPayload>
/**
 * Model Subscribers
 * 
 */
export type Subscribers = $Result.DefaultSelection<Prisma.$SubscribersPayload>
/**
 * Model Messages
 * 
 */
export type Messages = $Result.DefaultSelection<Prisma.$MessagesPayload>

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

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

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

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

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

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

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

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

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

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

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

  /**
   * `prisma.chairmanProfile`: Exposes CRUD operations for the **ChairmanProfile** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ChairmanProfiles
    * const chairmanProfiles = await prisma.chairmanProfile.findMany()
    * ```
    */
  get chairmanProfile(): Prisma.ChairmanProfileDelegate<ExtArgs>;

  /**
   * `prisma.chairmanAssociation`: Exposes CRUD operations for the **ChairmanAssociation** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ChairmanAssociations
    * const chairmanAssociations = await prisma.chairmanAssociation.findMany()
    * ```
    */
  get chairmanAssociation(): Prisma.ChairmanAssociationDelegate<ExtArgs>;

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

  /**
   * `prisma.chairmanMessage`: Exposes CRUD operations for the **ChairmanMessage** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ChairmanMessages
    * const chairmanMessages = await prisma.chairmanMessage.findMany()
    * ```
    */
  get chairmanMessage(): Prisma.ChairmanMessageDelegate<ExtArgs>;

  /**
   * `prisma.chairmanSpeech`: Exposes CRUD operations for the **ChairmanSpeech** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ChairmanSpeeches
    * const chairmanSpeeches = await prisma.chairmanSpeech.findMany()
    * ```
    */
  get chairmanSpeech(): Prisma.ChairmanSpeechDelegate<ExtArgs>;

  /**
   * `prisma.chairmanInterviewPrint`: Exposes CRUD operations for the **ChairmanInterviewPrint** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ChairmanInterviewPrints
    * const chairmanInterviewPrints = await prisma.chairmanInterviewPrint.findMany()
    * ```
    */
  get chairmanInterviewPrint(): Prisma.ChairmanInterviewPrintDelegate<ExtArgs>;

  /**
   * `prisma.chairmanInterviewElectronic`: Exposes CRUD operations for the **ChairmanInterviewElectronic** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ChairmanInterviewElectronics
    * const chairmanInterviewElectronics = await prisma.chairmanInterviewElectronic.findMany()
    * ```
    */
  get chairmanInterviewElectronic(): Prisma.ChairmanInterviewElectronicDelegate<ExtArgs>;

  /**
   * `prisma.chairmanPresentation`: Exposes CRUD operations for the **ChairmanPresentation** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ChairmanPresentations
    * const chairmanPresentations = await prisma.chairmanPresentation.findMany()
    * ```
    */
  get chairmanPresentation(): Prisma.ChairmanPresentationDelegate<ExtArgs>;

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

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

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

  /**
   * `prisma.annualReport`: Exposes CRUD operations for the **AnnualReport** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more AnnualReports
    * const annualReports = await prisma.annualReport.findMany()
    * ```
    */
  get annualReport(): Prisma.AnnualReportDelegate<ExtArgs>;

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

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

  /**
   * `prisma.sCBSeminar`: Exposes CRUD operations for the **SCBSeminar** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more SCBSeminars
    * const sCBSeminars = await prisma.sCBSeminar.findMany()
    * ```
    */
  get sCBSeminar(): Prisma.SCBSeminarDelegate<ExtArgs>;

  /**
   * `prisma.eligibility`: Exposes CRUD operations for the **Eligibility** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Eligibilities
    * const eligibilities = await prisma.eligibility.findMany()
    * ```
    */
  get eligibility(): Prisma.EligibilityDelegate<ExtArgs>;

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

  /**
   * `prisma.membersList`: Exposes CRUD operations for the **MembersList** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more MembersLists
    * const membersLists = await prisma.membersList.findMany()
    * ```
    */
  get membersList(): Prisma.MembersListDelegate<ExtArgs>;

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

  /**
   * `prisma.contactUs`: Exposes CRUD operations for the **ContactUs** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Contactuses
    * const contactuses = await prisma.contactUs.findMany()
    * ```
    */
  get contactUs(): Prisma.ContactUsDelegate<ExtArgs>;

  /**
   * `prisma.secretariat`: Exposes CRUD operations for the **Secretariat** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Secretariats
    * const secretariats = await prisma.secretariat.findMany()
    * ```
    */
  get secretariat(): Prisma.SecretariatDelegate<ExtArgs>;

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

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

  /**
   * `prisma.membershipText`: Exposes CRUD operations for the **MembershipText** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more MembershipTexts
    * const membershipTexts = await prisma.membershipText.findMany()
    * ```
    */
  get membershipText(): Prisma.MembershipTextDelegate<ExtArgs>;

  /**
   * `prisma.applicationProcedure`: Exposes CRUD operations for the **ApplicationProcedure** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ApplicationProcedures
    * const applicationProcedures = await prisma.applicationProcedure.findMany()
    * ```
    */
  get applicationProcedure(): Prisma.ApplicationProcedureDelegate<ExtArgs>;

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

  /**
   * `prisma.photoAlbum`: Exposes CRUD operations for the **PhotoAlbum** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more PhotoAlbums
    * const photoAlbums = await prisma.photoAlbum.findMany()
    * ```
    */
  get photoAlbum(): Prisma.PhotoAlbumDelegate<ExtArgs>;

  /**
   * `prisma.galleryPhoto`: Exposes CRUD operations for the **GalleryPhoto** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more GalleryPhotos
    * const galleryPhotos = await prisma.galleryPhoto.findMany()
    * ```
    */
  get galleryPhoto(): Prisma.GalleryPhotoDelegate<ExtArgs>;

  /**
   * `prisma.galleryVideo`: Exposes CRUD operations for the **GalleryVideo** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more GalleryVideos
    * const galleryVideos = await prisma.galleryVideo.findMany()
    * ```
    */
  get galleryVideo(): Prisma.GalleryVideoDelegate<ExtArgs>;

  /**
   * `prisma.condolence`: Exposes CRUD operations for the **Condolence** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Condolences
    * const condolences = await prisma.condolence.findMany()
    * ```
    */
  get condolence(): Prisma.CondolenceDelegate<ExtArgs>;

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

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

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

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.4.2
   * Query Engine version: 2f302df92bd8945e20ad4595a73def5b96afa54f
   */
  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
  }

  /**
   * 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`.'
      : {})

  /**
   * 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: {
    latestNews: 'latestNews',
    sliderImages: 'sliderImages',
    missions: 'missions',
    objectives: 'objectives',
    homeData: 'homeData',
    briefData: 'briefData',
    serviceData: 'serviceData',
    activitiesData: 'activitiesData',
    formerChairman: 'formerChairman',
    formerSrViceChairman: 'formerSrViceChairman',
    formerViceChairman: 'formerViceChairman',
    ChairmanProfile: 'ChairmanProfile',
    ChairmanAssociation: 'ChairmanAssociation',
    ChairmanClubs: 'ChairmanClubs',
    ChairmanMessage: 'ChairmanMessage',
    ChairmanSpeech: 'ChairmanSpeech',
    ChairmanInterviewPrint: 'ChairmanInterviewPrint',
    ChairmanInterviewElectronic: 'ChairmanInterviewElectronic',
    ChairmanPresentation: 'ChairmanPresentation',
    memorandum: 'memorandum',
    BoardOfDirectors: 'BoardOfDirectors',
    ShippersNews: 'ShippersNews',
    AnnualReport: 'AnnualReport',
    OtherPublications: 'OtherPublications',
    SCBRecommendations: 'SCBRecommendations',
    SCBSeminar: 'SCBSeminar',
    Eligibility: 'Eligibility',
    RelevantPapers: 'RelevantPapers',
    MembersList: 'MembersList',
    UsefulLinks: 'UsefulLinks',
    ContactUs: 'ContactUs',
    Secretariat: 'Secretariat',
    PDFs: 'PDFs',
    Forms: 'Forms',
    MembershipText: 'MembershipText',
    ApplicationProcedure: 'ApplicationProcedure',
    Benefits: 'Benefits',
    PhotoAlbum: 'PhotoAlbum',
    GalleryPhoto: 'GalleryPhoto',
    GalleryVideo: 'GalleryVideo',
    Condolence: 'Condolence',
    Affiliates: 'Affiliates',
    Subscribers: 'Subscribers',
    Messages: 'Messages'
  };

  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: 'latestNews' | 'sliderImages' | 'missions' | 'objectives' | 'homeData' | 'briefData' | 'serviceData' | 'activitiesData' | 'formerChairman' | 'formerSrViceChairman' | 'formerViceChairman' | 'chairmanProfile' | 'chairmanAssociation' | 'chairmanClubs' | 'chairmanMessage' | 'chairmanSpeech' | 'chairmanInterviewPrint' | 'chairmanInterviewElectronic' | 'chairmanPresentation' | 'memorandum' | 'boardOfDirectors' | 'shippersNews' | 'annualReport' | 'otherPublications' | 'sCBRecommendations' | 'sCBSeminar' | 'eligibility' | 'relevantPapers' | 'membersList' | 'usefulLinks' | 'contactUs' | 'secretariat' | 'pDFs' | 'forms' | 'membershipText' | 'applicationProcedure' | 'benefits' | 'photoAlbum' | 'galleryPhoto' | 'galleryVideo' | 'condolence' | 'affiliates' | 'subscribers' | 'messages'
      txIsolationLevel: Prisma.TransactionIsolationLevel
    },
    model: {
      latestNews: {
        payload: Prisma.$latestNewsPayload<ExtArgs>
        fields: Prisma.latestNewsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.latestNewsFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$latestNewsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.latestNewsFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$latestNewsPayload>
          }
          findFirst: {
            args: Prisma.latestNewsFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$latestNewsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.latestNewsFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$latestNewsPayload>
          }
          findMany: {
            args: Prisma.latestNewsFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$latestNewsPayload>[]
          }
          create: {
            args: Prisma.latestNewsCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$latestNewsPayload>
          }
          createMany: {
            args: Prisma.latestNewsCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.latestNewsDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$latestNewsPayload>
          }
          update: {
            args: Prisma.latestNewsUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$latestNewsPayload>
          }
          deleteMany: {
            args: Prisma.latestNewsDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.latestNewsUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.latestNewsUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$latestNewsPayload>
          }
          aggregate: {
            args: Prisma.LatestNewsAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateLatestNews>
          }
          groupBy: {
            args: Prisma.latestNewsGroupByArgs<ExtArgs>,
            result: $Utils.Optional<LatestNewsGroupByOutputType>[]
          }
          count: {
            args: Prisma.latestNewsCountArgs<ExtArgs>,
            result: $Utils.Optional<LatestNewsCountAggregateOutputType> | number
          }
        }
      }
      sliderImages: {
        payload: Prisma.$sliderImagesPayload<ExtArgs>
        fields: Prisma.sliderImagesFieldRefs
        operations: {
          findUnique: {
            args: Prisma.sliderImagesFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$sliderImagesPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.sliderImagesFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$sliderImagesPayload>
          }
          findFirst: {
            args: Prisma.sliderImagesFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$sliderImagesPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.sliderImagesFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$sliderImagesPayload>
          }
          findMany: {
            args: Prisma.sliderImagesFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$sliderImagesPayload>[]
          }
          create: {
            args: Prisma.sliderImagesCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$sliderImagesPayload>
          }
          createMany: {
            args: Prisma.sliderImagesCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.sliderImagesDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$sliderImagesPayload>
          }
          update: {
            args: Prisma.sliderImagesUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$sliderImagesPayload>
          }
          deleteMany: {
            args: Prisma.sliderImagesDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.sliderImagesUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.sliderImagesUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$sliderImagesPayload>
          }
          aggregate: {
            args: Prisma.SliderImagesAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateSliderImages>
          }
          groupBy: {
            args: Prisma.sliderImagesGroupByArgs<ExtArgs>,
            result: $Utils.Optional<SliderImagesGroupByOutputType>[]
          }
          count: {
            args: Prisma.sliderImagesCountArgs<ExtArgs>,
            result: $Utils.Optional<SliderImagesCountAggregateOutputType> | number
          }
        }
      }
      missions: {
        payload: Prisma.$missionsPayload<ExtArgs>
        fields: Prisma.missionsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.missionsFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$missionsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.missionsFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$missionsPayload>
          }
          findFirst: {
            args: Prisma.missionsFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$missionsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.missionsFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$missionsPayload>
          }
          findMany: {
            args: Prisma.missionsFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$missionsPayload>[]
          }
          create: {
            args: Prisma.missionsCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$missionsPayload>
          }
          createMany: {
            args: Prisma.missionsCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.missionsDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$missionsPayload>
          }
          update: {
            args: Prisma.missionsUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$missionsPayload>
          }
          deleteMany: {
            args: Prisma.missionsDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.missionsUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.missionsUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$missionsPayload>
          }
          aggregate: {
            args: Prisma.MissionsAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateMissions>
          }
          groupBy: {
            args: Prisma.missionsGroupByArgs<ExtArgs>,
            result: $Utils.Optional<MissionsGroupByOutputType>[]
          }
          count: {
            args: Prisma.missionsCountArgs<ExtArgs>,
            result: $Utils.Optional<MissionsCountAggregateOutputType> | number
          }
        }
      }
      objectives: {
        payload: Prisma.$objectivesPayload<ExtArgs>
        fields: Prisma.objectivesFieldRefs
        operations: {
          findUnique: {
            args: Prisma.objectivesFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$objectivesPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.objectivesFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$objectivesPayload>
          }
          findFirst: {
            args: Prisma.objectivesFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$objectivesPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.objectivesFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$objectivesPayload>
          }
          findMany: {
            args: Prisma.objectivesFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$objectivesPayload>[]
          }
          create: {
            args: Prisma.objectivesCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$objectivesPayload>
          }
          createMany: {
            args: Prisma.objectivesCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.objectivesDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$objectivesPayload>
          }
          update: {
            args: Prisma.objectivesUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$objectivesPayload>
          }
          deleteMany: {
            args: Prisma.objectivesDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.objectivesUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.objectivesUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$objectivesPayload>
          }
          aggregate: {
            args: Prisma.ObjectivesAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateObjectives>
          }
          groupBy: {
            args: Prisma.objectivesGroupByArgs<ExtArgs>,
            result: $Utils.Optional<ObjectivesGroupByOutputType>[]
          }
          count: {
            args: Prisma.objectivesCountArgs<ExtArgs>,
            result: $Utils.Optional<ObjectivesCountAggregateOutputType> | number
          }
        }
      }
      homeData: {
        payload: Prisma.$homeDataPayload<ExtArgs>
        fields: Prisma.homeDataFieldRefs
        operations: {
          findUnique: {
            args: Prisma.homeDataFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$homeDataPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.homeDataFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$homeDataPayload>
          }
          findFirst: {
            args: Prisma.homeDataFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$homeDataPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.homeDataFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$homeDataPayload>
          }
          findMany: {
            args: Prisma.homeDataFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$homeDataPayload>[]
          }
          create: {
            args: Prisma.homeDataCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$homeDataPayload>
          }
          createMany: {
            args: Prisma.homeDataCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.homeDataDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$homeDataPayload>
          }
          update: {
            args: Prisma.homeDataUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$homeDataPayload>
          }
          deleteMany: {
            args: Prisma.homeDataDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.homeDataUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.homeDataUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$homeDataPayload>
          }
          aggregate: {
            args: Prisma.HomeDataAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateHomeData>
          }
          groupBy: {
            args: Prisma.homeDataGroupByArgs<ExtArgs>,
            result: $Utils.Optional<HomeDataGroupByOutputType>[]
          }
          count: {
            args: Prisma.homeDataCountArgs<ExtArgs>,
            result: $Utils.Optional<HomeDataCountAggregateOutputType> | number
          }
        }
      }
      briefData: {
        payload: Prisma.$briefDataPayload<ExtArgs>
        fields: Prisma.briefDataFieldRefs
        operations: {
          findUnique: {
            args: Prisma.briefDataFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$briefDataPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.briefDataFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$briefDataPayload>
          }
          findFirst: {
            args: Prisma.briefDataFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$briefDataPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.briefDataFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$briefDataPayload>
          }
          findMany: {
            args: Prisma.briefDataFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$briefDataPayload>[]
          }
          create: {
            args: Prisma.briefDataCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$briefDataPayload>
          }
          createMany: {
            args: Prisma.briefDataCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.briefDataDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$briefDataPayload>
          }
          update: {
            args: Prisma.briefDataUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$briefDataPayload>
          }
          deleteMany: {
            args: Prisma.briefDataDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.briefDataUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.briefDataUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$briefDataPayload>
          }
          aggregate: {
            args: Prisma.BriefDataAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateBriefData>
          }
          groupBy: {
            args: Prisma.briefDataGroupByArgs<ExtArgs>,
            result: $Utils.Optional<BriefDataGroupByOutputType>[]
          }
          count: {
            args: Prisma.briefDataCountArgs<ExtArgs>,
            result: $Utils.Optional<BriefDataCountAggregateOutputType> | number
          }
        }
      }
      serviceData: {
        payload: Prisma.$serviceDataPayload<ExtArgs>
        fields: Prisma.serviceDataFieldRefs
        operations: {
          findUnique: {
            args: Prisma.serviceDataFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$serviceDataPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.serviceDataFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$serviceDataPayload>
          }
          findFirst: {
            args: Prisma.serviceDataFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$serviceDataPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.serviceDataFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$serviceDataPayload>
          }
          findMany: {
            args: Prisma.serviceDataFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$serviceDataPayload>[]
          }
          create: {
            args: Prisma.serviceDataCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$serviceDataPayload>
          }
          createMany: {
            args: Prisma.serviceDataCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.serviceDataDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$serviceDataPayload>
          }
          update: {
            args: Prisma.serviceDataUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$serviceDataPayload>
          }
          deleteMany: {
            args: Prisma.serviceDataDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.serviceDataUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.serviceDataUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$serviceDataPayload>
          }
          aggregate: {
            args: Prisma.ServiceDataAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateServiceData>
          }
          groupBy: {
            args: Prisma.serviceDataGroupByArgs<ExtArgs>,
            result: $Utils.Optional<ServiceDataGroupByOutputType>[]
          }
          count: {
            args: Prisma.serviceDataCountArgs<ExtArgs>,
            result: $Utils.Optional<ServiceDataCountAggregateOutputType> | number
          }
        }
      }
      activitiesData: {
        payload: Prisma.$activitiesDataPayload<ExtArgs>
        fields: Prisma.activitiesDataFieldRefs
        operations: {
          findUnique: {
            args: Prisma.activitiesDataFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$activitiesDataPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.activitiesDataFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$activitiesDataPayload>
          }
          findFirst: {
            args: Prisma.activitiesDataFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$activitiesDataPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.activitiesDataFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$activitiesDataPayload>
          }
          findMany: {
            args: Prisma.activitiesDataFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$activitiesDataPayload>[]
          }
          create: {
            args: Prisma.activitiesDataCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$activitiesDataPayload>
          }
          createMany: {
            args: Prisma.activitiesDataCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.activitiesDataDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$activitiesDataPayload>
          }
          update: {
            args: Prisma.activitiesDataUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$activitiesDataPayload>
          }
          deleteMany: {
            args: Prisma.activitiesDataDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.activitiesDataUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.activitiesDataUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$activitiesDataPayload>
          }
          aggregate: {
            args: Prisma.ActivitiesDataAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateActivitiesData>
          }
          groupBy: {
            args: Prisma.activitiesDataGroupByArgs<ExtArgs>,
            result: $Utils.Optional<ActivitiesDataGroupByOutputType>[]
          }
          count: {
            args: Prisma.activitiesDataCountArgs<ExtArgs>,
            result: $Utils.Optional<ActivitiesDataCountAggregateOutputType> | number
          }
        }
      }
      formerChairman: {
        payload: Prisma.$formerChairmanPayload<ExtArgs>
        fields: Prisma.formerChairmanFieldRefs
        operations: {
          findUnique: {
            args: Prisma.formerChairmanFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$formerChairmanPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.formerChairmanFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$formerChairmanPayload>
          }
          findFirst: {
            args: Prisma.formerChairmanFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$formerChairmanPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.formerChairmanFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$formerChairmanPayload>
          }
          findMany: {
            args: Prisma.formerChairmanFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$formerChairmanPayload>[]
          }
          create: {
            args: Prisma.formerChairmanCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$formerChairmanPayload>
          }
          createMany: {
            args: Prisma.formerChairmanCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.formerChairmanDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$formerChairmanPayload>
          }
          update: {
            args: Prisma.formerChairmanUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$formerChairmanPayload>
          }
          deleteMany: {
            args: Prisma.formerChairmanDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.formerChairmanUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.formerChairmanUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$formerChairmanPayload>
          }
          aggregate: {
            args: Prisma.FormerChairmanAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateFormerChairman>
          }
          groupBy: {
            args: Prisma.formerChairmanGroupByArgs<ExtArgs>,
            result: $Utils.Optional<FormerChairmanGroupByOutputType>[]
          }
          count: {
            args: Prisma.formerChairmanCountArgs<ExtArgs>,
            result: $Utils.Optional<FormerChairmanCountAggregateOutputType> | number
          }
        }
      }
      formerSrViceChairman: {
        payload: Prisma.$formerSrViceChairmanPayload<ExtArgs>
        fields: Prisma.formerSrViceChairmanFieldRefs
        operations: {
          findUnique: {
            args: Prisma.formerSrViceChairmanFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$formerSrViceChairmanPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.formerSrViceChairmanFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$formerSrViceChairmanPayload>
          }
          findFirst: {
            args: Prisma.formerSrViceChairmanFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$formerSrViceChairmanPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.formerSrViceChairmanFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$formerSrViceChairmanPayload>
          }
          findMany: {
            args: Prisma.formerSrViceChairmanFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$formerSrViceChairmanPayload>[]
          }
          create: {
            args: Prisma.formerSrViceChairmanCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$formerSrViceChairmanPayload>
          }
          createMany: {
            args: Prisma.formerSrViceChairmanCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.formerSrViceChairmanDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$formerSrViceChairmanPayload>
          }
          update: {
            args: Prisma.formerSrViceChairmanUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$formerSrViceChairmanPayload>
          }
          deleteMany: {
            args: Prisma.formerSrViceChairmanDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.formerSrViceChairmanUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.formerSrViceChairmanUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$formerSrViceChairmanPayload>
          }
          aggregate: {
            args: Prisma.FormerSrViceChairmanAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateFormerSrViceChairman>
          }
          groupBy: {
            args: Prisma.formerSrViceChairmanGroupByArgs<ExtArgs>,
            result: $Utils.Optional<FormerSrViceChairmanGroupByOutputType>[]
          }
          count: {
            args: Prisma.formerSrViceChairmanCountArgs<ExtArgs>,
            result: $Utils.Optional<FormerSrViceChairmanCountAggregateOutputType> | number
          }
        }
      }
      formerViceChairman: {
        payload: Prisma.$formerViceChairmanPayload<ExtArgs>
        fields: Prisma.formerViceChairmanFieldRefs
        operations: {
          findUnique: {
            args: Prisma.formerViceChairmanFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$formerViceChairmanPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.formerViceChairmanFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$formerViceChairmanPayload>
          }
          findFirst: {
            args: Prisma.formerViceChairmanFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$formerViceChairmanPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.formerViceChairmanFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$formerViceChairmanPayload>
          }
          findMany: {
            args: Prisma.formerViceChairmanFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$formerViceChairmanPayload>[]
          }
          create: {
            args: Prisma.formerViceChairmanCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$formerViceChairmanPayload>
          }
          createMany: {
            args: Prisma.formerViceChairmanCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.formerViceChairmanDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$formerViceChairmanPayload>
          }
          update: {
            args: Prisma.formerViceChairmanUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$formerViceChairmanPayload>
          }
          deleteMany: {
            args: Prisma.formerViceChairmanDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.formerViceChairmanUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.formerViceChairmanUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$formerViceChairmanPayload>
          }
          aggregate: {
            args: Prisma.FormerViceChairmanAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateFormerViceChairman>
          }
          groupBy: {
            args: Prisma.formerViceChairmanGroupByArgs<ExtArgs>,
            result: $Utils.Optional<FormerViceChairmanGroupByOutputType>[]
          }
          count: {
            args: Prisma.formerViceChairmanCountArgs<ExtArgs>,
            result: $Utils.Optional<FormerViceChairmanCountAggregateOutputType> | number
          }
        }
      }
      ChairmanProfile: {
        payload: Prisma.$ChairmanProfilePayload<ExtArgs>
        fields: Prisma.ChairmanProfileFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ChairmanProfileFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanProfilePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ChairmanProfileFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanProfilePayload>
          }
          findFirst: {
            args: Prisma.ChairmanProfileFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanProfilePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ChairmanProfileFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanProfilePayload>
          }
          findMany: {
            args: Prisma.ChairmanProfileFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanProfilePayload>[]
          }
          create: {
            args: Prisma.ChairmanProfileCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanProfilePayload>
          }
          createMany: {
            args: Prisma.ChairmanProfileCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.ChairmanProfileDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanProfilePayload>
          }
          update: {
            args: Prisma.ChairmanProfileUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanProfilePayload>
          }
          deleteMany: {
            args: Prisma.ChairmanProfileDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.ChairmanProfileUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.ChairmanProfileUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanProfilePayload>
          }
          aggregate: {
            args: Prisma.ChairmanProfileAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateChairmanProfile>
          }
          groupBy: {
            args: Prisma.ChairmanProfileGroupByArgs<ExtArgs>,
            result: $Utils.Optional<ChairmanProfileGroupByOutputType>[]
          }
          count: {
            args: Prisma.ChairmanProfileCountArgs<ExtArgs>,
            result: $Utils.Optional<ChairmanProfileCountAggregateOutputType> | number
          }
        }
      }
      ChairmanAssociation: {
        payload: Prisma.$ChairmanAssociationPayload<ExtArgs>
        fields: Prisma.ChairmanAssociationFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ChairmanAssociationFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanAssociationPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ChairmanAssociationFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanAssociationPayload>
          }
          findFirst: {
            args: Prisma.ChairmanAssociationFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanAssociationPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ChairmanAssociationFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanAssociationPayload>
          }
          findMany: {
            args: Prisma.ChairmanAssociationFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanAssociationPayload>[]
          }
          create: {
            args: Prisma.ChairmanAssociationCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanAssociationPayload>
          }
          createMany: {
            args: Prisma.ChairmanAssociationCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.ChairmanAssociationDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanAssociationPayload>
          }
          update: {
            args: Prisma.ChairmanAssociationUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanAssociationPayload>
          }
          deleteMany: {
            args: Prisma.ChairmanAssociationDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.ChairmanAssociationUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.ChairmanAssociationUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanAssociationPayload>
          }
          aggregate: {
            args: Prisma.ChairmanAssociationAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateChairmanAssociation>
          }
          groupBy: {
            args: Prisma.ChairmanAssociationGroupByArgs<ExtArgs>,
            result: $Utils.Optional<ChairmanAssociationGroupByOutputType>[]
          }
          count: {
            args: Prisma.ChairmanAssociationCountArgs<ExtArgs>,
            result: $Utils.Optional<ChairmanAssociationCountAggregateOutputType> | number
          }
        }
      }
      ChairmanClubs: {
        payload: Prisma.$ChairmanClubsPayload<ExtArgs>
        fields: Prisma.ChairmanClubsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ChairmanClubsFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanClubsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ChairmanClubsFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanClubsPayload>
          }
          findFirst: {
            args: Prisma.ChairmanClubsFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanClubsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ChairmanClubsFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanClubsPayload>
          }
          findMany: {
            args: Prisma.ChairmanClubsFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanClubsPayload>[]
          }
          create: {
            args: Prisma.ChairmanClubsCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanClubsPayload>
          }
          createMany: {
            args: Prisma.ChairmanClubsCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.ChairmanClubsDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanClubsPayload>
          }
          update: {
            args: Prisma.ChairmanClubsUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanClubsPayload>
          }
          deleteMany: {
            args: Prisma.ChairmanClubsDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.ChairmanClubsUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.ChairmanClubsUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanClubsPayload>
          }
          aggregate: {
            args: Prisma.ChairmanClubsAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateChairmanClubs>
          }
          groupBy: {
            args: Prisma.ChairmanClubsGroupByArgs<ExtArgs>,
            result: $Utils.Optional<ChairmanClubsGroupByOutputType>[]
          }
          count: {
            args: Prisma.ChairmanClubsCountArgs<ExtArgs>,
            result: $Utils.Optional<ChairmanClubsCountAggregateOutputType> | number
          }
        }
      }
      ChairmanMessage: {
        payload: Prisma.$ChairmanMessagePayload<ExtArgs>
        fields: Prisma.ChairmanMessageFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ChairmanMessageFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanMessagePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ChairmanMessageFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanMessagePayload>
          }
          findFirst: {
            args: Prisma.ChairmanMessageFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanMessagePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ChairmanMessageFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanMessagePayload>
          }
          findMany: {
            args: Prisma.ChairmanMessageFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanMessagePayload>[]
          }
          create: {
            args: Prisma.ChairmanMessageCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanMessagePayload>
          }
          createMany: {
            args: Prisma.ChairmanMessageCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.ChairmanMessageDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanMessagePayload>
          }
          update: {
            args: Prisma.ChairmanMessageUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanMessagePayload>
          }
          deleteMany: {
            args: Prisma.ChairmanMessageDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.ChairmanMessageUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.ChairmanMessageUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanMessagePayload>
          }
          aggregate: {
            args: Prisma.ChairmanMessageAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateChairmanMessage>
          }
          groupBy: {
            args: Prisma.ChairmanMessageGroupByArgs<ExtArgs>,
            result: $Utils.Optional<ChairmanMessageGroupByOutputType>[]
          }
          count: {
            args: Prisma.ChairmanMessageCountArgs<ExtArgs>,
            result: $Utils.Optional<ChairmanMessageCountAggregateOutputType> | number
          }
        }
      }
      ChairmanSpeech: {
        payload: Prisma.$ChairmanSpeechPayload<ExtArgs>
        fields: Prisma.ChairmanSpeechFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ChairmanSpeechFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanSpeechPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ChairmanSpeechFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanSpeechPayload>
          }
          findFirst: {
            args: Prisma.ChairmanSpeechFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanSpeechPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ChairmanSpeechFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanSpeechPayload>
          }
          findMany: {
            args: Prisma.ChairmanSpeechFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanSpeechPayload>[]
          }
          create: {
            args: Prisma.ChairmanSpeechCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanSpeechPayload>
          }
          createMany: {
            args: Prisma.ChairmanSpeechCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.ChairmanSpeechDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanSpeechPayload>
          }
          update: {
            args: Prisma.ChairmanSpeechUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanSpeechPayload>
          }
          deleteMany: {
            args: Prisma.ChairmanSpeechDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.ChairmanSpeechUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.ChairmanSpeechUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanSpeechPayload>
          }
          aggregate: {
            args: Prisma.ChairmanSpeechAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateChairmanSpeech>
          }
          groupBy: {
            args: Prisma.ChairmanSpeechGroupByArgs<ExtArgs>,
            result: $Utils.Optional<ChairmanSpeechGroupByOutputType>[]
          }
          count: {
            args: Prisma.ChairmanSpeechCountArgs<ExtArgs>,
            result: $Utils.Optional<ChairmanSpeechCountAggregateOutputType> | number
          }
        }
      }
      ChairmanInterviewPrint: {
        payload: Prisma.$ChairmanInterviewPrintPayload<ExtArgs>
        fields: Prisma.ChairmanInterviewPrintFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ChairmanInterviewPrintFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanInterviewPrintPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ChairmanInterviewPrintFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanInterviewPrintPayload>
          }
          findFirst: {
            args: Prisma.ChairmanInterviewPrintFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanInterviewPrintPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ChairmanInterviewPrintFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanInterviewPrintPayload>
          }
          findMany: {
            args: Prisma.ChairmanInterviewPrintFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanInterviewPrintPayload>[]
          }
          create: {
            args: Prisma.ChairmanInterviewPrintCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanInterviewPrintPayload>
          }
          createMany: {
            args: Prisma.ChairmanInterviewPrintCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.ChairmanInterviewPrintDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanInterviewPrintPayload>
          }
          update: {
            args: Prisma.ChairmanInterviewPrintUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanInterviewPrintPayload>
          }
          deleteMany: {
            args: Prisma.ChairmanInterviewPrintDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.ChairmanInterviewPrintUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.ChairmanInterviewPrintUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanInterviewPrintPayload>
          }
          aggregate: {
            args: Prisma.ChairmanInterviewPrintAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateChairmanInterviewPrint>
          }
          groupBy: {
            args: Prisma.ChairmanInterviewPrintGroupByArgs<ExtArgs>,
            result: $Utils.Optional<ChairmanInterviewPrintGroupByOutputType>[]
          }
          count: {
            args: Prisma.ChairmanInterviewPrintCountArgs<ExtArgs>,
            result: $Utils.Optional<ChairmanInterviewPrintCountAggregateOutputType> | number
          }
        }
      }
      ChairmanInterviewElectronic: {
        payload: Prisma.$ChairmanInterviewElectronicPayload<ExtArgs>
        fields: Prisma.ChairmanInterviewElectronicFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ChairmanInterviewElectronicFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanInterviewElectronicPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ChairmanInterviewElectronicFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanInterviewElectronicPayload>
          }
          findFirst: {
            args: Prisma.ChairmanInterviewElectronicFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanInterviewElectronicPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ChairmanInterviewElectronicFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanInterviewElectronicPayload>
          }
          findMany: {
            args: Prisma.ChairmanInterviewElectronicFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanInterviewElectronicPayload>[]
          }
          create: {
            args: Prisma.ChairmanInterviewElectronicCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanInterviewElectronicPayload>
          }
          createMany: {
            args: Prisma.ChairmanInterviewElectronicCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.ChairmanInterviewElectronicDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanInterviewElectronicPayload>
          }
          update: {
            args: Prisma.ChairmanInterviewElectronicUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanInterviewElectronicPayload>
          }
          deleteMany: {
            args: Prisma.ChairmanInterviewElectronicDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.ChairmanInterviewElectronicUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.ChairmanInterviewElectronicUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanInterviewElectronicPayload>
          }
          aggregate: {
            args: Prisma.ChairmanInterviewElectronicAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateChairmanInterviewElectronic>
          }
          groupBy: {
            args: Prisma.ChairmanInterviewElectronicGroupByArgs<ExtArgs>,
            result: $Utils.Optional<ChairmanInterviewElectronicGroupByOutputType>[]
          }
          count: {
            args: Prisma.ChairmanInterviewElectronicCountArgs<ExtArgs>,
            result: $Utils.Optional<ChairmanInterviewElectronicCountAggregateOutputType> | number
          }
        }
      }
      ChairmanPresentation: {
        payload: Prisma.$ChairmanPresentationPayload<ExtArgs>
        fields: Prisma.ChairmanPresentationFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ChairmanPresentationFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanPresentationPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ChairmanPresentationFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanPresentationPayload>
          }
          findFirst: {
            args: Prisma.ChairmanPresentationFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanPresentationPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ChairmanPresentationFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanPresentationPayload>
          }
          findMany: {
            args: Prisma.ChairmanPresentationFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanPresentationPayload>[]
          }
          create: {
            args: Prisma.ChairmanPresentationCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanPresentationPayload>
          }
          createMany: {
            args: Prisma.ChairmanPresentationCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.ChairmanPresentationDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanPresentationPayload>
          }
          update: {
            args: Prisma.ChairmanPresentationUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanPresentationPayload>
          }
          deleteMany: {
            args: Prisma.ChairmanPresentationDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.ChairmanPresentationUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.ChairmanPresentationUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ChairmanPresentationPayload>
          }
          aggregate: {
            args: Prisma.ChairmanPresentationAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateChairmanPresentation>
          }
          groupBy: {
            args: Prisma.ChairmanPresentationGroupByArgs<ExtArgs>,
            result: $Utils.Optional<ChairmanPresentationGroupByOutputType>[]
          }
          count: {
            args: Prisma.ChairmanPresentationCountArgs<ExtArgs>,
            result: $Utils.Optional<ChairmanPresentationCountAggregateOutputType> | number
          }
        }
      }
      memorandum: {
        payload: Prisma.$memorandumPayload<ExtArgs>
        fields: Prisma.memorandumFieldRefs
        operations: {
          findUnique: {
            args: Prisma.memorandumFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$memorandumPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.memorandumFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$memorandumPayload>
          }
          findFirst: {
            args: Prisma.memorandumFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$memorandumPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.memorandumFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$memorandumPayload>
          }
          findMany: {
            args: Prisma.memorandumFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$memorandumPayload>[]
          }
          create: {
            args: Prisma.memorandumCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$memorandumPayload>
          }
          createMany: {
            args: Prisma.memorandumCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.memorandumDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$memorandumPayload>
          }
          update: {
            args: Prisma.memorandumUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$memorandumPayload>
          }
          deleteMany: {
            args: Prisma.memorandumDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.memorandumUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.memorandumUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$memorandumPayload>
          }
          aggregate: {
            args: Prisma.MemorandumAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateMemorandum>
          }
          groupBy: {
            args: Prisma.memorandumGroupByArgs<ExtArgs>,
            result: $Utils.Optional<MemorandumGroupByOutputType>[]
          }
          count: {
            args: Prisma.memorandumCountArgs<ExtArgs>,
            result: $Utils.Optional<MemorandumCountAggregateOutputType> | number
          }
        }
      }
      BoardOfDirectors: {
        payload: Prisma.$BoardOfDirectorsPayload<ExtArgs>
        fields: Prisma.BoardOfDirectorsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.BoardOfDirectorsFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$BoardOfDirectorsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.BoardOfDirectorsFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$BoardOfDirectorsPayload>
          }
          findFirst: {
            args: Prisma.BoardOfDirectorsFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$BoardOfDirectorsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.BoardOfDirectorsFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$BoardOfDirectorsPayload>
          }
          findMany: {
            args: Prisma.BoardOfDirectorsFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$BoardOfDirectorsPayload>[]
          }
          create: {
            args: Prisma.BoardOfDirectorsCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$BoardOfDirectorsPayload>
          }
          createMany: {
            args: Prisma.BoardOfDirectorsCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.BoardOfDirectorsDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$BoardOfDirectorsPayload>
          }
          update: {
            args: Prisma.BoardOfDirectorsUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$BoardOfDirectorsPayload>
          }
          deleteMany: {
            args: Prisma.BoardOfDirectorsDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.BoardOfDirectorsUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.BoardOfDirectorsUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$BoardOfDirectorsPayload>
          }
          aggregate: {
            args: Prisma.BoardOfDirectorsAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateBoardOfDirectors>
          }
          groupBy: {
            args: Prisma.BoardOfDirectorsGroupByArgs<ExtArgs>,
            result: $Utils.Optional<BoardOfDirectorsGroupByOutputType>[]
          }
          count: {
            args: Prisma.BoardOfDirectorsCountArgs<ExtArgs>,
            result: $Utils.Optional<BoardOfDirectorsCountAggregateOutputType> | number
          }
        }
      }
      ShippersNews: {
        payload: Prisma.$ShippersNewsPayload<ExtArgs>
        fields: Prisma.ShippersNewsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ShippersNewsFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ShippersNewsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ShippersNewsFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ShippersNewsPayload>
          }
          findFirst: {
            args: Prisma.ShippersNewsFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ShippersNewsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ShippersNewsFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ShippersNewsPayload>
          }
          findMany: {
            args: Prisma.ShippersNewsFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ShippersNewsPayload>[]
          }
          create: {
            args: Prisma.ShippersNewsCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ShippersNewsPayload>
          }
          createMany: {
            args: Prisma.ShippersNewsCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.ShippersNewsDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ShippersNewsPayload>
          }
          update: {
            args: Prisma.ShippersNewsUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ShippersNewsPayload>
          }
          deleteMany: {
            args: Prisma.ShippersNewsDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.ShippersNewsUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.ShippersNewsUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ShippersNewsPayload>
          }
          aggregate: {
            args: Prisma.ShippersNewsAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateShippersNews>
          }
          groupBy: {
            args: Prisma.ShippersNewsGroupByArgs<ExtArgs>,
            result: $Utils.Optional<ShippersNewsGroupByOutputType>[]
          }
          count: {
            args: Prisma.ShippersNewsCountArgs<ExtArgs>,
            result: $Utils.Optional<ShippersNewsCountAggregateOutputType> | number
          }
        }
      }
      AnnualReport: {
        payload: Prisma.$AnnualReportPayload<ExtArgs>
        fields: Prisma.AnnualReportFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AnnualReportFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AnnualReportPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AnnualReportFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AnnualReportPayload>
          }
          findFirst: {
            args: Prisma.AnnualReportFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AnnualReportPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AnnualReportFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AnnualReportPayload>
          }
          findMany: {
            args: Prisma.AnnualReportFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AnnualReportPayload>[]
          }
          create: {
            args: Prisma.AnnualReportCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AnnualReportPayload>
          }
          createMany: {
            args: Prisma.AnnualReportCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.AnnualReportDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AnnualReportPayload>
          }
          update: {
            args: Prisma.AnnualReportUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AnnualReportPayload>
          }
          deleteMany: {
            args: Prisma.AnnualReportDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.AnnualReportUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.AnnualReportUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AnnualReportPayload>
          }
          aggregate: {
            args: Prisma.AnnualReportAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateAnnualReport>
          }
          groupBy: {
            args: Prisma.AnnualReportGroupByArgs<ExtArgs>,
            result: $Utils.Optional<AnnualReportGroupByOutputType>[]
          }
          count: {
            args: Prisma.AnnualReportCountArgs<ExtArgs>,
            result: $Utils.Optional<AnnualReportCountAggregateOutputType> | number
          }
        }
      }
      OtherPublications: {
        payload: Prisma.$OtherPublicationsPayload<ExtArgs>
        fields: Prisma.OtherPublicationsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.OtherPublicationsFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OtherPublicationsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.OtherPublicationsFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OtherPublicationsPayload>
          }
          findFirst: {
            args: Prisma.OtherPublicationsFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OtherPublicationsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.OtherPublicationsFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OtherPublicationsPayload>
          }
          findMany: {
            args: Prisma.OtherPublicationsFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OtherPublicationsPayload>[]
          }
          create: {
            args: Prisma.OtherPublicationsCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OtherPublicationsPayload>
          }
          createMany: {
            args: Prisma.OtherPublicationsCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.OtherPublicationsDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OtherPublicationsPayload>
          }
          update: {
            args: Prisma.OtherPublicationsUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OtherPublicationsPayload>
          }
          deleteMany: {
            args: Prisma.OtherPublicationsDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.OtherPublicationsUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.OtherPublicationsUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$OtherPublicationsPayload>
          }
          aggregate: {
            args: Prisma.OtherPublicationsAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateOtherPublications>
          }
          groupBy: {
            args: Prisma.OtherPublicationsGroupByArgs<ExtArgs>,
            result: $Utils.Optional<OtherPublicationsGroupByOutputType>[]
          }
          count: {
            args: Prisma.OtherPublicationsCountArgs<ExtArgs>,
            result: $Utils.Optional<OtherPublicationsCountAggregateOutputType> | number
          }
        }
      }
      SCBRecommendations: {
        payload: Prisma.$SCBRecommendationsPayload<ExtArgs>
        fields: Prisma.SCBRecommendationsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.SCBRecommendationsFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SCBRecommendationsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.SCBRecommendationsFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SCBRecommendationsPayload>
          }
          findFirst: {
            args: Prisma.SCBRecommendationsFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SCBRecommendationsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.SCBRecommendationsFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SCBRecommendationsPayload>
          }
          findMany: {
            args: Prisma.SCBRecommendationsFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SCBRecommendationsPayload>[]
          }
          create: {
            args: Prisma.SCBRecommendationsCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SCBRecommendationsPayload>
          }
          createMany: {
            args: Prisma.SCBRecommendationsCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.SCBRecommendationsDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SCBRecommendationsPayload>
          }
          update: {
            args: Prisma.SCBRecommendationsUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SCBRecommendationsPayload>
          }
          deleteMany: {
            args: Prisma.SCBRecommendationsDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.SCBRecommendationsUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.SCBRecommendationsUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SCBRecommendationsPayload>
          }
          aggregate: {
            args: Prisma.SCBRecommendationsAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateSCBRecommendations>
          }
          groupBy: {
            args: Prisma.SCBRecommendationsGroupByArgs<ExtArgs>,
            result: $Utils.Optional<SCBRecommendationsGroupByOutputType>[]
          }
          count: {
            args: Prisma.SCBRecommendationsCountArgs<ExtArgs>,
            result: $Utils.Optional<SCBRecommendationsCountAggregateOutputType> | number
          }
        }
      }
      SCBSeminar: {
        payload: Prisma.$SCBSeminarPayload<ExtArgs>
        fields: Prisma.SCBSeminarFieldRefs
        operations: {
          findUnique: {
            args: Prisma.SCBSeminarFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SCBSeminarPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.SCBSeminarFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SCBSeminarPayload>
          }
          findFirst: {
            args: Prisma.SCBSeminarFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SCBSeminarPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.SCBSeminarFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SCBSeminarPayload>
          }
          findMany: {
            args: Prisma.SCBSeminarFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SCBSeminarPayload>[]
          }
          create: {
            args: Prisma.SCBSeminarCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SCBSeminarPayload>
          }
          createMany: {
            args: Prisma.SCBSeminarCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.SCBSeminarDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SCBSeminarPayload>
          }
          update: {
            args: Prisma.SCBSeminarUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SCBSeminarPayload>
          }
          deleteMany: {
            args: Prisma.SCBSeminarDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.SCBSeminarUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.SCBSeminarUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SCBSeminarPayload>
          }
          aggregate: {
            args: Prisma.SCBSeminarAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateSCBSeminar>
          }
          groupBy: {
            args: Prisma.SCBSeminarGroupByArgs<ExtArgs>,
            result: $Utils.Optional<SCBSeminarGroupByOutputType>[]
          }
          count: {
            args: Prisma.SCBSeminarCountArgs<ExtArgs>,
            result: $Utils.Optional<SCBSeminarCountAggregateOutputType> | number
          }
        }
      }
      Eligibility: {
        payload: Prisma.$EligibilityPayload<ExtArgs>
        fields: Prisma.EligibilityFieldRefs
        operations: {
          findUnique: {
            args: Prisma.EligibilityFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EligibilityPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.EligibilityFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EligibilityPayload>
          }
          findFirst: {
            args: Prisma.EligibilityFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EligibilityPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.EligibilityFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EligibilityPayload>
          }
          findMany: {
            args: Prisma.EligibilityFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EligibilityPayload>[]
          }
          create: {
            args: Prisma.EligibilityCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EligibilityPayload>
          }
          createMany: {
            args: Prisma.EligibilityCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.EligibilityDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EligibilityPayload>
          }
          update: {
            args: Prisma.EligibilityUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EligibilityPayload>
          }
          deleteMany: {
            args: Prisma.EligibilityDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.EligibilityUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.EligibilityUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$EligibilityPayload>
          }
          aggregate: {
            args: Prisma.EligibilityAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateEligibility>
          }
          groupBy: {
            args: Prisma.EligibilityGroupByArgs<ExtArgs>,
            result: $Utils.Optional<EligibilityGroupByOutputType>[]
          }
          count: {
            args: Prisma.EligibilityCountArgs<ExtArgs>,
            result: $Utils.Optional<EligibilityCountAggregateOutputType> | number
          }
        }
      }
      RelevantPapers: {
        payload: Prisma.$RelevantPapersPayload<ExtArgs>
        fields: Prisma.RelevantPapersFieldRefs
        operations: {
          findUnique: {
            args: Prisma.RelevantPapersFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$RelevantPapersPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.RelevantPapersFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$RelevantPapersPayload>
          }
          findFirst: {
            args: Prisma.RelevantPapersFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$RelevantPapersPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.RelevantPapersFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$RelevantPapersPayload>
          }
          findMany: {
            args: Prisma.RelevantPapersFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$RelevantPapersPayload>[]
          }
          create: {
            args: Prisma.RelevantPapersCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$RelevantPapersPayload>
          }
          createMany: {
            args: Prisma.RelevantPapersCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.RelevantPapersDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$RelevantPapersPayload>
          }
          update: {
            args: Prisma.RelevantPapersUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$RelevantPapersPayload>
          }
          deleteMany: {
            args: Prisma.RelevantPapersDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.RelevantPapersUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.RelevantPapersUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$RelevantPapersPayload>
          }
          aggregate: {
            args: Prisma.RelevantPapersAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateRelevantPapers>
          }
          groupBy: {
            args: Prisma.RelevantPapersGroupByArgs<ExtArgs>,
            result: $Utils.Optional<RelevantPapersGroupByOutputType>[]
          }
          count: {
            args: Prisma.RelevantPapersCountArgs<ExtArgs>,
            result: $Utils.Optional<RelevantPapersCountAggregateOutputType> | number
          }
        }
      }
      MembersList: {
        payload: Prisma.$MembersListPayload<ExtArgs>
        fields: Prisma.MembersListFieldRefs
        operations: {
          findUnique: {
            args: Prisma.MembersListFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MembersListPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.MembersListFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MembersListPayload>
          }
          findFirst: {
            args: Prisma.MembersListFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MembersListPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.MembersListFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MembersListPayload>
          }
          findMany: {
            args: Prisma.MembersListFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MembersListPayload>[]
          }
          create: {
            args: Prisma.MembersListCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MembersListPayload>
          }
          createMany: {
            args: Prisma.MembersListCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.MembersListDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MembersListPayload>
          }
          update: {
            args: Prisma.MembersListUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MembersListPayload>
          }
          deleteMany: {
            args: Prisma.MembersListDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.MembersListUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.MembersListUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MembersListPayload>
          }
          aggregate: {
            args: Prisma.MembersListAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateMembersList>
          }
          groupBy: {
            args: Prisma.MembersListGroupByArgs<ExtArgs>,
            result: $Utils.Optional<MembersListGroupByOutputType>[]
          }
          count: {
            args: Prisma.MembersListCountArgs<ExtArgs>,
            result: $Utils.Optional<MembersListCountAggregateOutputType> | number
          }
        }
      }
      UsefulLinks: {
        payload: Prisma.$UsefulLinksPayload<ExtArgs>
        fields: Prisma.UsefulLinksFieldRefs
        operations: {
          findUnique: {
            args: Prisma.UsefulLinksFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$UsefulLinksPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.UsefulLinksFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$UsefulLinksPayload>
          }
          findFirst: {
            args: Prisma.UsefulLinksFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$UsefulLinksPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.UsefulLinksFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$UsefulLinksPayload>
          }
          findMany: {
            args: Prisma.UsefulLinksFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$UsefulLinksPayload>[]
          }
          create: {
            args: Prisma.UsefulLinksCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$UsefulLinksPayload>
          }
          createMany: {
            args: Prisma.UsefulLinksCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.UsefulLinksDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$UsefulLinksPayload>
          }
          update: {
            args: Prisma.UsefulLinksUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$UsefulLinksPayload>
          }
          deleteMany: {
            args: Prisma.UsefulLinksDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.UsefulLinksUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.UsefulLinksUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$UsefulLinksPayload>
          }
          aggregate: {
            args: Prisma.UsefulLinksAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateUsefulLinks>
          }
          groupBy: {
            args: Prisma.UsefulLinksGroupByArgs<ExtArgs>,
            result: $Utils.Optional<UsefulLinksGroupByOutputType>[]
          }
          count: {
            args: Prisma.UsefulLinksCountArgs<ExtArgs>,
            result: $Utils.Optional<UsefulLinksCountAggregateOutputType> | number
          }
        }
      }
      ContactUs: {
        payload: Prisma.$ContactUsPayload<ExtArgs>
        fields: Prisma.ContactUsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ContactUsFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ContactUsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ContactUsFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ContactUsPayload>
          }
          findFirst: {
            args: Prisma.ContactUsFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ContactUsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ContactUsFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ContactUsPayload>
          }
          findMany: {
            args: Prisma.ContactUsFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ContactUsPayload>[]
          }
          create: {
            args: Prisma.ContactUsCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ContactUsPayload>
          }
          createMany: {
            args: Prisma.ContactUsCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.ContactUsDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ContactUsPayload>
          }
          update: {
            args: Prisma.ContactUsUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ContactUsPayload>
          }
          deleteMany: {
            args: Prisma.ContactUsDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.ContactUsUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.ContactUsUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ContactUsPayload>
          }
          aggregate: {
            args: Prisma.ContactUsAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateContactUs>
          }
          groupBy: {
            args: Prisma.ContactUsGroupByArgs<ExtArgs>,
            result: $Utils.Optional<ContactUsGroupByOutputType>[]
          }
          count: {
            args: Prisma.ContactUsCountArgs<ExtArgs>,
            result: $Utils.Optional<ContactUsCountAggregateOutputType> | number
          }
        }
      }
      Secretariat: {
        payload: Prisma.$SecretariatPayload<ExtArgs>
        fields: Prisma.SecretariatFieldRefs
        operations: {
          findUnique: {
            args: Prisma.SecretariatFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SecretariatPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.SecretariatFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SecretariatPayload>
          }
          findFirst: {
            args: Prisma.SecretariatFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SecretariatPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.SecretariatFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SecretariatPayload>
          }
          findMany: {
            args: Prisma.SecretariatFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SecretariatPayload>[]
          }
          create: {
            args: Prisma.SecretariatCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SecretariatPayload>
          }
          createMany: {
            args: Prisma.SecretariatCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.SecretariatDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SecretariatPayload>
          }
          update: {
            args: Prisma.SecretariatUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SecretariatPayload>
          }
          deleteMany: {
            args: Prisma.SecretariatDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.SecretariatUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.SecretariatUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SecretariatPayload>
          }
          aggregate: {
            args: Prisma.SecretariatAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateSecretariat>
          }
          groupBy: {
            args: Prisma.SecretariatGroupByArgs<ExtArgs>,
            result: $Utils.Optional<SecretariatGroupByOutputType>[]
          }
          count: {
            args: Prisma.SecretariatCountArgs<ExtArgs>,
            result: $Utils.Optional<SecretariatCountAggregateOutputType> | number
          }
        }
      }
      PDFs: {
        payload: Prisma.$PDFsPayload<ExtArgs>
        fields: Prisma.PDFsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.PDFsFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$PDFsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.PDFsFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$PDFsPayload>
          }
          findFirst: {
            args: Prisma.PDFsFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$PDFsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.PDFsFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$PDFsPayload>
          }
          findMany: {
            args: Prisma.PDFsFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$PDFsPayload>[]
          }
          create: {
            args: Prisma.PDFsCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$PDFsPayload>
          }
          createMany: {
            args: Prisma.PDFsCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.PDFsDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$PDFsPayload>
          }
          update: {
            args: Prisma.PDFsUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$PDFsPayload>
          }
          deleteMany: {
            args: Prisma.PDFsDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.PDFsUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.PDFsUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$PDFsPayload>
          }
          aggregate: {
            args: Prisma.PDFsAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregatePDFs>
          }
          groupBy: {
            args: Prisma.PDFsGroupByArgs<ExtArgs>,
            result: $Utils.Optional<PDFsGroupByOutputType>[]
          }
          count: {
            args: Prisma.PDFsCountArgs<ExtArgs>,
            result: $Utils.Optional<PDFsCountAggregateOutputType> | number
          }
        }
      }
      Forms: {
        payload: Prisma.$FormsPayload<ExtArgs>
        fields: Prisma.FormsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.FormsFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$FormsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.FormsFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$FormsPayload>
          }
          findFirst: {
            args: Prisma.FormsFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$FormsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.FormsFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$FormsPayload>
          }
          findMany: {
            args: Prisma.FormsFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$FormsPayload>[]
          }
          create: {
            args: Prisma.FormsCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$FormsPayload>
          }
          createMany: {
            args: Prisma.FormsCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.FormsDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$FormsPayload>
          }
          update: {
            args: Prisma.FormsUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$FormsPayload>
          }
          deleteMany: {
            args: Prisma.FormsDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.FormsUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.FormsUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$FormsPayload>
          }
          aggregate: {
            args: Prisma.FormsAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateForms>
          }
          groupBy: {
            args: Prisma.FormsGroupByArgs<ExtArgs>,
            result: $Utils.Optional<FormsGroupByOutputType>[]
          }
          count: {
            args: Prisma.FormsCountArgs<ExtArgs>,
            result: $Utils.Optional<FormsCountAggregateOutputType> | number
          }
        }
      }
      MembershipText: {
        payload: Prisma.$MembershipTextPayload<ExtArgs>
        fields: Prisma.MembershipTextFieldRefs
        operations: {
          findUnique: {
            args: Prisma.MembershipTextFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MembershipTextPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.MembershipTextFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MembershipTextPayload>
          }
          findFirst: {
            args: Prisma.MembershipTextFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MembershipTextPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.MembershipTextFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MembershipTextPayload>
          }
          findMany: {
            args: Prisma.MembershipTextFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MembershipTextPayload>[]
          }
          create: {
            args: Prisma.MembershipTextCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MembershipTextPayload>
          }
          createMany: {
            args: Prisma.MembershipTextCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.MembershipTextDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MembershipTextPayload>
          }
          update: {
            args: Prisma.MembershipTextUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MembershipTextPayload>
          }
          deleteMany: {
            args: Prisma.MembershipTextDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.MembershipTextUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.MembershipTextUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MembershipTextPayload>
          }
          aggregate: {
            args: Prisma.MembershipTextAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateMembershipText>
          }
          groupBy: {
            args: Prisma.MembershipTextGroupByArgs<ExtArgs>,
            result: $Utils.Optional<MembershipTextGroupByOutputType>[]
          }
          count: {
            args: Prisma.MembershipTextCountArgs<ExtArgs>,
            result: $Utils.Optional<MembershipTextCountAggregateOutputType> | number
          }
        }
      }
      ApplicationProcedure: {
        payload: Prisma.$ApplicationProcedurePayload<ExtArgs>
        fields: Prisma.ApplicationProcedureFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ApplicationProcedureFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ApplicationProcedurePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ApplicationProcedureFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ApplicationProcedurePayload>
          }
          findFirst: {
            args: Prisma.ApplicationProcedureFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ApplicationProcedurePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ApplicationProcedureFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ApplicationProcedurePayload>
          }
          findMany: {
            args: Prisma.ApplicationProcedureFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ApplicationProcedurePayload>[]
          }
          create: {
            args: Prisma.ApplicationProcedureCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ApplicationProcedurePayload>
          }
          createMany: {
            args: Prisma.ApplicationProcedureCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.ApplicationProcedureDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ApplicationProcedurePayload>
          }
          update: {
            args: Prisma.ApplicationProcedureUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ApplicationProcedurePayload>
          }
          deleteMany: {
            args: Prisma.ApplicationProcedureDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.ApplicationProcedureUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.ApplicationProcedureUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$ApplicationProcedurePayload>
          }
          aggregate: {
            args: Prisma.ApplicationProcedureAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateApplicationProcedure>
          }
          groupBy: {
            args: Prisma.ApplicationProcedureGroupByArgs<ExtArgs>,
            result: $Utils.Optional<ApplicationProcedureGroupByOutputType>[]
          }
          count: {
            args: Prisma.ApplicationProcedureCountArgs<ExtArgs>,
            result: $Utils.Optional<ApplicationProcedureCountAggregateOutputType> | number
          }
        }
      }
      Benefits: {
        payload: Prisma.$BenefitsPayload<ExtArgs>
        fields: Prisma.BenefitsFieldRefs
        operations: {
          findUnique: {
            args: Prisma.BenefitsFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$BenefitsPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.BenefitsFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$BenefitsPayload>
          }
          findFirst: {
            args: Prisma.BenefitsFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$BenefitsPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.BenefitsFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$BenefitsPayload>
          }
          findMany: {
            args: Prisma.BenefitsFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$BenefitsPayload>[]
          }
          create: {
            args: Prisma.BenefitsCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$BenefitsPayload>
          }
          createMany: {
            args: Prisma.BenefitsCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.BenefitsDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$BenefitsPayload>
          }
          update: {
            args: Prisma.BenefitsUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$BenefitsPayload>
          }
          deleteMany: {
            args: Prisma.BenefitsDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.BenefitsUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.BenefitsUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$BenefitsPayload>
          }
          aggregate: {
            args: Prisma.BenefitsAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateBenefits>
          }
          groupBy: {
            args: Prisma.BenefitsGroupByArgs<ExtArgs>,
            result: $Utils.Optional<BenefitsGroupByOutputType>[]
          }
          count: {
            args: Prisma.BenefitsCountArgs<ExtArgs>,
            result: $Utils.Optional<BenefitsCountAggregateOutputType> | number
          }
        }
      }
      PhotoAlbum: {
        payload: Prisma.$PhotoAlbumPayload<ExtArgs>
        fields: Prisma.PhotoAlbumFieldRefs
        operations: {
          findUnique: {
            args: Prisma.PhotoAlbumFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$PhotoAlbumPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.PhotoAlbumFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$PhotoAlbumPayload>
          }
          findFirst: {
            args: Prisma.PhotoAlbumFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$PhotoAlbumPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.PhotoAlbumFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$PhotoAlbumPayload>
          }
          findMany: {
            args: Prisma.PhotoAlbumFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$PhotoAlbumPayload>[]
          }
          create: {
            args: Prisma.PhotoAlbumCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$PhotoAlbumPayload>
          }
          createMany: {
            args: Prisma.PhotoAlbumCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.PhotoAlbumDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$PhotoAlbumPayload>
          }
          update: {
            args: Prisma.PhotoAlbumUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$PhotoAlbumPayload>
          }
          deleteMany: {
            args: Prisma.PhotoAlbumDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.PhotoAlbumUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.PhotoAlbumUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$PhotoAlbumPayload>
          }
          aggregate: {
            args: Prisma.PhotoAlbumAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregatePhotoAlbum>
          }
          groupBy: {
            args: Prisma.PhotoAlbumGroupByArgs<ExtArgs>,
            result: $Utils.Optional<PhotoAlbumGroupByOutputType>[]
          }
          count: {
            args: Prisma.PhotoAlbumCountArgs<ExtArgs>,
            result: $Utils.Optional<PhotoAlbumCountAggregateOutputType> | number
          }
        }
      }
      GalleryPhoto: {
        payload: Prisma.$GalleryPhotoPayload<ExtArgs>
        fields: Prisma.GalleryPhotoFieldRefs
        operations: {
          findUnique: {
            args: Prisma.GalleryPhotoFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$GalleryPhotoPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.GalleryPhotoFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$GalleryPhotoPayload>
          }
          findFirst: {
            args: Prisma.GalleryPhotoFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$GalleryPhotoPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.GalleryPhotoFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$GalleryPhotoPayload>
          }
          findMany: {
            args: Prisma.GalleryPhotoFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$GalleryPhotoPayload>[]
          }
          create: {
            args: Prisma.GalleryPhotoCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$GalleryPhotoPayload>
          }
          createMany: {
            args: Prisma.GalleryPhotoCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.GalleryPhotoDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$GalleryPhotoPayload>
          }
          update: {
            args: Prisma.GalleryPhotoUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$GalleryPhotoPayload>
          }
          deleteMany: {
            args: Prisma.GalleryPhotoDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.GalleryPhotoUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.GalleryPhotoUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$GalleryPhotoPayload>
          }
          aggregate: {
            args: Prisma.GalleryPhotoAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateGalleryPhoto>
          }
          groupBy: {
            args: Prisma.GalleryPhotoGroupByArgs<ExtArgs>,
            result: $Utils.Optional<GalleryPhotoGroupByOutputType>[]
          }
          count: {
            args: Prisma.GalleryPhotoCountArgs<ExtArgs>,
            result: $Utils.Optional<GalleryPhotoCountAggregateOutputType> | number
          }
        }
      }
      GalleryVideo: {
        payload: Prisma.$GalleryVideoPayload<ExtArgs>
        fields: Prisma.GalleryVideoFieldRefs
        operations: {
          findUnique: {
            args: Prisma.GalleryVideoFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$GalleryVideoPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.GalleryVideoFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$GalleryVideoPayload>
          }
          findFirst: {
            args: Prisma.GalleryVideoFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$GalleryVideoPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.GalleryVideoFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$GalleryVideoPayload>
          }
          findMany: {
            args: Prisma.GalleryVideoFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$GalleryVideoPayload>[]
          }
          create: {
            args: Prisma.GalleryVideoCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$GalleryVideoPayload>
          }
          createMany: {
            args: Prisma.GalleryVideoCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.GalleryVideoDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$GalleryVideoPayload>
          }
          update: {
            args: Prisma.GalleryVideoUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$GalleryVideoPayload>
          }
          deleteMany: {
            args: Prisma.GalleryVideoDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.GalleryVideoUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.GalleryVideoUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$GalleryVideoPayload>
          }
          aggregate: {
            args: Prisma.GalleryVideoAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateGalleryVideo>
          }
          groupBy: {
            args: Prisma.GalleryVideoGroupByArgs<ExtArgs>,
            result: $Utils.Optional<GalleryVideoGroupByOutputType>[]
          }
          count: {
            args: Prisma.GalleryVideoCountArgs<ExtArgs>,
            result: $Utils.Optional<GalleryVideoCountAggregateOutputType> | number
          }
        }
      }
      Condolence: {
        payload: Prisma.$CondolencePayload<ExtArgs>
        fields: Prisma.CondolenceFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CondolenceFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CondolencePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CondolenceFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CondolencePayload>
          }
          findFirst: {
            args: Prisma.CondolenceFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CondolencePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CondolenceFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CondolencePayload>
          }
          findMany: {
            args: Prisma.CondolenceFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CondolencePayload>[]
          }
          create: {
            args: Prisma.CondolenceCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CondolencePayload>
          }
          createMany: {
            args: Prisma.CondolenceCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.CondolenceDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CondolencePayload>
          }
          update: {
            args: Prisma.CondolenceUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CondolencePayload>
          }
          deleteMany: {
            args: Prisma.CondolenceDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.CondolenceUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.CondolenceUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$CondolencePayload>
          }
          aggregate: {
            args: Prisma.CondolenceAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateCondolence>
          }
          groupBy: {
            args: Prisma.CondolenceGroupByArgs<ExtArgs>,
            result: $Utils.Optional<CondolenceGroupByOutputType>[]
          }
          count: {
            args: Prisma.CondolenceCountArgs<ExtArgs>,
            result: $Utils.Optional<CondolenceCountAggregateOutputType> | number
          }
        }
      }
      Affiliates: {
        payload: Prisma.$AffiliatesPayload<ExtArgs>
        fields: Prisma.AffiliatesFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AffiliatesFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AffiliatesPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AffiliatesFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AffiliatesPayload>
          }
          findFirst: {
            args: Prisma.AffiliatesFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AffiliatesPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AffiliatesFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AffiliatesPayload>
          }
          findMany: {
            args: Prisma.AffiliatesFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AffiliatesPayload>[]
          }
          create: {
            args: Prisma.AffiliatesCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AffiliatesPayload>
          }
          createMany: {
            args: Prisma.AffiliatesCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.AffiliatesDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AffiliatesPayload>
          }
          update: {
            args: Prisma.AffiliatesUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AffiliatesPayload>
          }
          deleteMany: {
            args: Prisma.AffiliatesDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.AffiliatesUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.AffiliatesUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$AffiliatesPayload>
          }
          aggregate: {
            args: Prisma.AffiliatesAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateAffiliates>
          }
          groupBy: {
            args: Prisma.AffiliatesGroupByArgs<ExtArgs>,
            result: $Utils.Optional<AffiliatesGroupByOutputType>[]
          }
          count: {
            args: Prisma.AffiliatesCountArgs<ExtArgs>,
            result: $Utils.Optional<AffiliatesCountAggregateOutputType> | number
          }
        }
      }
      Subscribers: {
        payload: Prisma.$SubscribersPayload<ExtArgs>
        fields: Prisma.SubscribersFieldRefs
        operations: {
          findUnique: {
            args: Prisma.SubscribersFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SubscribersPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.SubscribersFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SubscribersPayload>
          }
          findFirst: {
            args: Prisma.SubscribersFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SubscribersPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.SubscribersFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SubscribersPayload>
          }
          findMany: {
            args: Prisma.SubscribersFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SubscribersPayload>[]
          }
          create: {
            args: Prisma.SubscribersCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SubscribersPayload>
          }
          createMany: {
            args: Prisma.SubscribersCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.SubscribersDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SubscribersPayload>
          }
          update: {
            args: Prisma.SubscribersUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SubscribersPayload>
          }
          deleteMany: {
            args: Prisma.SubscribersDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.SubscribersUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.SubscribersUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$SubscribersPayload>
          }
          aggregate: {
            args: Prisma.SubscribersAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateSubscribers>
          }
          groupBy: {
            args: Prisma.SubscribersGroupByArgs<ExtArgs>,
            result: $Utils.Optional<SubscribersGroupByOutputType>[]
          }
          count: {
            args: Prisma.SubscribersCountArgs<ExtArgs>,
            result: $Utils.Optional<SubscribersCountAggregateOutputType> | number
          }
        }
      }
      Messages: {
        payload: Prisma.$MessagesPayload<ExtArgs>
        fields: Prisma.MessagesFieldRefs
        operations: {
          findUnique: {
            args: Prisma.MessagesFindUniqueArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MessagesPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.MessagesFindUniqueOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MessagesPayload>
          }
          findFirst: {
            args: Prisma.MessagesFindFirstArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MessagesPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.MessagesFindFirstOrThrowArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MessagesPayload>
          }
          findMany: {
            args: Prisma.MessagesFindManyArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MessagesPayload>[]
          }
          create: {
            args: Prisma.MessagesCreateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MessagesPayload>
          }
          createMany: {
            args: Prisma.MessagesCreateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          delete: {
            args: Prisma.MessagesDeleteArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MessagesPayload>
          }
          update: {
            args: Prisma.MessagesUpdateArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MessagesPayload>
          }
          deleteMany: {
            args: Prisma.MessagesDeleteManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          updateMany: {
            args: Prisma.MessagesUpdateManyArgs<ExtArgs>,
            result: Prisma.BatchPayload
          }
          upsert: {
            args: Prisma.MessagesUpsertArgs<ExtArgs>,
            result: $Utils.PayloadToResult<Prisma.$MessagesPayload>
          }
          aggregate: {
            args: Prisma.MessagesAggregateArgs<ExtArgs>,
            result: $Utils.Optional<AggregateMessages>
          }
          groupBy: {
            args: Prisma.MessagesGroupByArgs<ExtArgs>,
            result: $Utils.Optional<MessagesGroupByOutputType>[]
          }
          count: {
            args: Prisma.MessagesCountArgs<ExtArgs>,
            result: $Utils.Optional<MessagesCountAggregateOutputType> | number
          }
        }
      }
    }
  } & {
    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)[]
  }

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

  export type MissionsCountOutputType = {
    objectiveList: number
  }

  export type MissionsCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    objectiveList?: boolean | MissionsCountOutputTypeCountObjectiveListArgs
  }

  // Custom InputTypes

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


  /**
   * MissionsCountOutputType without action
   */
  export type MissionsCountOutputTypeCountObjectiveListArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: objectivesWhereInput
  }



  /**
   * Count Type ChairmanProfileCountOutputType
   */

  export type ChairmanProfileCountOutputType = {
    associations: number
    clubs: number
  }

  export type ChairmanProfileCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    associations?: boolean | ChairmanProfileCountOutputTypeCountAssociationsArgs
    clubs?: boolean | ChairmanProfileCountOutputTypeCountClubsArgs
  }

  // Custom InputTypes

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


  /**
   * ChairmanProfileCountOutputType without action
   */
  export type ChairmanProfileCountOutputTypeCountAssociationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ChairmanAssociationWhereInput
  }


  /**
   * ChairmanProfileCountOutputType without action
   */
  export type ChairmanProfileCountOutputTypeCountClubsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ChairmanClubsWhereInput
  }



  /**
   * Count Type PhotoAlbumCountOutputType
   */

  export type PhotoAlbumCountOutputType = {
    photos: number
  }

  export type PhotoAlbumCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    photos?: boolean | PhotoAlbumCountOutputTypeCountPhotosArgs
  }

  // Custom InputTypes

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


  /**
   * PhotoAlbumCountOutputType without action
   */
  export type PhotoAlbumCountOutputTypeCountPhotosArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: GalleryPhotoWhereInput
  }



  /**
   * Models
   */

  /**
   * Model latestNews
   */

  export type AggregateLatestNews = {
    _count: LatestNewsCountAggregateOutputType | null
    _avg: LatestNewsAvgAggregateOutputType | null
    _sum: LatestNewsSumAggregateOutputType | null
    _min: LatestNewsMinAggregateOutputType | null
    _max: LatestNewsMaxAggregateOutputType | null
  }

  export type LatestNewsAvgAggregateOutputType = {
    id: number | null
  }

  export type LatestNewsSumAggregateOutputType = {
    id: number | null
  }

  export type LatestNewsMinAggregateOutputType = {
    id: number | null
    news: string | null
  }

  export type LatestNewsMaxAggregateOutputType = {
    id: number | null
    news: string | null
  }

  export type LatestNewsCountAggregateOutputType = {
    id: number
    news: number
    _all: number
  }


  export type LatestNewsAvgAggregateInputType = {
    id?: true
  }

  export type LatestNewsSumAggregateInputType = {
    id?: true
  }

  export type LatestNewsMinAggregateInputType = {
    id?: true
    news?: true
  }

  export type LatestNewsMaxAggregateInputType = {
    id?: true
    news?: true
  }

  export type LatestNewsCountAggregateInputType = {
    id?: true
    news?: true
    _all?: true
  }

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

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




  export type latestNewsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: latestNewsWhereInput
    orderBy?: latestNewsOrderByWithAggregationInput | latestNewsOrderByWithAggregationInput[]
    by: LatestNewsScalarFieldEnum[] | LatestNewsScalarFieldEnum
    having?: latestNewsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: LatestNewsCountAggregateInputType | true
    _avg?: LatestNewsAvgAggregateInputType
    _sum?: LatestNewsSumAggregateInputType
    _min?: LatestNewsMinAggregateInputType
    _max?: LatestNewsMaxAggregateInputType
  }

  export type LatestNewsGroupByOutputType = {
    id: number
    news: string
    _count: LatestNewsCountAggregateOutputType | null
    _avg: LatestNewsAvgAggregateOutputType | null
    _sum: LatestNewsSumAggregateOutputType | null
    _min: LatestNewsMinAggregateOutputType | null
    _max: LatestNewsMaxAggregateOutputType | null
  }

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


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

  export type latestNewsSelectScalar = {
    id?: boolean
    news?: boolean
  }


  export type $latestNewsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "latestNews"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      news: string
    }, ExtArgs["result"]["latestNews"]>
    composites: {}
  }


  type latestNewsGetPayload<S extends boolean | null | undefined | latestNewsDefaultArgs> = $Result.GetResult<Prisma.$latestNewsPayload, S>

  type latestNewsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<latestNewsFindManyArgs, 'select' | 'include'> & {
      select?: LatestNewsCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a LatestNews.
     * @param {latestNewsCreateArgs} args - Arguments to create a LatestNews.
     * @example
     * // Create one LatestNews
     * const LatestNews = await prisma.latestNews.create({
     *   data: {
     *     // ... data to create a LatestNews
     *   }
     * })
     * 
    **/
    create<T extends latestNewsCreateArgs<ExtArgs>>(
      args: SelectSubset<T, latestNewsCreateArgs<ExtArgs>>
    ): Prisma__latestNewsClient<$Result.GetResult<Prisma.$latestNewsPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a LatestNews.
     * @param {latestNewsDeleteArgs} args - Arguments to delete one LatestNews.
     * @example
     * // Delete one LatestNews
     * const LatestNews = await prisma.latestNews.delete({
     *   where: {
     *     // ... filter to delete one LatestNews
     *   }
     * })
     * 
    **/
    delete<T extends latestNewsDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, latestNewsDeleteArgs<ExtArgs>>
    ): Prisma__latestNewsClient<$Result.GetResult<Prisma.$latestNewsPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for latestNews.
   * 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__latestNewsClient<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 latestNews model
   */ 
  interface latestNewsFieldRefs {
    readonly id: FieldRef<"latestNews", 'Int'>
    readonly news: FieldRef<"latestNews", 'String'>
  }
    

  // Custom InputTypes

  /**
   * latestNews findUnique
   */
  export type latestNewsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the latestNews
     */
    select?: latestNewsSelect<ExtArgs> | null
    /**
     * Filter, which latestNews to fetch.
     */
    where: latestNewsWhereUniqueInput
  }


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


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


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


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


  /**
   * latestNews create
   */
  export type latestNewsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the latestNews
     */
    select?: latestNewsSelect<ExtArgs> | null
    /**
     * The data needed to create a latestNews.
     */
    data: XOR<latestNewsCreateInput, latestNewsUncheckedCreateInput>
  }


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


  /**
   * latestNews update
   */
  export type latestNewsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the latestNews
     */
    select?: latestNewsSelect<ExtArgs> | null
    /**
     * The data needed to update a latestNews.
     */
    data: XOR<latestNewsUpdateInput, latestNewsUncheckedUpdateInput>
    /**
     * Choose, which latestNews to update.
     */
    where: latestNewsWhereUniqueInput
  }


  /**
   * latestNews updateMany
   */
  export type latestNewsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update latestNews.
     */
    data: XOR<latestNewsUpdateManyMutationInput, latestNewsUncheckedUpdateManyInput>
    /**
     * Filter which latestNews to update
     */
    where?: latestNewsWhereInput
  }


  /**
   * latestNews upsert
   */
  export type latestNewsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the latestNews
     */
    select?: latestNewsSelect<ExtArgs> | null
    /**
     * The filter to search for the latestNews to update in case it exists.
     */
    where: latestNewsWhereUniqueInput
    /**
     * In case the latestNews found by the `where` argument doesn't exist, create a new latestNews with this data.
     */
    create: XOR<latestNewsCreateInput, latestNewsUncheckedCreateInput>
    /**
     * In case the latestNews was found with the provided `where` argument, update it with this data.
     */
    update: XOR<latestNewsUpdateInput, latestNewsUncheckedUpdateInput>
  }


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


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


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



  /**
   * Model sliderImages
   */

  export type AggregateSliderImages = {
    _count: SliderImagesCountAggregateOutputType | null
    _avg: SliderImagesAvgAggregateOutputType | null
    _sum: SliderImagesSumAggregateOutputType | null
    _min: SliderImagesMinAggregateOutputType | null
    _max: SliderImagesMaxAggregateOutputType | null
  }

  export type SliderImagesAvgAggregateOutputType = {
    id: number | null
  }

  export type SliderImagesSumAggregateOutputType = {
    id: number | null
  }

  export type SliderImagesMinAggregateOutputType = {
    id: number | null
    image: string | null
    caption: string | null
  }

  export type SliderImagesMaxAggregateOutputType = {
    id: number | null
    image: string | null
    caption: string | null
  }

  export type SliderImagesCountAggregateOutputType = {
    id: number
    image: number
    caption: number
    _all: number
  }


  export type SliderImagesAvgAggregateInputType = {
    id?: true
  }

  export type SliderImagesSumAggregateInputType = {
    id?: true
  }

  export type SliderImagesMinAggregateInputType = {
    id?: true
    image?: true
    caption?: true
  }

  export type SliderImagesMaxAggregateInputType = {
    id?: true
    image?: true
    caption?: true
  }

  export type SliderImagesCountAggregateInputType = {
    id?: true
    image?: true
    caption?: true
    _all?: true
  }

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

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




  export type sliderImagesGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: sliderImagesWhereInput
    orderBy?: sliderImagesOrderByWithAggregationInput | sliderImagesOrderByWithAggregationInput[]
    by: SliderImagesScalarFieldEnum[] | SliderImagesScalarFieldEnum
    having?: sliderImagesScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: SliderImagesCountAggregateInputType | true
    _avg?: SliderImagesAvgAggregateInputType
    _sum?: SliderImagesSumAggregateInputType
    _min?: SliderImagesMinAggregateInputType
    _max?: SliderImagesMaxAggregateInputType
  }

  export type SliderImagesGroupByOutputType = {
    id: number
    image: string
    caption: string
    _count: SliderImagesCountAggregateOutputType | null
    _avg: SliderImagesAvgAggregateOutputType | null
    _sum: SliderImagesSumAggregateOutputType | null
    _min: SliderImagesMinAggregateOutputType | null
    _max: SliderImagesMaxAggregateOutputType | null
  }

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


  export type sliderImagesSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    image?: boolean
    caption?: boolean
  }, ExtArgs["result"]["sliderImages"]>

  export type sliderImagesSelectScalar = {
    id?: boolean
    image?: boolean
    caption?: boolean
  }


  export type $sliderImagesPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "sliderImages"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      image: string
      caption: string
    }, ExtArgs["result"]["sliderImages"]>
    composites: {}
  }


  type sliderImagesGetPayload<S extends boolean | null | undefined | sliderImagesDefaultArgs> = $Result.GetResult<Prisma.$sliderImagesPayload, S>

  type sliderImagesCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<sliderImagesFindManyArgs, 'select' | 'include'> & {
      select?: SliderImagesCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a SliderImages.
     * @param {sliderImagesCreateArgs} args - Arguments to create a SliderImages.
     * @example
     * // Create one SliderImages
     * const SliderImages = await prisma.sliderImages.create({
     *   data: {
     *     // ... data to create a SliderImages
     *   }
     * })
     * 
    **/
    create<T extends sliderImagesCreateArgs<ExtArgs>>(
      args: SelectSubset<T, sliderImagesCreateArgs<ExtArgs>>
    ): Prisma__sliderImagesClient<$Result.GetResult<Prisma.$sliderImagesPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a SliderImages.
     * @param {sliderImagesDeleteArgs} args - Arguments to delete one SliderImages.
     * @example
     * // Delete one SliderImages
     * const SliderImages = await prisma.sliderImages.delete({
     *   where: {
     *     // ... filter to delete one SliderImages
     *   }
     * })
     * 
    **/
    delete<T extends sliderImagesDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, sliderImagesDeleteArgs<ExtArgs>>
    ): Prisma__sliderImagesClient<$Result.GetResult<Prisma.$sliderImagesPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for sliderImages.
   * 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__sliderImagesClient<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 sliderImages model
   */ 
  interface sliderImagesFieldRefs {
    readonly id: FieldRef<"sliderImages", 'Int'>
    readonly image: FieldRef<"sliderImages", 'String'>
    readonly caption: FieldRef<"sliderImages", 'String'>
  }
    

  // Custom InputTypes

  /**
   * sliderImages findUnique
   */
  export type sliderImagesFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the sliderImages
     */
    select?: sliderImagesSelect<ExtArgs> | null
    /**
     * Filter, which sliderImages to fetch.
     */
    where: sliderImagesWhereUniqueInput
  }


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


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


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


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


  /**
   * sliderImages create
   */
  export type sliderImagesCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the sliderImages
     */
    select?: sliderImagesSelect<ExtArgs> | null
    /**
     * The data needed to create a sliderImages.
     */
    data: XOR<sliderImagesCreateInput, sliderImagesUncheckedCreateInput>
  }


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


  /**
   * sliderImages update
   */
  export type sliderImagesUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the sliderImages
     */
    select?: sliderImagesSelect<ExtArgs> | null
    /**
     * The data needed to update a sliderImages.
     */
    data: XOR<sliderImagesUpdateInput, sliderImagesUncheckedUpdateInput>
    /**
     * Choose, which sliderImages to update.
     */
    where: sliderImagesWhereUniqueInput
  }


  /**
   * sliderImages updateMany
   */
  export type sliderImagesUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update sliderImages.
     */
    data: XOR<sliderImagesUpdateManyMutationInput, sliderImagesUncheckedUpdateManyInput>
    /**
     * Filter which sliderImages to update
     */
    where?: sliderImagesWhereInput
  }


  /**
   * sliderImages upsert
   */
  export type sliderImagesUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the sliderImages
     */
    select?: sliderImagesSelect<ExtArgs> | null
    /**
     * The filter to search for the sliderImages to update in case it exists.
     */
    where: sliderImagesWhereUniqueInput
    /**
     * In case the sliderImages found by the `where` argument doesn't exist, create a new sliderImages with this data.
     */
    create: XOR<sliderImagesCreateInput, sliderImagesUncheckedCreateInput>
    /**
     * In case the sliderImages was found with the provided `where` argument, update it with this data.
     */
    update: XOR<sliderImagesUpdateInput, sliderImagesUncheckedUpdateInput>
  }


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


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


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



  /**
   * Model missions
   */

  export type AggregateMissions = {
    _count: MissionsCountAggregateOutputType | null
    _avg: MissionsAvgAggregateOutputType | null
    _sum: MissionsSumAggregateOutputType | null
    _min: MissionsMinAggregateOutputType | null
    _max: MissionsMaxAggregateOutputType | null
  }

  export type MissionsAvgAggregateOutputType = {
    id: number | null
  }

  export type MissionsSumAggregateOutputType = {
    id: number | null
  }

  export type MissionsMinAggregateOutputType = {
    id: number | null
    text: string | null
    pdfName: string | null
  }

  export type MissionsMaxAggregateOutputType = {
    id: number | null
    text: string | null
    pdfName: string | null
  }

  export type MissionsCountAggregateOutputType = {
    id: number
    text: number
    pdfName: number
    _all: number
  }


  export type MissionsAvgAggregateInputType = {
    id?: true
  }

  export type MissionsSumAggregateInputType = {
    id?: true
  }

  export type MissionsMinAggregateInputType = {
    id?: true
    text?: true
    pdfName?: true
  }

  export type MissionsMaxAggregateInputType = {
    id?: true
    text?: true
    pdfName?: true
  }

  export type MissionsCountAggregateInputType = {
    id?: true
    text?: true
    pdfName?: true
    _all?: true
  }

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

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




  export type missionsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: missionsWhereInput
    orderBy?: missionsOrderByWithAggregationInput | missionsOrderByWithAggregationInput[]
    by: MissionsScalarFieldEnum[] | MissionsScalarFieldEnum
    having?: missionsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: MissionsCountAggregateInputType | true
    _avg?: MissionsAvgAggregateInputType
    _sum?: MissionsSumAggregateInputType
    _min?: MissionsMinAggregateInputType
    _max?: MissionsMaxAggregateInputType
  }

  export type MissionsGroupByOutputType = {
    id: number
    text: string
    pdfName: string
    _count: MissionsCountAggregateOutputType | null
    _avg: MissionsAvgAggregateOutputType | null
    _sum: MissionsSumAggregateOutputType | null
    _min: MissionsMinAggregateOutputType | null
    _max: MissionsMaxAggregateOutputType | null
  }

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


  export type missionsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    text?: boolean
    pdfName?: boolean
    objectiveList?: boolean | missions$objectiveListArgs<ExtArgs>
    _count?: boolean | MissionsCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["missions"]>

  export type missionsSelectScalar = {
    id?: boolean
    text?: boolean
    pdfName?: boolean
  }

  export type missionsInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    objectiveList?: boolean | missions$objectiveListArgs<ExtArgs>
    _count?: boolean | MissionsCountOutputTypeDefaultArgs<ExtArgs>
  }


  export type $missionsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "missions"
    objects: {
      objectiveList: Prisma.$objectivesPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      text: string
      pdfName: string
    }, ExtArgs["result"]["missions"]>
    composites: {}
  }


  type missionsGetPayload<S extends boolean | null | undefined | missionsDefaultArgs> = $Result.GetResult<Prisma.$missionsPayload, S>

  type missionsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<missionsFindManyArgs, 'select' | 'include'> & {
      select?: MissionsCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Missions.
     * @param {missionsCreateArgs} args - Arguments to create a Missions.
     * @example
     * // Create one Missions
     * const Missions = await prisma.missions.create({
     *   data: {
     *     // ... data to create a Missions
     *   }
     * })
     * 
    **/
    create<T extends missionsCreateArgs<ExtArgs>>(
      args: SelectSubset<T, missionsCreateArgs<ExtArgs>>
    ): Prisma__missionsClient<$Result.GetResult<Prisma.$missionsPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a Missions.
     * @param {missionsDeleteArgs} args - Arguments to delete one Missions.
     * @example
     * // Delete one Missions
     * const Missions = await prisma.missions.delete({
     *   where: {
     *     // ... filter to delete one Missions
     *   }
     * })
     * 
    **/
    delete<T extends missionsDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, missionsDeleteArgs<ExtArgs>>
    ): Prisma__missionsClient<$Result.GetResult<Prisma.$missionsPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

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

    objectiveList<T extends missions$objectiveListArgs<ExtArgs> = {}>(args?: Subset<T, missions$objectiveListArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$objectivesPayload<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 missions model
   */ 
  interface missionsFieldRefs {
    readonly id: FieldRef<"missions", 'Int'>
    readonly text: FieldRef<"missions", 'String'>
    readonly pdfName: FieldRef<"missions", 'String'>
  }
    

  // Custom InputTypes

  /**
   * missions findUnique
   */
  export type missionsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the missions
     */
    select?: missionsSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: missionsInclude<ExtArgs> | null
    /**
     * Filter, which missions to fetch.
     */
    where: missionsWhereUniqueInput
  }


  /**
   * missions findUniqueOrThrow
   */
  export type missionsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the missions
     */
    select?: missionsSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: missionsInclude<ExtArgs> | null
    /**
     * Filter, which missions to fetch.
     */
    where: missionsWhereUniqueInput
  }


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


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


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


  /**
   * missions create
   */
  export type missionsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the missions
     */
    select?: missionsSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: missionsInclude<ExtArgs> | null
    /**
     * The data needed to create a missions.
     */
    data: XOR<missionsCreateInput, missionsUncheckedCreateInput>
  }


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


  /**
   * missions update
   */
  export type missionsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the missions
     */
    select?: missionsSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: missionsInclude<ExtArgs> | null
    /**
     * The data needed to update a missions.
     */
    data: XOR<missionsUpdateInput, missionsUncheckedUpdateInput>
    /**
     * Choose, which missions to update.
     */
    where: missionsWhereUniqueInput
  }


  /**
   * missions updateMany
   */
  export type missionsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update missions.
     */
    data: XOR<missionsUpdateManyMutationInput, missionsUncheckedUpdateManyInput>
    /**
     * Filter which missions to update
     */
    where?: missionsWhereInput
  }


  /**
   * missions upsert
   */
  export type missionsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the missions
     */
    select?: missionsSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: missionsInclude<ExtArgs> | null
    /**
     * The filter to search for the missions to update in case it exists.
     */
    where: missionsWhereUniqueInput
    /**
     * In case the missions found by the `where` argument doesn't exist, create a new missions with this data.
     */
    create: XOR<missionsCreateInput, missionsUncheckedCreateInput>
    /**
     * In case the missions was found with the provided `where` argument, update it with this data.
     */
    update: XOR<missionsUpdateInput, missionsUncheckedUpdateInput>
  }


  /**
   * missions delete
   */
  export type missionsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the missions
     */
    select?: missionsSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: missionsInclude<ExtArgs> | null
    /**
     * Filter which missions to delete.
     */
    where: missionsWhereUniqueInput
  }


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


  /**
   * missions.objectiveList
   */
  export type missions$objectiveListArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the objectives
     */
    select?: objectivesSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: objectivesInclude<ExtArgs> | null
    where?: objectivesWhereInput
    orderBy?: objectivesOrderByWithRelationInput | objectivesOrderByWithRelationInput[]
    cursor?: objectivesWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ObjectivesScalarFieldEnum | ObjectivesScalarFieldEnum[]
  }


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



  /**
   * Model objectives
   */

  export type AggregateObjectives = {
    _count: ObjectivesCountAggregateOutputType | null
    _avg: ObjectivesAvgAggregateOutputType | null
    _sum: ObjectivesSumAggregateOutputType | null
    _min: ObjectivesMinAggregateOutputType | null
    _max: ObjectivesMaxAggregateOutputType | null
  }

  export type ObjectivesAvgAggregateOutputType = {
    id: number | null
    missionsId: number | null
  }

  export type ObjectivesSumAggregateOutputType = {
    id: number | null
    missionsId: number | null
  }

  export type ObjectivesMinAggregateOutputType = {
    id: number | null
    text: string | null
    bg: string | null
    missionsId: number | null
  }

  export type ObjectivesMaxAggregateOutputType = {
    id: number | null
    text: string | null
    bg: string | null
    missionsId: number | null
  }

  export type ObjectivesCountAggregateOutputType = {
    id: number
    text: number
    bg: number
    missionsId: number
    _all: number
  }


  export type ObjectivesAvgAggregateInputType = {
    id?: true
    missionsId?: true
  }

  export type ObjectivesSumAggregateInputType = {
    id?: true
    missionsId?: true
  }

  export type ObjectivesMinAggregateInputType = {
    id?: true
    text?: true
    bg?: true
    missionsId?: true
  }

  export type ObjectivesMaxAggregateInputType = {
    id?: true
    text?: true
    bg?: true
    missionsId?: true
  }

  export type ObjectivesCountAggregateInputType = {
    id?: true
    text?: true
    bg?: true
    missionsId?: true
    _all?: true
  }

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

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




  export type objectivesGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: objectivesWhereInput
    orderBy?: objectivesOrderByWithAggregationInput | objectivesOrderByWithAggregationInput[]
    by: ObjectivesScalarFieldEnum[] | ObjectivesScalarFieldEnum
    having?: objectivesScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ObjectivesCountAggregateInputType | true
    _avg?: ObjectivesAvgAggregateInputType
    _sum?: ObjectivesSumAggregateInputType
    _min?: ObjectivesMinAggregateInputType
    _max?: ObjectivesMaxAggregateInputType
  }

  export type ObjectivesGroupByOutputType = {
    id: number
    text: string
    bg: string
    missionsId: number | null
    _count: ObjectivesCountAggregateOutputType | null
    _avg: ObjectivesAvgAggregateOutputType | null
    _sum: ObjectivesSumAggregateOutputType | null
    _min: ObjectivesMinAggregateOutputType | null
    _max: ObjectivesMaxAggregateOutputType | null
  }

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


  export type objectivesSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    text?: boolean
    bg?: boolean
    missionsId?: boolean
    missions?: boolean | objectives$missionsArgs<ExtArgs>
  }, ExtArgs["result"]["objectives"]>

  export type objectivesSelectScalar = {
    id?: boolean
    text?: boolean
    bg?: boolean
    missionsId?: boolean
  }

  export type objectivesInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    missions?: boolean | objectives$missionsArgs<ExtArgs>
  }


  export type $objectivesPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "objectives"
    objects: {
      missions: Prisma.$missionsPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      text: string
      bg: string
      missionsId: number | null
    }, ExtArgs["result"]["objectives"]>
    composites: {}
  }


  type objectivesGetPayload<S extends boolean | null | undefined | objectivesDefaultArgs> = $Result.GetResult<Prisma.$objectivesPayload, S>

  type objectivesCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<objectivesFindManyArgs, 'select' | 'include'> & {
      select?: ObjectivesCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Objectives.
     * @param {objectivesCreateArgs} args - Arguments to create a Objectives.
     * @example
     * // Create one Objectives
     * const Objectives = await prisma.objectives.create({
     *   data: {
     *     // ... data to create a Objectives
     *   }
     * })
     * 
    **/
    create<T extends objectivesCreateArgs<ExtArgs>>(
      args: SelectSubset<T, objectivesCreateArgs<ExtArgs>>
    ): Prisma__objectivesClient<$Result.GetResult<Prisma.$objectivesPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a Objectives.
     * @param {objectivesDeleteArgs} args - Arguments to delete one Objectives.
     * @example
     * // Delete one Objectives
     * const Objectives = await prisma.objectives.delete({
     *   where: {
     *     // ... filter to delete one Objectives
     *   }
     * })
     * 
    **/
    delete<T extends objectivesDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, objectivesDeleteArgs<ExtArgs>>
    ): Prisma__objectivesClient<$Result.GetResult<Prisma.$objectivesPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

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

    missions<T extends objectives$missionsArgs<ExtArgs> = {}>(args?: Subset<T, objectives$missionsArgs<ExtArgs>>): Prisma__missionsClient<$Result.GetResult<Prisma.$missionsPayload<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 objectives model
   */ 
  interface objectivesFieldRefs {
    readonly id: FieldRef<"objectives", 'Int'>
    readonly text: FieldRef<"objectives", 'String'>
    readonly bg: FieldRef<"objectives", 'String'>
    readonly missionsId: FieldRef<"objectives", 'Int'>
  }
    

  // Custom InputTypes

  /**
   * objectives findUnique
   */
  export type objectivesFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the objectives
     */
    select?: objectivesSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: objectivesInclude<ExtArgs> | null
    /**
     * Filter, which objectives to fetch.
     */
    where: objectivesWhereUniqueInput
  }


  /**
   * objectives findUniqueOrThrow
   */
  export type objectivesFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the objectives
     */
    select?: objectivesSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: objectivesInclude<ExtArgs> | null
    /**
     * Filter, which objectives to fetch.
     */
    where: objectivesWhereUniqueInput
  }


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


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


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


  /**
   * objectives create
   */
  export type objectivesCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the objectives
     */
    select?: objectivesSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: objectivesInclude<ExtArgs> | null
    /**
     * The data needed to create a objectives.
     */
    data: XOR<objectivesCreateInput, objectivesUncheckedCreateInput>
  }


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


  /**
   * objectives update
   */
  export type objectivesUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the objectives
     */
    select?: objectivesSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: objectivesInclude<ExtArgs> | null
    /**
     * The data needed to update a objectives.
     */
    data: XOR<objectivesUpdateInput, objectivesUncheckedUpdateInput>
    /**
     * Choose, which objectives to update.
     */
    where: objectivesWhereUniqueInput
  }


  /**
   * objectives updateMany
   */
  export type objectivesUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update objectives.
     */
    data: XOR<objectivesUpdateManyMutationInput, objectivesUncheckedUpdateManyInput>
    /**
     * Filter which objectives to update
     */
    where?: objectivesWhereInput
  }


  /**
   * objectives upsert
   */
  export type objectivesUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the objectives
     */
    select?: objectivesSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: objectivesInclude<ExtArgs> | null
    /**
     * The filter to search for the objectives to update in case it exists.
     */
    where: objectivesWhereUniqueInput
    /**
     * In case the objectives found by the `where` argument doesn't exist, create a new objectives with this data.
     */
    create: XOR<objectivesCreateInput, objectivesUncheckedCreateInput>
    /**
     * In case the objectives was found with the provided `where` argument, update it with this data.
     */
    update: XOR<objectivesUpdateInput, objectivesUncheckedUpdateInput>
  }


  /**
   * objectives delete
   */
  export type objectivesDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the objectives
     */
    select?: objectivesSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: objectivesInclude<ExtArgs> | null
    /**
     * Filter which objectives to delete.
     */
    where: objectivesWhereUniqueInput
  }


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


  /**
   * objectives.missions
   */
  export type objectives$missionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the missions
     */
    select?: missionsSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: missionsInclude<ExtArgs> | null
    where?: missionsWhereInput
  }


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



  /**
   * Model homeData
   */

  export type AggregateHomeData = {
    _count: HomeDataCountAggregateOutputType | null
    _avg: HomeDataAvgAggregateOutputType | null
    _sum: HomeDataSumAggregateOutputType | null
    _min: HomeDataMinAggregateOutputType | null
    _max: HomeDataMaxAggregateOutputType | null
  }

  export type HomeDataAvgAggregateOutputType = {
    id: number | null
  }

  export type HomeDataSumAggregateOutputType = {
    id: number | null
  }

  export type HomeDataMinAggregateOutputType = {
    id: number | null
    title: string | null
    text: string | null
    pdf: string | null
  }

  export type HomeDataMaxAggregateOutputType = {
    id: number | null
    title: string | null
    text: string | null
    pdf: string | null
  }

  export type HomeDataCountAggregateOutputType = {
    id: number
    title: number
    text: number
    image: number
    pdf: number
    _all: number
  }


  export type HomeDataAvgAggregateInputType = {
    id?: true
  }

  export type HomeDataSumAggregateInputType = {
    id?: true
  }

  export type HomeDataMinAggregateInputType = {
    id?: true
    title?: true
    text?: true
    pdf?: true
  }

  export type HomeDataMaxAggregateInputType = {
    id?: true
    title?: true
    text?: true
    pdf?: true
  }

  export type HomeDataCountAggregateInputType = {
    id?: true
    title?: true
    text?: true
    image?: true
    pdf?: true
    _all?: true
  }

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

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




  export type homeDataGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: homeDataWhereInput
    orderBy?: homeDataOrderByWithAggregationInput | homeDataOrderByWithAggregationInput[]
    by: HomeDataScalarFieldEnum[] | HomeDataScalarFieldEnum
    having?: homeDataScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: HomeDataCountAggregateInputType | true
    _avg?: HomeDataAvgAggregateInputType
    _sum?: HomeDataSumAggregateInputType
    _min?: HomeDataMinAggregateInputType
    _max?: HomeDataMaxAggregateInputType
  }

  export type HomeDataGroupByOutputType = {
    id: number
    title: string
    text: string
    image: JsonValue | null
    pdf: string | null
    _count: HomeDataCountAggregateOutputType | null
    _avg: HomeDataAvgAggregateOutputType | null
    _sum: HomeDataSumAggregateOutputType | null
    _min: HomeDataMinAggregateOutputType | null
    _max: HomeDataMaxAggregateOutputType | null
  }

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


  export type homeDataSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    text?: boolean
    image?: boolean
    pdf?: boolean
  }, ExtArgs["result"]["homeData"]>

  export type homeDataSelectScalar = {
    id?: boolean
    title?: boolean
    text?: boolean
    image?: boolean
    pdf?: boolean
  }


  export type $homeDataPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "homeData"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      title: string
      text: string
      image: Prisma.JsonValue | null
      pdf: string | null
    }, ExtArgs["result"]["homeData"]>
    composites: {}
  }


  type homeDataGetPayload<S extends boolean | null | undefined | homeDataDefaultArgs> = $Result.GetResult<Prisma.$homeDataPayload, S>

  type homeDataCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<homeDataFindManyArgs, 'select' | 'include'> & {
      select?: HomeDataCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a HomeData.
     * @param {homeDataCreateArgs} args - Arguments to create a HomeData.
     * @example
     * // Create one HomeData
     * const HomeData = await prisma.homeData.create({
     *   data: {
     *     // ... data to create a HomeData
     *   }
     * })
     * 
    **/
    create<T extends homeDataCreateArgs<ExtArgs>>(
      args: SelectSubset<T, homeDataCreateArgs<ExtArgs>>
    ): Prisma__homeDataClient<$Result.GetResult<Prisma.$homeDataPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a HomeData.
     * @param {homeDataDeleteArgs} args - Arguments to delete one HomeData.
     * @example
     * // Delete one HomeData
     * const HomeData = await prisma.homeData.delete({
     *   where: {
     *     // ... filter to delete one HomeData
     *   }
     * })
     * 
    **/
    delete<T extends homeDataDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, homeDataDeleteArgs<ExtArgs>>
    ): Prisma__homeDataClient<$Result.GetResult<Prisma.$homeDataPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for homeData.
   * 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__homeDataClient<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 homeData model
   */ 
  interface homeDataFieldRefs {
    readonly id: FieldRef<"homeData", 'Int'>
    readonly title: FieldRef<"homeData", 'String'>
    readonly text: FieldRef<"homeData", 'String'>
    readonly image: FieldRef<"homeData", 'Json'>
    readonly pdf: FieldRef<"homeData", 'String'>
  }
    

  // Custom InputTypes

  /**
   * homeData findUnique
   */
  export type homeDataFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the homeData
     */
    select?: homeDataSelect<ExtArgs> | null
    /**
     * Filter, which homeData to fetch.
     */
    where: homeDataWhereUniqueInput
  }


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


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


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


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


  /**
   * homeData create
   */
  export type homeDataCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the homeData
     */
    select?: homeDataSelect<ExtArgs> | null
    /**
     * The data needed to create a homeData.
     */
    data: XOR<homeDataCreateInput, homeDataUncheckedCreateInput>
  }


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


  /**
   * homeData update
   */
  export type homeDataUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the homeData
     */
    select?: homeDataSelect<ExtArgs> | null
    /**
     * The data needed to update a homeData.
     */
    data: XOR<homeDataUpdateInput, homeDataUncheckedUpdateInput>
    /**
     * Choose, which homeData to update.
     */
    where: homeDataWhereUniqueInput
  }


  /**
   * homeData updateMany
   */
  export type homeDataUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update homeData.
     */
    data: XOR<homeDataUpdateManyMutationInput, homeDataUncheckedUpdateManyInput>
    /**
     * Filter which homeData to update
     */
    where?: homeDataWhereInput
  }


  /**
   * homeData upsert
   */
  export type homeDataUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the homeData
     */
    select?: homeDataSelect<ExtArgs> | null
    /**
     * The filter to search for the homeData to update in case it exists.
     */
    where: homeDataWhereUniqueInput
    /**
     * In case the homeData found by the `where` argument doesn't exist, create a new homeData with this data.
     */
    create: XOR<homeDataCreateInput, homeDataUncheckedCreateInput>
    /**
     * In case the homeData was found with the provided `where` argument, update it with this data.
     */
    update: XOR<homeDataUpdateInput, homeDataUncheckedUpdateInput>
  }


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


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


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



  /**
   * Model briefData
   */

  export type AggregateBriefData = {
    _count: BriefDataCountAggregateOutputType | null
    _avg: BriefDataAvgAggregateOutputType | null
    _sum: BriefDataSumAggregateOutputType | null
    _min: BriefDataMinAggregateOutputType | null
    _max: BriefDataMaxAggregateOutputType | null
  }

  export type BriefDataAvgAggregateOutputType = {
    id: number | null
  }

  export type BriefDataSumAggregateOutputType = {
    id: number | null
  }

  export type BriefDataMinAggregateOutputType = {
    id: number | null
    text: string | null
  }

  export type BriefDataMaxAggregateOutputType = {
    id: number | null
    text: string | null
  }

  export type BriefDataCountAggregateOutputType = {
    id: number
    text: number
    image: number
    _all: number
  }


  export type BriefDataAvgAggregateInputType = {
    id?: true
  }

  export type BriefDataSumAggregateInputType = {
    id?: true
  }

  export type BriefDataMinAggregateInputType = {
    id?: true
    text?: true
  }

  export type BriefDataMaxAggregateInputType = {
    id?: true
    text?: true
  }

  export type BriefDataCountAggregateInputType = {
    id?: true
    text?: true
    image?: true
    _all?: true
  }

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

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




  export type briefDataGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: briefDataWhereInput
    orderBy?: briefDataOrderByWithAggregationInput | briefDataOrderByWithAggregationInput[]
    by: BriefDataScalarFieldEnum[] | BriefDataScalarFieldEnum
    having?: briefDataScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: BriefDataCountAggregateInputType | true
    _avg?: BriefDataAvgAggregateInputType
    _sum?: BriefDataSumAggregateInputType
    _min?: BriefDataMinAggregateInputType
    _max?: BriefDataMaxAggregateInputType
  }

  export type BriefDataGroupByOutputType = {
    id: number
    text: string
    image: JsonValue | null
    _count: BriefDataCountAggregateOutputType | null
    _avg: BriefDataAvgAggregateOutputType | null
    _sum: BriefDataSumAggregateOutputType | null
    _min: BriefDataMinAggregateOutputType | null
    _max: BriefDataMaxAggregateOutputType | null
  }

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


  export type briefDataSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    text?: boolean
    image?: boolean
  }, ExtArgs["result"]["briefData"]>

  export type briefDataSelectScalar = {
    id?: boolean
    text?: boolean
    image?: boolean
  }


  export type $briefDataPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "briefData"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      text: string
      image: Prisma.JsonValue | null
    }, ExtArgs["result"]["briefData"]>
    composites: {}
  }


  type briefDataGetPayload<S extends boolean | null | undefined | briefDataDefaultArgs> = $Result.GetResult<Prisma.$briefDataPayload, S>

  type briefDataCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<briefDataFindManyArgs, 'select' | 'include'> & {
      select?: BriefDataCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a BriefData.
     * @param {briefDataCreateArgs} args - Arguments to create a BriefData.
     * @example
     * // Create one BriefData
     * const BriefData = await prisma.briefData.create({
     *   data: {
     *     // ... data to create a BriefData
     *   }
     * })
     * 
    **/
    create<T extends briefDataCreateArgs<ExtArgs>>(
      args: SelectSubset<T, briefDataCreateArgs<ExtArgs>>
    ): Prisma__briefDataClient<$Result.GetResult<Prisma.$briefDataPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a BriefData.
     * @param {briefDataDeleteArgs} args - Arguments to delete one BriefData.
     * @example
     * // Delete one BriefData
     * const BriefData = await prisma.briefData.delete({
     *   where: {
     *     // ... filter to delete one BriefData
     *   }
     * })
     * 
    **/
    delete<T extends briefDataDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, briefDataDeleteArgs<ExtArgs>>
    ): Prisma__briefDataClient<$Result.GetResult<Prisma.$briefDataPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for briefData.
   * 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__briefDataClient<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 briefData model
   */ 
  interface briefDataFieldRefs {
    readonly id: FieldRef<"briefData", 'Int'>
    readonly text: FieldRef<"briefData", 'String'>
    readonly image: FieldRef<"briefData", 'Json'>
  }
    

  // Custom InputTypes

  /**
   * briefData findUnique
   */
  export type briefDataFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the briefData
     */
    select?: briefDataSelect<ExtArgs> | null
    /**
     * Filter, which briefData to fetch.
     */
    where: briefDataWhereUniqueInput
  }


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


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


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


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


  /**
   * briefData create
   */
  export type briefDataCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the briefData
     */
    select?: briefDataSelect<ExtArgs> | null
    /**
     * The data needed to create a briefData.
     */
    data: XOR<briefDataCreateInput, briefDataUncheckedCreateInput>
  }


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


  /**
   * briefData update
   */
  export type briefDataUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the briefData
     */
    select?: briefDataSelect<ExtArgs> | null
    /**
     * The data needed to update a briefData.
     */
    data: XOR<briefDataUpdateInput, briefDataUncheckedUpdateInput>
    /**
     * Choose, which briefData to update.
     */
    where: briefDataWhereUniqueInput
  }


  /**
   * briefData updateMany
   */
  export type briefDataUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update briefData.
     */
    data: XOR<briefDataUpdateManyMutationInput, briefDataUncheckedUpdateManyInput>
    /**
     * Filter which briefData to update
     */
    where?: briefDataWhereInput
  }


  /**
   * briefData upsert
   */
  export type briefDataUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the briefData
     */
    select?: briefDataSelect<ExtArgs> | null
    /**
     * The filter to search for the briefData to update in case it exists.
     */
    where: briefDataWhereUniqueInput
    /**
     * In case the briefData found by the `where` argument doesn't exist, create a new briefData with this data.
     */
    create: XOR<briefDataCreateInput, briefDataUncheckedCreateInput>
    /**
     * In case the briefData was found with the provided `where` argument, update it with this data.
     */
    update: XOR<briefDataUpdateInput, briefDataUncheckedUpdateInput>
  }


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


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


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



  /**
   * Model serviceData
   */

  export type AggregateServiceData = {
    _count: ServiceDataCountAggregateOutputType | null
    _avg: ServiceDataAvgAggregateOutputType | null
    _sum: ServiceDataSumAggregateOutputType | null
    _min: ServiceDataMinAggregateOutputType | null
    _max: ServiceDataMaxAggregateOutputType | null
  }

  export type ServiceDataAvgAggregateOutputType = {
    id: number | null
  }

  export type ServiceDataSumAggregateOutputType = {
    id: number | null
  }

  export type ServiceDataMinAggregateOutputType = {
    id: number | null
    text: string | null
    bg: string | null
    bg2: string | null
  }

  export type ServiceDataMaxAggregateOutputType = {
    id: number | null
    text: string | null
    bg: string | null
    bg2: string | null
  }

  export type ServiceDataCountAggregateOutputType = {
    id: number
    text: number
    bg: number
    bg2: number
    _all: number
  }


  export type ServiceDataAvgAggregateInputType = {
    id?: true
  }

  export type ServiceDataSumAggregateInputType = {
    id?: true
  }

  export type ServiceDataMinAggregateInputType = {
    id?: true
    text?: true
    bg?: true
    bg2?: true
  }

  export type ServiceDataMaxAggregateInputType = {
    id?: true
    text?: true
    bg?: true
    bg2?: true
  }

  export type ServiceDataCountAggregateInputType = {
    id?: true
    text?: true
    bg?: true
    bg2?: true
    _all?: true
  }

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

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




  export type serviceDataGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: serviceDataWhereInput
    orderBy?: serviceDataOrderByWithAggregationInput | serviceDataOrderByWithAggregationInput[]
    by: ServiceDataScalarFieldEnum[] | ServiceDataScalarFieldEnum
    having?: serviceDataScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ServiceDataCountAggregateInputType | true
    _avg?: ServiceDataAvgAggregateInputType
    _sum?: ServiceDataSumAggregateInputType
    _min?: ServiceDataMinAggregateInputType
    _max?: ServiceDataMaxAggregateInputType
  }

  export type ServiceDataGroupByOutputType = {
    id: number
    text: string
    bg: string
    bg2: string
    _count: ServiceDataCountAggregateOutputType | null
    _avg: ServiceDataAvgAggregateOutputType | null
    _sum: ServiceDataSumAggregateOutputType | null
    _min: ServiceDataMinAggregateOutputType | null
    _max: ServiceDataMaxAggregateOutputType | null
  }

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


  export type serviceDataSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    text?: boolean
    bg?: boolean
    bg2?: boolean
  }, ExtArgs["result"]["serviceData"]>

  export type serviceDataSelectScalar = {
    id?: boolean
    text?: boolean
    bg?: boolean
    bg2?: boolean
  }


  export type $serviceDataPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "serviceData"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      text: string
      bg: string
      bg2: string
    }, ExtArgs["result"]["serviceData"]>
    composites: {}
  }


  type serviceDataGetPayload<S extends boolean | null | undefined | serviceDataDefaultArgs> = $Result.GetResult<Prisma.$serviceDataPayload, S>

  type serviceDataCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<serviceDataFindManyArgs, 'select' | 'include'> & {
      select?: ServiceDataCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a ServiceData.
     * @param {serviceDataCreateArgs} args - Arguments to create a ServiceData.
     * @example
     * // Create one ServiceData
     * const ServiceData = await prisma.serviceData.create({
     *   data: {
     *     // ... data to create a ServiceData
     *   }
     * })
     * 
    **/
    create<T extends serviceDataCreateArgs<ExtArgs>>(
      args: SelectSubset<T, serviceDataCreateArgs<ExtArgs>>
    ): Prisma__serviceDataClient<$Result.GetResult<Prisma.$serviceDataPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a ServiceData.
     * @param {serviceDataDeleteArgs} args - Arguments to delete one ServiceData.
     * @example
     * // Delete one ServiceData
     * const ServiceData = await prisma.serviceData.delete({
     *   where: {
     *     // ... filter to delete one ServiceData
     *   }
     * })
     * 
    **/
    delete<T extends serviceDataDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, serviceDataDeleteArgs<ExtArgs>>
    ): Prisma__serviceDataClient<$Result.GetResult<Prisma.$serviceDataPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for serviceData.
   * 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__serviceDataClient<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 serviceData model
   */ 
  interface serviceDataFieldRefs {
    readonly id: FieldRef<"serviceData", 'Int'>
    readonly text: FieldRef<"serviceData", 'String'>
    readonly bg: FieldRef<"serviceData", 'String'>
    readonly bg2: FieldRef<"serviceData", 'String'>
  }
    

  // Custom InputTypes

  /**
   * serviceData findUnique
   */
  export type serviceDataFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the serviceData
     */
    select?: serviceDataSelect<ExtArgs> | null
    /**
     * Filter, which serviceData to fetch.
     */
    where: serviceDataWhereUniqueInput
  }


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


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


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


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


  /**
   * serviceData create
   */
  export type serviceDataCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the serviceData
     */
    select?: serviceDataSelect<ExtArgs> | null
    /**
     * The data needed to create a serviceData.
     */
    data: XOR<serviceDataCreateInput, serviceDataUncheckedCreateInput>
  }


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


  /**
   * serviceData update
   */
  export type serviceDataUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the serviceData
     */
    select?: serviceDataSelect<ExtArgs> | null
    /**
     * The data needed to update a serviceData.
     */
    data: XOR<serviceDataUpdateInput, serviceDataUncheckedUpdateInput>
    /**
     * Choose, which serviceData to update.
     */
    where: serviceDataWhereUniqueInput
  }


  /**
   * serviceData updateMany
   */
  export type serviceDataUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update serviceData.
     */
    data: XOR<serviceDataUpdateManyMutationInput, serviceDataUncheckedUpdateManyInput>
    /**
     * Filter which serviceData to update
     */
    where?: serviceDataWhereInput
  }


  /**
   * serviceData upsert
   */
  export type serviceDataUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the serviceData
     */
    select?: serviceDataSelect<ExtArgs> | null
    /**
     * The filter to search for the serviceData to update in case it exists.
     */
    where: serviceDataWhereUniqueInput
    /**
     * In case the serviceData found by the `where` argument doesn't exist, create a new serviceData with this data.
     */
    create: XOR<serviceDataCreateInput, serviceDataUncheckedCreateInput>
    /**
     * In case the serviceData was found with the provided `where` argument, update it with this data.
     */
    update: XOR<serviceDataUpdateInput, serviceDataUncheckedUpdateInput>
  }


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


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


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



  /**
   * Model activitiesData
   */

  export type AggregateActivitiesData = {
    _count: ActivitiesDataCountAggregateOutputType | null
    _avg: ActivitiesDataAvgAggregateOutputType | null
    _sum: ActivitiesDataSumAggregateOutputType | null
    _min: ActivitiesDataMinAggregateOutputType | null
    _max: ActivitiesDataMaxAggregateOutputType | null
  }

  export type ActivitiesDataAvgAggregateOutputType = {
    id: number | null
  }

  export type ActivitiesDataSumAggregateOutputType = {
    id: number | null
  }

  export type ActivitiesDataMinAggregateOutputType = {
    id: number | null
    text: string | null
    bg: string | null
    bg2: string | null
  }

  export type ActivitiesDataMaxAggregateOutputType = {
    id: number | null
    text: string | null
    bg: string | null
    bg2: string | null
  }

  export type ActivitiesDataCountAggregateOutputType = {
    id: number
    text: number
    bg: number
    bg2: number
    _all: number
  }


  export type ActivitiesDataAvgAggregateInputType = {
    id?: true
  }

  export type ActivitiesDataSumAggregateInputType = {
    id?: true
  }

  export type ActivitiesDataMinAggregateInputType = {
    id?: true
    text?: true
    bg?: true
    bg2?: true
  }

  export type ActivitiesDataMaxAggregateInputType = {
    id?: true
    text?: true
    bg?: true
    bg2?: true
  }

  export type ActivitiesDataCountAggregateInputType = {
    id?: true
    text?: true
    bg?: true
    bg2?: true
    _all?: true
  }

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

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




  export type activitiesDataGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: activitiesDataWhereInput
    orderBy?: activitiesDataOrderByWithAggregationInput | activitiesDataOrderByWithAggregationInput[]
    by: ActivitiesDataScalarFieldEnum[] | ActivitiesDataScalarFieldEnum
    having?: activitiesDataScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ActivitiesDataCountAggregateInputType | true
    _avg?: ActivitiesDataAvgAggregateInputType
    _sum?: ActivitiesDataSumAggregateInputType
    _min?: ActivitiesDataMinAggregateInputType
    _max?: ActivitiesDataMaxAggregateInputType
  }

  export type ActivitiesDataGroupByOutputType = {
    id: number
    text: string
    bg: string
    bg2: string
    _count: ActivitiesDataCountAggregateOutputType | null
    _avg: ActivitiesDataAvgAggregateOutputType | null
    _sum: ActivitiesDataSumAggregateOutputType | null
    _min: ActivitiesDataMinAggregateOutputType | null
    _max: ActivitiesDataMaxAggregateOutputType | null
  }

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


  export type activitiesDataSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    text?: boolean
    bg?: boolean
    bg2?: boolean
  }, ExtArgs["result"]["activitiesData"]>

  export type activitiesDataSelectScalar = {
    id?: boolean
    text?: boolean
    bg?: boolean
    bg2?: boolean
  }


  export type $activitiesDataPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "activitiesData"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      text: string
      bg: string
      bg2: string
    }, ExtArgs["result"]["activitiesData"]>
    composites: {}
  }


  type activitiesDataGetPayload<S extends boolean | null | undefined | activitiesDataDefaultArgs> = $Result.GetResult<Prisma.$activitiesDataPayload, S>

  type activitiesDataCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<activitiesDataFindManyArgs, 'select' | 'include'> & {
      select?: ActivitiesDataCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a ActivitiesData.
     * @param {activitiesDataCreateArgs} args - Arguments to create a ActivitiesData.
     * @example
     * // Create one ActivitiesData
     * const ActivitiesData = await prisma.activitiesData.create({
     *   data: {
     *     // ... data to create a ActivitiesData
     *   }
     * })
     * 
    **/
    create<T extends activitiesDataCreateArgs<ExtArgs>>(
      args: SelectSubset<T, activitiesDataCreateArgs<ExtArgs>>
    ): Prisma__activitiesDataClient<$Result.GetResult<Prisma.$activitiesDataPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a ActivitiesData.
     * @param {activitiesDataDeleteArgs} args - Arguments to delete one ActivitiesData.
     * @example
     * // Delete one ActivitiesData
     * const ActivitiesData = await prisma.activitiesData.delete({
     *   where: {
     *     // ... filter to delete one ActivitiesData
     *   }
     * })
     * 
    **/
    delete<T extends activitiesDataDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, activitiesDataDeleteArgs<ExtArgs>>
    ): Prisma__activitiesDataClient<$Result.GetResult<Prisma.$activitiesDataPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for activitiesData.
   * 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__activitiesDataClient<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 activitiesData model
   */ 
  interface activitiesDataFieldRefs {
    readonly id: FieldRef<"activitiesData", 'Int'>
    readonly text: FieldRef<"activitiesData", 'String'>
    readonly bg: FieldRef<"activitiesData", 'String'>
    readonly bg2: FieldRef<"activitiesData", 'String'>
  }
    

  // Custom InputTypes

  /**
   * activitiesData findUnique
   */
  export type activitiesDataFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the activitiesData
     */
    select?: activitiesDataSelect<ExtArgs> | null
    /**
     * Filter, which activitiesData to fetch.
     */
    where: activitiesDataWhereUniqueInput
  }


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


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


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


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


  /**
   * activitiesData create
   */
  export type activitiesDataCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the activitiesData
     */
    select?: activitiesDataSelect<ExtArgs> | null
    /**
     * The data needed to create a activitiesData.
     */
    data: XOR<activitiesDataCreateInput, activitiesDataUncheckedCreateInput>
  }


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


  /**
   * activitiesData update
   */
  export type activitiesDataUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the activitiesData
     */
    select?: activitiesDataSelect<ExtArgs> | null
    /**
     * The data needed to update a activitiesData.
     */
    data: XOR<activitiesDataUpdateInput, activitiesDataUncheckedUpdateInput>
    /**
     * Choose, which activitiesData to update.
     */
    where: activitiesDataWhereUniqueInput
  }


  /**
   * activitiesData updateMany
   */
  export type activitiesDataUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update activitiesData.
     */
    data: XOR<activitiesDataUpdateManyMutationInput, activitiesDataUncheckedUpdateManyInput>
    /**
     * Filter which activitiesData to update
     */
    where?: activitiesDataWhereInput
  }


  /**
   * activitiesData upsert
   */
  export type activitiesDataUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the activitiesData
     */
    select?: activitiesDataSelect<ExtArgs> | null
    /**
     * The filter to search for the activitiesData to update in case it exists.
     */
    where: activitiesDataWhereUniqueInput
    /**
     * In case the activitiesData found by the `where` argument doesn't exist, create a new activitiesData with this data.
     */
    create: XOR<activitiesDataCreateInput, activitiesDataUncheckedCreateInput>
    /**
     * In case the activitiesData was found with the provided `where` argument, update it with this data.
     */
    update: XOR<activitiesDataUpdateInput, activitiesDataUncheckedUpdateInput>
  }


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


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


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



  /**
   * Model formerChairman
   */

  export type AggregateFormerChairman = {
    _count: FormerChairmanCountAggregateOutputType | null
    _avg: FormerChairmanAvgAggregateOutputType | null
    _sum: FormerChairmanSumAggregateOutputType | null
    _min: FormerChairmanMinAggregateOutputType | null
    _max: FormerChairmanMaxAggregateOutputType | null
  }

  export type FormerChairmanAvgAggregateOutputType = {
    id: number | null
  }

  export type FormerChairmanSumAggregateOutputType = {
    id: number | null
  }

  export type FormerChairmanMinAggregateOutputType = {
    id: number | null
    name: string | null
    position: string | null
    period: string | null
  }

  export type FormerChairmanMaxAggregateOutputType = {
    id: number | null
    name: string | null
    position: string | null
    period: string | null
  }

  export type FormerChairmanCountAggregateOutputType = {
    id: number
    name: number
    position: number
    period: number
    _all: number
  }


  export type FormerChairmanAvgAggregateInputType = {
    id?: true
  }

  export type FormerChairmanSumAggregateInputType = {
    id?: true
  }

  export type FormerChairmanMinAggregateInputType = {
    id?: true
    name?: true
    position?: true
    period?: true
  }

  export type FormerChairmanMaxAggregateInputType = {
    id?: true
    name?: true
    position?: true
    period?: true
  }

  export type FormerChairmanCountAggregateInputType = {
    id?: true
    name?: true
    position?: true
    period?: true
    _all?: true
  }

  export type FormerChairmanAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which formerChairman to aggregate.
     */
    where?: formerChairmanWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of formerChairmen to fetch.
     */
    orderBy?: formerChairmanOrderByWithRelationInput | formerChairmanOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: formerChairmanWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` formerChairmen from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` formerChairmen.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned formerChairmen
    **/
    _count?: true | FormerChairmanCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: FormerChairmanAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: FormerChairmanSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: FormerChairmanMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: FormerChairmanMaxAggregateInputType
  }

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




  export type formerChairmanGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: formerChairmanWhereInput
    orderBy?: formerChairmanOrderByWithAggregationInput | formerChairmanOrderByWithAggregationInput[]
    by: FormerChairmanScalarFieldEnum[] | FormerChairmanScalarFieldEnum
    having?: formerChairmanScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: FormerChairmanCountAggregateInputType | true
    _avg?: FormerChairmanAvgAggregateInputType
    _sum?: FormerChairmanSumAggregateInputType
    _min?: FormerChairmanMinAggregateInputType
    _max?: FormerChairmanMaxAggregateInputType
  }

  export type FormerChairmanGroupByOutputType = {
    id: number
    name: string
    position: string
    period: string
    _count: FormerChairmanCountAggregateOutputType | null
    _avg: FormerChairmanAvgAggregateOutputType | null
    _sum: FormerChairmanSumAggregateOutputType | null
    _min: FormerChairmanMinAggregateOutputType | null
    _max: FormerChairmanMaxAggregateOutputType | null
  }

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


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

  export type formerChairmanSelectScalar = {
    id?: boolean
    name?: boolean
    position?: boolean
    period?: boolean
  }


  export type $formerChairmanPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "formerChairman"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      name: string
      position: string
      period: string
    }, ExtArgs["result"]["formerChairman"]>
    composites: {}
  }


  type formerChairmanGetPayload<S extends boolean | null | undefined | formerChairmanDefaultArgs> = $Result.GetResult<Prisma.$formerChairmanPayload, S>

  type formerChairmanCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<formerChairmanFindManyArgs, 'select' | 'include'> & {
      select?: FormerChairmanCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a FormerChairman.
     * @param {formerChairmanCreateArgs} args - Arguments to create a FormerChairman.
     * @example
     * // Create one FormerChairman
     * const FormerChairman = await prisma.formerChairman.create({
     *   data: {
     *     // ... data to create a FormerChairman
     *   }
     * })
     * 
    **/
    create<T extends formerChairmanCreateArgs<ExtArgs>>(
      args: SelectSubset<T, formerChairmanCreateArgs<ExtArgs>>
    ): Prisma__formerChairmanClient<$Result.GetResult<Prisma.$formerChairmanPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a FormerChairman.
     * @param {formerChairmanDeleteArgs} args - Arguments to delete one FormerChairman.
     * @example
     * // Delete one FormerChairman
     * const FormerChairman = await prisma.formerChairman.delete({
     *   where: {
     *     // ... filter to delete one FormerChairman
     *   }
     * })
     * 
    **/
    delete<T extends formerChairmanDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, formerChairmanDeleteArgs<ExtArgs>>
    ): Prisma__formerChairmanClient<$Result.GetResult<Prisma.$formerChairmanPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for formerChairman.
   * 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__formerChairmanClient<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 formerChairman model
   */ 
  interface formerChairmanFieldRefs {
    readonly id: FieldRef<"formerChairman", 'Int'>
    readonly name: FieldRef<"formerChairman", 'String'>
    readonly position: FieldRef<"formerChairman", 'String'>
    readonly period: FieldRef<"formerChairman", 'String'>
  }
    

  // Custom InputTypes

  /**
   * formerChairman findUnique
   */
  export type formerChairmanFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the formerChairman
     */
    select?: formerChairmanSelect<ExtArgs> | null
    /**
     * Filter, which formerChairman to fetch.
     */
    where: formerChairmanWhereUniqueInput
  }


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


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


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


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


  /**
   * formerChairman create
   */
  export type formerChairmanCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the formerChairman
     */
    select?: formerChairmanSelect<ExtArgs> | null
    /**
     * The data needed to create a formerChairman.
     */
    data: XOR<formerChairmanCreateInput, formerChairmanUncheckedCreateInput>
  }


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


  /**
   * formerChairman update
   */
  export type formerChairmanUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the formerChairman
     */
    select?: formerChairmanSelect<ExtArgs> | null
    /**
     * The data needed to update a formerChairman.
     */
    data: XOR<formerChairmanUpdateInput, formerChairmanUncheckedUpdateInput>
    /**
     * Choose, which formerChairman to update.
     */
    where: formerChairmanWhereUniqueInput
  }


  /**
   * formerChairman updateMany
   */
  export type formerChairmanUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update formerChairmen.
     */
    data: XOR<formerChairmanUpdateManyMutationInput, formerChairmanUncheckedUpdateManyInput>
    /**
     * Filter which formerChairmen to update
     */
    where?: formerChairmanWhereInput
  }


  /**
   * formerChairman upsert
   */
  export type formerChairmanUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the formerChairman
     */
    select?: formerChairmanSelect<ExtArgs> | null
    /**
     * The filter to search for the formerChairman to update in case it exists.
     */
    where: formerChairmanWhereUniqueInput
    /**
     * In case the formerChairman found by the `where` argument doesn't exist, create a new formerChairman with this data.
     */
    create: XOR<formerChairmanCreateInput, formerChairmanUncheckedCreateInput>
    /**
     * In case the formerChairman was found with the provided `where` argument, update it with this data.
     */
    update: XOR<formerChairmanUpdateInput, formerChairmanUncheckedUpdateInput>
  }


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


  /**
   * formerChairman deleteMany
   */
  export type formerChairmanDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which formerChairmen to delete
     */
    where?: formerChairmanWhereInput
  }


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



  /**
   * Model formerSrViceChairman
   */

  export type AggregateFormerSrViceChairman = {
    _count: FormerSrViceChairmanCountAggregateOutputType | null
    _avg: FormerSrViceChairmanAvgAggregateOutputType | null
    _sum: FormerSrViceChairmanSumAggregateOutputType | null
    _min: FormerSrViceChairmanMinAggregateOutputType | null
    _max: FormerSrViceChairmanMaxAggregateOutputType | null
  }

  export type FormerSrViceChairmanAvgAggregateOutputType = {
    id: number | null
  }

  export type FormerSrViceChairmanSumAggregateOutputType = {
    id: number | null
  }

  export type FormerSrViceChairmanMinAggregateOutputType = {
    id: number | null
    name: string | null
    position: string | null
    period: string | null
  }

  export type FormerSrViceChairmanMaxAggregateOutputType = {
    id: number | null
    name: string | null
    position: string | null
    period: string | null
  }

  export type FormerSrViceChairmanCountAggregateOutputType = {
    id: number
    name: number
    position: number
    period: number
    _all: number
  }


  export type FormerSrViceChairmanAvgAggregateInputType = {
    id?: true
  }

  export type FormerSrViceChairmanSumAggregateInputType = {
    id?: true
  }

  export type FormerSrViceChairmanMinAggregateInputType = {
    id?: true
    name?: true
    position?: true
    period?: true
  }

  export type FormerSrViceChairmanMaxAggregateInputType = {
    id?: true
    name?: true
    position?: true
    period?: true
  }

  export type FormerSrViceChairmanCountAggregateInputType = {
    id?: true
    name?: true
    position?: true
    period?: true
    _all?: true
  }

  export type FormerSrViceChairmanAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which formerSrViceChairman to aggregate.
     */
    where?: formerSrViceChairmanWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of formerSrViceChairmen to fetch.
     */
    orderBy?: formerSrViceChairmanOrderByWithRelationInput | formerSrViceChairmanOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: formerSrViceChairmanWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` formerSrViceChairmen from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` formerSrViceChairmen.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned formerSrViceChairmen
    **/
    _count?: true | FormerSrViceChairmanCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: FormerSrViceChairmanAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: FormerSrViceChairmanSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: FormerSrViceChairmanMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: FormerSrViceChairmanMaxAggregateInputType
  }

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




  export type formerSrViceChairmanGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: formerSrViceChairmanWhereInput
    orderBy?: formerSrViceChairmanOrderByWithAggregationInput | formerSrViceChairmanOrderByWithAggregationInput[]
    by: FormerSrViceChairmanScalarFieldEnum[] | FormerSrViceChairmanScalarFieldEnum
    having?: formerSrViceChairmanScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: FormerSrViceChairmanCountAggregateInputType | true
    _avg?: FormerSrViceChairmanAvgAggregateInputType
    _sum?: FormerSrViceChairmanSumAggregateInputType
    _min?: FormerSrViceChairmanMinAggregateInputType
    _max?: FormerSrViceChairmanMaxAggregateInputType
  }

  export type FormerSrViceChairmanGroupByOutputType = {
    id: number
    name: string
    position: string
    period: string
    _count: FormerSrViceChairmanCountAggregateOutputType | null
    _avg: FormerSrViceChairmanAvgAggregateOutputType | null
    _sum: FormerSrViceChairmanSumAggregateOutputType | null
    _min: FormerSrViceChairmanMinAggregateOutputType | null
    _max: FormerSrViceChairmanMaxAggregateOutputType | null
  }

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


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

  export type formerSrViceChairmanSelectScalar = {
    id?: boolean
    name?: boolean
    position?: boolean
    period?: boolean
  }


  export type $formerSrViceChairmanPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "formerSrViceChairman"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      name: string
      position: string
      period: string
    }, ExtArgs["result"]["formerSrViceChairman"]>
    composites: {}
  }


  type formerSrViceChairmanGetPayload<S extends boolean | null | undefined | formerSrViceChairmanDefaultArgs> = $Result.GetResult<Prisma.$formerSrViceChairmanPayload, S>

  type formerSrViceChairmanCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<formerSrViceChairmanFindManyArgs, 'select' | 'include'> & {
      select?: FormerSrViceChairmanCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a FormerSrViceChairman.
     * @param {formerSrViceChairmanCreateArgs} args - Arguments to create a FormerSrViceChairman.
     * @example
     * // Create one FormerSrViceChairman
     * const FormerSrViceChairman = await prisma.formerSrViceChairman.create({
     *   data: {
     *     // ... data to create a FormerSrViceChairman
     *   }
     * })
     * 
    **/
    create<T extends formerSrViceChairmanCreateArgs<ExtArgs>>(
      args: SelectSubset<T, formerSrViceChairmanCreateArgs<ExtArgs>>
    ): Prisma__formerSrViceChairmanClient<$Result.GetResult<Prisma.$formerSrViceChairmanPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a FormerSrViceChairman.
     * @param {formerSrViceChairmanDeleteArgs} args - Arguments to delete one FormerSrViceChairman.
     * @example
     * // Delete one FormerSrViceChairman
     * const FormerSrViceChairman = await prisma.formerSrViceChairman.delete({
     *   where: {
     *     // ... filter to delete one FormerSrViceChairman
     *   }
     * })
     * 
    **/
    delete<T extends formerSrViceChairmanDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, formerSrViceChairmanDeleteArgs<ExtArgs>>
    ): Prisma__formerSrViceChairmanClient<$Result.GetResult<Prisma.$formerSrViceChairmanPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for formerSrViceChairman.
   * 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__formerSrViceChairmanClient<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 formerSrViceChairman model
   */ 
  interface formerSrViceChairmanFieldRefs {
    readonly id: FieldRef<"formerSrViceChairman", 'Int'>
    readonly name: FieldRef<"formerSrViceChairman", 'String'>
    readonly position: FieldRef<"formerSrViceChairman", 'String'>
    readonly period: FieldRef<"formerSrViceChairman", 'String'>
  }
    

  // Custom InputTypes

  /**
   * formerSrViceChairman findUnique
   */
  export type formerSrViceChairmanFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the formerSrViceChairman
     */
    select?: formerSrViceChairmanSelect<ExtArgs> | null
    /**
     * Filter, which formerSrViceChairman to fetch.
     */
    where: formerSrViceChairmanWhereUniqueInput
  }


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


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


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


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


  /**
   * formerSrViceChairman create
   */
  export type formerSrViceChairmanCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the formerSrViceChairman
     */
    select?: formerSrViceChairmanSelect<ExtArgs> | null
    /**
     * The data needed to create a formerSrViceChairman.
     */
    data: XOR<formerSrViceChairmanCreateInput, formerSrViceChairmanUncheckedCreateInput>
  }


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


  /**
   * formerSrViceChairman update
   */
  export type formerSrViceChairmanUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the formerSrViceChairman
     */
    select?: formerSrViceChairmanSelect<ExtArgs> | null
    /**
     * The data needed to update a formerSrViceChairman.
     */
    data: XOR<formerSrViceChairmanUpdateInput, formerSrViceChairmanUncheckedUpdateInput>
    /**
     * Choose, which formerSrViceChairman to update.
     */
    where: formerSrViceChairmanWhereUniqueInput
  }


  /**
   * formerSrViceChairman updateMany
   */
  export type formerSrViceChairmanUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update formerSrViceChairmen.
     */
    data: XOR<formerSrViceChairmanUpdateManyMutationInput, formerSrViceChairmanUncheckedUpdateManyInput>
    /**
     * Filter which formerSrViceChairmen to update
     */
    where?: formerSrViceChairmanWhereInput
  }


  /**
   * formerSrViceChairman upsert
   */
  export type formerSrViceChairmanUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the formerSrViceChairman
     */
    select?: formerSrViceChairmanSelect<ExtArgs> | null
    /**
     * The filter to search for the formerSrViceChairman to update in case it exists.
     */
    where: formerSrViceChairmanWhereUniqueInput
    /**
     * In case the formerSrViceChairman found by the `where` argument doesn't exist, create a new formerSrViceChairman with this data.
     */
    create: XOR<formerSrViceChairmanCreateInput, formerSrViceChairmanUncheckedCreateInput>
    /**
     * In case the formerSrViceChairman was found with the provided `where` argument, update it with this data.
     */
    update: XOR<formerSrViceChairmanUpdateInput, formerSrViceChairmanUncheckedUpdateInput>
  }


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


  /**
   * formerSrViceChairman deleteMany
   */
  export type formerSrViceChairmanDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which formerSrViceChairmen to delete
     */
    where?: formerSrViceChairmanWhereInput
  }


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



  /**
   * Model formerViceChairman
   */

  export type AggregateFormerViceChairman = {
    _count: FormerViceChairmanCountAggregateOutputType | null
    _avg: FormerViceChairmanAvgAggregateOutputType | null
    _sum: FormerViceChairmanSumAggregateOutputType | null
    _min: FormerViceChairmanMinAggregateOutputType | null
    _max: FormerViceChairmanMaxAggregateOutputType | null
  }

  export type FormerViceChairmanAvgAggregateOutputType = {
    id: number | null
  }

  export type FormerViceChairmanSumAggregateOutputType = {
    id: number | null
  }

  export type FormerViceChairmanMinAggregateOutputType = {
    id: number | null
    name: string | null
    position: string | null
    period: string | null
  }

  export type FormerViceChairmanMaxAggregateOutputType = {
    id: number | null
    name: string | null
    position: string | null
    period: string | null
  }

  export type FormerViceChairmanCountAggregateOutputType = {
    id: number
    name: number
    position: number
    period: number
    _all: number
  }


  export type FormerViceChairmanAvgAggregateInputType = {
    id?: true
  }

  export type FormerViceChairmanSumAggregateInputType = {
    id?: true
  }

  export type FormerViceChairmanMinAggregateInputType = {
    id?: true
    name?: true
    position?: true
    period?: true
  }

  export type FormerViceChairmanMaxAggregateInputType = {
    id?: true
    name?: true
    position?: true
    period?: true
  }

  export type FormerViceChairmanCountAggregateInputType = {
    id?: true
    name?: true
    position?: true
    period?: true
    _all?: true
  }

  export type FormerViceChairmanAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which formerViceChairman to aggregate.
     */
    where?: formerViceChairmanWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of formerViceChairmen to fetch.
     */
    orderBy?: formerViceChairmanOrderByWithRelationInput | formerViceChairmanOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: formerViceChairmanWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` formerViceChairmen from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` formerViceChairmen.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned formerViceChairmen
    **/
    _count?: true | FormerViceChairmanCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: FormerViceChairmanAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: FormerViceChairmanSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: FormerViceChairmanMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: FormerViceChairmanMaxAggregateInputType
  }

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




  export type formerViceChairmanGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: formerViceChairmanWhereInput
    orderBy?: formerViceChairmanOrderByWithAggregationInput | formerViceChairmanOrderByWithAggregationInput[]
    by: FormerViceChairmanScalarFieldEnum[] | FormerViceChairmanScalarFieldEnum
    having?: formerViceChairmanScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: FormerViceChairmanCountAggregateInputType | true
    _avg?: FormerViceChairmanAvgAggregateInputType
    _sum?: FormerViceChairmanSumAggregateInputType
    _min?: FormerViceChairmanMinAggregateInputType
    _max?: FormerViceChairmanMaxAggregateInputType
  }

  export type FormerViceChairmanGroupByOutputType = {
    id: number
    name: string
    position: string
    period: string
    _count: FormerViceChairmanCountAggregateOutputType | null
    _avg: FormerViceChairmanAvgAggregateOutputType | null
    _sum: FormerViceChairmanSumAggregateOutputType | null
    _min: FormerViceChairmanMinAggregateOutputType | null
    _max: FormerViceChairmanMaxAggregateOutputType | null
  }

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


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

  export type formerViceChairmanSelectScalar = {
    id?: boolean
    name?: boolean
    position?: boolean
    period?: boolean
  }


  export type $formerViceChairmanPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "formerViceChairman"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      name: string
      position: string
      period: string
    }, ExtArgs["result"]["formerViceChairman"]>
    composites: {}
  }


  type formerViceChairmanGetPayload<S extends boolean | null | undefined | formerViceChairmanDefaultArgs> = $Result.GetResult<Prisma.$formerViceChairmanPayload, S>

  type formerViceChairmanCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<formerViceChairmanFindManyArgs, 'select' | 'include'> & {
      select?: FormerViceChairmanCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a FormerViceChairman.
     * @param {formerViceChairmanCreateArgs} args - Arguments to create a FormerViceChairman.
     * @example
     * // Create one FormerViceChairman
     * const FormerViceChairman = await prisma.formerViceChairman.create({
     *   data: {
     *     // ... data to create a FormerViceChairman
     *   }
     * })
     * 
    **/
    create<T extends formerViceChairmanCreateArgs<ExtArgs>>(
      args: SelectSubset<T, formerViceChairmanCreateArgs<ExtArgs>>
    ): Prisma__formerViceChairmanClient<$Result.GetResult<Prisma.$formerViceChairmanPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a FormerViceChairman.
     * @param {formerViceChairmanDeleteArgs} args - Arguments to delete one FormerViceChairman.
     * @example
     * // Delete one FormerViceChairman
     * const FormerViceChairman = await prisma.formerViceChairman.delete({
     *   where: {
     *     // ... filter to delete one FormerViceChairman
     *   }
     * })
     * 
    **/
    delete<T extends formerViceChairmanDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, formerViceChairmanDeleteArgs<ExtArgs>>
    ): Prisma__formerViceChairmanClient<$Result.GetResult<Prisma.$formerViceChairmanPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for formerViceChairman.
   * 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__formerViceChairmanClient<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 formerViceChairman model
   */ 
  interface formerViceChairmanFieldRefs {
    readonly id: FieldRef<"formerViceChairman", 'Int'>
    readonly name: FieldRef<"formerViceChairman", 'String'>
    readonly position: FieldRef<"formerViceChairman", 'String'>
    readonly period: FieldRef<"formerViceChairman", 'String'>
  }
    

  // Custom InputTypes

  /**
   * formerViceChairman findUnique
   */
  export type formerViceChairmanFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the formerViceChairman
     */
    select?: formerViceChairmanSelect<ExtArgs> | null
    /**
     * Filter, which formerViceChairman to fetch.
     */
    where: formerViceChairmanWhereUniqueInput
  }


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


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


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


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


  /**
   * formerViceChairman create
   */
  export type formerViceChairmanCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the formerViceChairman
     */
    select?: formerViceChairmanSelect<ExtArgs> | null
    /**
     * The data needed to create a formerViceChairman.
     */
    data: XOR<formerViceChairmanCreateInput, formerViceChairmanUncheckedCreateInput>
  }


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


  /**
   * formerViceChairman update
   */
  export type formerViceChairmanUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the formerViceChairman
     */
    select?: formerViceChairmanSelect<ExtArgs> | null
    /**
     * The data needed to update a formerViceChairman.
     */
    data: XOR<formerViceChairmanUpdateInput, formerViceChairmanUncheckedUpdateInput>
    /**
     * Choose, which formerViceChairman to update.
     */
    where: formerViceChairmanWhereUniqueInput
  }


  /**
   * formerViceChairman updateMany
   */
  export type formerViceChairmanUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update formerViceChairmen.
     */
    data: XOR<formerViceChairmanUpdateManyMutationInput, formerViceChairmanUncheckedUpdateManyInput>
    /**
     * Filter which formerViceChairmen to update
     */
    where?: formerViceChairmanWhereInput
  }


  /**
   * formerViceChairman upsert
   */
  export type formerViceChairmanUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the formerViceChairman
     */
    select?: formerViceChairmanSelect<ExtArgs> | null
    /**
     * The filter to search for the formerViceChairman to update in case it exists.
     */
    where: formerViceChairmanWhereUniqueInput
    /**
     * In case the formerViceChairman found by the `where` argument doesn't exist, create a new formerViceChairman with this data.
     */
    create: XOR<formerViceChairmanCreateInput, formerViceChairmanUncheckedCreateInput>
    /**
     * In case the formerViceChairman was found with the provided `where` argument, update it with this data.
     */
    update: XOR<formerViceChairmanUpdateInput, formerViceChairmanUncheckedUpdateInput>
  }


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


  /**
   * formerViceChairman deleteMany
   */
  export type formerViceChairmanDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which formerViceChairmen to delete
     */
    where?: formerViceChairmanWhereInput
  }


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



  /**
   * Model ChairmanProfile
   */

  export type AggregateChairmanProfile = {
    _count: ChairmanProfileCountAggregateOutputType | null
    _avg: ChairmanProfileAvgAggregateOutputType | null
    _sum: ChairmanProfileSumAggregateOutputType | null
    _min: ChairmanProfileMinAggregateOutputType | null
    _max: ChairmanProfileMaxAggregateOutputType | null
  }

  export type ChairmanProfileAvgAggregateOutputType = {
    id: number | null
  }

  export type ChairmanProfileSumAggregateOutputType = {
    id: number | null
  }

  export type ChairmanProfileMinAggregateOutputType = {
    id: number | null
    image: string | null
    name: string | null
    academic: string | null
    profession: string | null
    business: string | null
    presentPosition: string | null
    foreignTravel: string | null
  }

  export type ChairmanProfileMaxAggregateOutputType = {
    id: number | null
    image: string | null
    name: string | null
    academic: string | null
    profession: string | null
    business: string | null
    presentPosition: string | null
    foreignTravel: string | null
  }

  export type ChairmanProfileCountAggregateOutputType = {
    id: number
    image: number
    name: number
    academic: number
    profession: number
    business: number
    presentPosition: number
    foreignTravel: number
    _all: number
  }


  export type ChairmanProfileAvgAggregateInputType = {
    id?: true
  }

  export type ChairmanProfileSumAggregateInputType = {
    id?: true
  }

  export type ChairmanProfileMinAggregateInputType = {
    id?: true
    image?: true
    name?: true
    academic?: true
    profession?: true
    business?: true
    presentPosition?: true
    foreignTravel?: true
  }

  export type ChairmanProfileMaxAggregateInputType = {
    id?: true
    image?: true
    name?: true
    academic?: true
    profession?: true
    business?: true
    presentPosition?: true
    foreignTravel?: true
  }

  export type ChairmanProfileCountAggregateInputType = {
    id?: true
    image?: true
    name?: true
    academic?: true
    profession?: true
    business?: true
    presentPosition?: true
    foreignTravel?: true
    _all?: true
  }

  export type ChairmanProfileAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ChairmanProfile to aggregate.
     */
    where?: ChairmanProfileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ChairmanProfiles to fetch.
     */
    orderBy?: ChairmanProfileOrderByWithRelationInput | ChairmanProfileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ChairmanProfileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ChairmanProfiles from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` ChairmanProfiles.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ChairmanProfiles
    **/
    _count?: true | ChairmanProfileCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ChairmanProfileAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ChairmanProfileSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ChairmanProfileMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ChairmanProfileMaxAggregateInputType
  }

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




  export type ChairmanProfileGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ChairmanProfileWhereInput
    orderBy?: ChairmanProfileOrderByWithAggregationInput | ChairmanProfileOrderByWithAggregationInput[]
    by: ChairmanProfileScalarFieldEnum[] | ChairmanProfileScalarFieldEnum
    having?: ChairmanProfileScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ChairmanProfileCountAggregateInputType | true
    _avg?: ChairmanProfileAvgAggregateInputType
    _sum?: ChairmanProfileSumAggregateInputType
    _min?: ChairmanProfileMinAggregateInputType
    _max?: ChairmanProfileMaxAggregateInputType
  }

  export type ChairmanProfileGroupByOutputType = {
    id: number
    image: string
    name: string
    academic: string
    profession: string
    business: string | null
    presentPosition: string
    foreignTravel: string | null
    _count: ChairmanProfileCountAggregateOutputType | null
    _avg: ChairmanProfileAvgAggregateOutputType | null
    _sum: ChairmanProfileSumAggregateOutputType | null
    _min: ChairmanProfileMinAggregateOutputType | null
    _max: ChairmanProfileMaxAggregateOutputType | null
  }

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


  export type ChairmanProfileSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    image?: boolean
    name?: boolean
    academic?: boolean
    profession?: boolean
    business?: boolean
    presentPosition?: boolean
    foreignTravel?: boolean
    associations?: boolean | ChairmanProfile$associationsArgs<ExtArgs>
    clubs?: boolean | ChairmanProfile$clubsArgs<ExtArgs>
    _count?: boolean | ChairmanProfileCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["chairmanProfile"]>

  export type ChairmanProfileSelectScalar = {
    id?: boolean
    image?: boolean
    name?: boolean
    academic?: boolean
    profession?: boolean
    business?: boolean
    presentPosition?: boolean
    foreignTravel?: boolean
  }

  export type ChairmanProfileInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    associations?: boolean | ChairmanProfile$associationsArgs<ExtArgs>
    clubs?: boolean | ChairmanProfile$clubsArgs<ExtArgs>
    _count?: boolean | ChairmanProfileCountOutputTypeDefaultArgs<ExtArgs>
  }


  export type $ChairmanProfilePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ChairmanProfile"
    objects: {
      associations: Prisma.$ChairmanAssociationPayload<ExtArgs>[]
      clubs: Prisma.$ChairmanClubsPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      image: string
      name: string
      academic: string
      profession: string
      business: string | null
      presentPosition: string
      foreignTravel: string | null
    }, ExtArgs["result"]["chairmanProfile"]>
    composites: {}
  }


  type ChairmanProfileGetPayload<S extends boolean | null | undefined | ChairmanProfileDefaultArgs> = $Result.GetResult<Prisma.$ChairmanProfilePayload, S>

  type ChairmanProfileCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ChairmanProfileFindManyArgs, 'select' | 'include'> & {
      select?: ChairmanProfileCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a ChairmanProfile.
     * @param {ChairmanProfileCreateArgs} args - Arguments to create a ChairmanProfile.
     * @example
     * // Create one ChairmanProfile
     * const ChairmanProfile = await prisma.chairmanProfile.create({
     *   data: {
     *     // ... data to create a ChairmanProfile
     *   }
     * })
     * 
    **/
    create<T extends ChairmanProfileCreateArgs<ExtArgs>>(
      args: SelectSubset<T, ChairmanProfileCreateArgs<ExtArgs>>
    ): Prisma__ChairmanProfileClient<$Result.GetResult<Prisma.$ChairmanProfilePayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a ChairmanProfile.
     * @param {ChairmanProfileDeleteArgs} args - Arguments to delete one ChairmanProfile.
     * @example
     * // Delete one ChairmanProfile
     * const ChairmanProfile = await prisma.chairmanProfile.delete({
     *   where: {
     *     // ... filter to delete one ChairmanProfile
     *   }
     * })
     * 
    **/
    delete<T extends ChairmanProfileDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, ChairmanProfileDeleteArgs<ExtArgs>>
    ): Prisma__ChairmanProfileClient<$Result.GetResult<Prisma.$ChairmanProfilePayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

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

    associations<T extends ChairmanProfile$associationsArgs<ExtArgs> = {}>(args?: Subset<T, ChairmanProfile$associationsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ChairmanAssociationPayload<ExtArgs>, T, 'findMany'> | Null>;

    clubs<T extends ChairmanProfile$clubsArgs<ExtArgs> = {}>(args?: Subset<T, ChairmanProfile$clubsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ChairmanClubsPayload<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 ChairmanProfile model
   */ 
  interface ChairmanProfileFieldRefs {
    readonly id: FieldRef<"ChairmanProfile", 'Int'>
    readonly image: FieldRef<"ChairmanProfile", 'String'>
    readonly name: FieldRef<"ChairmanProfile", 'String'>
    readonly academic: FieldRef<"ChairmanProfile", 'String'>
    readonly profession: FieldRef<"ChairmanProfile", 'String'>
    readonly business: FieldRef<"ChairmanProfile", 'String'>
    readonly presentPosition: FieldRef<"ChairmanProfile", 'String'>
    readonly foreignTravel: FieldRef<"ChairmanProfile", 'String'>
  }
    

  // Custom InputTypes

  /**
   * ChairmanProfile findUnique
   */
  export type ChairmanProfileFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanProfile
     */
    select?: ChairmanProfileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: ChairmanProfileInclude<ExtArgs> | null
    /**
     * Filter, which ChairmanProfile to fetch.
     */
    where: ChairmanProfileWhereUniqueInput
  }


  /**
   * ChairmanProfile findUniqueOrThrow
   */
  export type ChairmanProfileFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanProfile
     */
    select?: ChairmanProfileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: ChairmanProfileInclude<ExtArgs> | null
    /**
     * Filter, which ChairmanProfile to fetch.
     */
    where: ChairmanProfileWhereUniqueInput
  }


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


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


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


  /**
   * ChairmanProfile create
   */
  export type ChairmanProfileCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanProfile
     */
    select?: ChairmanProfileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: ChairmanProfileInclude<ExtArgs> | null
    /**
     * The data needed to create a ChairmanProfile.
     */
    data: XOR<ChairmanProfileCreateInput, ChairmanProfileUncheckedCreateInput>
  }


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


  /**
   * ChairmanProfile update
   */
  export type ChairmanProfileUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanProfile
     */
    select?: ChairmanProfileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: ChairmanProfileInclude<ExtArgs> | null
    /**
     * The data needed to update a ChairmanProfile.
     */
    data: XOR<ChairmanProfileUpdateInput, ChairmanProfileUncheckedUpdateInput>
    /**
     * Choose, which ChairmanProfile to update.
     */
    where: ChairmanProfileWhereUniqueInput
  }


  /**
   * ChairmanProfile updateMany
   */
  export type ChairmanProfileUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ChairmanProfiles.
     */
    data: XOR<ChairmanProfileUpdateManyMutationInput, ChairmanProfileUncheckedUpdateManyInput>
    /**
     * Filter which ChairmanProfiles to update
     */
    where?: ChairmanProfileWhereInput
  }


  /**
   * ChairmanProfile upsert
   */
  export type ChairmanProfileUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanProfile
     */
    select?: ChairmanProfileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: ChairmanProfileInclude<ExtArgs> | null
    /**
     * The filter to search for the ChairmanProfile to update in case it exists.
     */
    where: ChairmanProfileWhereUniqueInput
    /**
     * In case the ChairmanProfile found by the `where` argument doesn't exist, create a new ChairmanProfile with this data.
     */
    create: XOR<ChairmanProfileCreateInput, ChairmanProfileUncheckedCreateInput>
    /**
     * In case the ChairmanProfile was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ChairmanProfileUpdateInput, ChairmanProfileUncheckedUpdateInput>
  }


  /**
   * ChairmanProfile delete
   */
  export type ChairmanProfileDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanProfile
     */
    select?: ChairmanProfileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: ChairmanProfileInclude<ExtArgs> | null
    /**
     * Filter which ChairmanProfile to delete.
     */
    where: ChairmanProfileWhereUniqueInput
  }


  /**
   * ChairmanProfile deleteMany
   */
  export type ChairmanProfileDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ChairmanProfiles to delete
     */
    where?: ChairmanProfileWhereInput
  }


  /**
   * ChairmanProfile.associations
   */
  export type ChairmanProfile$associationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanAssociation
     */
    select?: ChairmanAssociationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: ChairmanAssociationInclude<ExtArgs> | null
    where?: ChairmanAssociationWhereInput
    orderBy?: ChairmanAssociationOrderByWithRelationInput | ChairmanAssociationOrderByWithRelationInput[]
    cursor?: ChairmanAssociationWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ChairmanAssociationScalarFieldEnum | ChairmanAssociationScalarFieldEnum[]
  }


  /**
   * ChairmanProfile.clubs
   */
  export type ChairmanProfile$clubsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanClubs
     */
    select?: ChairmanClubsSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: ChairmanClubsInclude<ExtArgs> | null
    where?: ChairmanClubsWhereInput
    orderBy?: ChairmanClubsOrderByWithRelationInput | ChairmanClubsOrderByWithRelationInput[]
    cursor?: ChairmanClubsWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ChairmanClubsScalarFieldEnum | ChairmanClubsScalarFieldEnum[]
  }


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



  /**
   * Model ChairmanAssociation
   */

  export type AggregateChairmanAssociation = {
    _count: ChairmanAssociationCountAggregateOutputType | null
    _avg: ChairmanAssociationAvgAggregateOutputType | null
    _sum: ChairmanAssociationSumAggregateOutputType | null
    _min: ChairmanAssociationMinAggregateOutputType | null
    _max: ChairmanAssociationMaxAggregateOutputType | null
  }

  export type ChairmanAssociationAvgAggregateOutputType = {
    id: number | null
    ChairmanProfileId: number | null
  }

  export type ChairmanAssociationSumAggregateOutputType = {
    id: number | null
    ChairmanProfileId: number | null
  }

  export type ChairmanAssociationMinAggregateOutputType = {
    id: number | null
    name: string | null
    text: string | null
    ChairmanProfileId: number | null
  }

  export type ChairmanAssociationMaxAggregateOutputType = {
    id: number | null
    name: string | null
    text: string | null
    ChairmanProfileId: number | null
  }

  export type ChairmanAssociationCountAggregateOutputType = {
    id: number
    name: number
    text: number
    ChairmanProfileId: number
    _all: number
  }


  export type ChairmanAssociationAvgAggregateInputType = {
    id?: true
    ChairmanProfileId?: true
  }

  export type ChairmanAssociationSumAggregateInputType = {
    id?: true
    ChairmanProfileId?: true
  }

  export type ChairmanAssociationMinAggregateInputType = {
    id?: true
    name?: true
    text?: true
    ChairmanProfileId?: true
  }

  export type ChairmanAssociationMaxAggregateInputType = {
    id?: true
    name?: true
    text?: true
    ChairmanProfileId?: true
  }

  export type ChairmanAssociationCountAggregateInputType = {
    id?: true
    name?: true
    text?: true
    ChairmanProfileId?: true
    _all?: true
  }

  export type ChairmanAssociationAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ChairmanAssociation to aggregate.
     */
    where?: ChairmanAssociationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ChairmanAssociations to fetch.
     */
    orderBy?: ChairmanAssociationOrderByWithRelationInput | ChairmanAssociationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ChairmanAssociationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ChairmanAssociations from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` ChairmanAssociations.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ChairmanAssociations
    **/
    _count?: true | ChairmanAssociationCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ChairmanAssociationAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ChairmanAssociationSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ChairmanAssociationMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ChairmanAssociationMaxAggregateInputType
  }

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




  export type ChairmanAssociationGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ChairmanAssociationWhereInput
    orderBy?: ChairmanAssociationOrderByWithAggregationInput | ChairmanAssociationOrderByWithAggregationInput[]
    by: ChairmanAssociationScalarFieldEnum[] | ChairmanAssociationScalarFieldEnum
    having?: ChairmanAssociationScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ChairmanAssociationCountAggregateInputType | true
    _avg?: ChairmanAssociationAvgAggregateInputType
    _sum?: ChairmanAssociationSumAggregateInputType
    _min?: ChairmanAssociationMinAggregateInputType
    _max?: ChairmanAssociationMaxAggregateInputType
  }

  export type ChairmanAssociationGroupByOutputType = {
    id: number
    name: string
    text: string
    ChairmanProfileId: number | null
    _count: ChairmanAssociationCountAggregateOutputType | null
    _avg: ChairmanAssociationAvgAggregateOutputType | null
    _sum: ChairmanAssociationSumAggregateOutputType | null
    _min: ChairmanAssociationMinAggregateOutputType | null
    _max: ChairmanAssociationMaxAggregateOutputType | null
  }

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


  export type ChairmanAssociationSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    text?: boolean
    ChairmanProfileId?: boolean
    profile?: boolean | ChairmanAssociation$profileArgs<ExtArgs>
  }, ExtArgs["result"]["chairmanAssociation"]>

  export type ChairmanAssociationSelectScalar = {
    id?: boolean
    name?: boolean
    text?: boolean
    ChairmanProfileId?: boolean
  }

  export type ChairmanAssociationInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    profile?: boolean | ChairmanAssociation$profileArgs<ExtArgs>
  }


  export type $ChairmanAssociationPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ChairmanAssociation"
    objects: {
      profile: Prisma.$ChairmanProfilePayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      name: string
      text: string
      ChairmanProfileId: number | null
    }, ExtArgs["result"]["chairmanAssociation"]>
    composites: {}
  }


  type ChairmanAssociationGetPayload<S extends boolean | null | undefined | ChairmanAssociationDefaultArgs> = $Result.GetResult<Prisma.$ChairmanAssociationPayload, S>

  type ChairmanAssociationCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ChairmanAssociationFindManyArgs, 'select' | 'include'> & {
      select?: ChairmanAssociationCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a ChairmanAssociation.
     * @param {ChairmanAssociationCreateArgs} args - Arguments to create a ChairmanAssociation.
     * @example
     * // Create one ChairmanAssociation
     * const ChairmanAssociation = await prisma.chairmanAssociation.create({
     *   data: {
     *     // ... data to create a ChairmanAssociation
     *   }
     * })
     * 
    **/
    create<T extends ChairmanAssociationCreateArgs<ExtArgs>>(
      args: SelectSubset<T, ChairmanAssociationCreateArgs<ExtArgs>>
    ): Prisma__ChairmanAssociationClient<$Result.GetResult<Prisma.$ChairmanAssociationPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a ChairmanAssociation.
     * @param {ChairmanAssociationDeleteArgs} args - Arguments to delete one ChairmanAssociation.
     * @example
     * // Delete one ChairmanAssociation
     * const ChairmanAssociation = await prisma.chairmanAssociation.delete({
     *   where: {
     *     // ... filter to delete one ChairmanAssociation
     *   }
     * })
     * 
    **/
    delete<T extends ChairmanAssociationDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, ChairmanAssociationDeleteArgs<ExtArgs>>
    ): Prisma__ChairmanAssociationClient<$Result.GetResult<Prisma.$ChairmanAssociationPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

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

    profile<T extends ChairmanAssociation$profileArgs<ExtArgs> = {}>(args?: Subset<T, ChairmanAssociation$profileArgs<ExtArgs>>): Prisma__ChairmanProfileClient<$Result.GetResult<Prisma.$ChairmanProfilePayload<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 ChairmanAssociation model
   */ 
  interface ChairmanAssociationFieldRefs {
    readonly id: FieldRef<"ChairmanAssociation", 'Int'>
    readonly name: FieldRef<"ChairmanAssociation", 'String'>
    readonly text: FieldRef<"ChairmanAssociation", 'String'>
    readonly ChairmanProfileId: FieldRef<"ChairmanAssociation", 'Int'>
  }
    

  // Custom InputTypes

  /**
   * ChairmanAssociation findUnique
   */
  export type ChairmanAssociationFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanAssociation
     */
    select?: ChairmanAssociationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: ChairmanAssociationInclude<ExtArgs> | null
    /**
     * Filter, which ChairmanAssociation to fetch.
     */
    where: ChairmanAssociationWhereUniqueInput
  }


  /**
   * ChairmanAssociation findUniqueOrThrow
   */
  export type ChairmanAssociationFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanAssociation
     */
    select?: ChairmanAssociationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: ChairmanAssociationInclude<ExtArgs> | null
    /**
     * Filter, which ChairmanAssociation to fetch.
     */
    where: ChairmanAssociationWhereUniqueInput
  }


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


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


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


  /**
   * ChairmanAssociation create
   */
  export type ChairmanAssociationCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanAssociation
     */
    select?: ChairmanAssociationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: ChairmanAssociationInclude<ExtArgs> | null
    /**
     * The data needed to create a ChairmanAssociation.
     */
    data: XOR<ChairmanAssociationCreateInput, ChairmanAssociationUncheckedCreateInput>
  }


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


  /**
   * ChairmanAssociation update
   */
  export type ChairmanAssociationUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanAssociation
     */
    select?: ChairmanAssociationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: ChairmanAssociationInclude<ExtArgs> | null
    /**
     * The data needed to update a ChairmanAssociation.
     */
    data: XOR<ChairmanAssociationUpdateInput, ChairmanAssociationUncheckedUpdateInput>
    /**
     * Choose, which ChairmanAssociation to update.
     */
    where: ChairmanAssociationWhereUniqueInput
  }


  /**
   * ChairmanAssociation updateMany
   */
  export type ChairmanAssociationUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ChairmanAssociations.
     */
    data: XOR<ChairmanAssociationUpdateManyMutationInput, ChairmanAssociationUncheckedUpdateManyInput>
    /**
     * Filter which ChairmanAssociations to update
     */
    where?: ChairmanAssociationWhereInput
  }


  /**
   * ChairmanAssociation upsert
   */
  export type ChairmanAssociationUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanAssociation
     */
    select?: ChairmanAssociationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: ChairmanAssociationInclude<ExtArgs> | null
    /**
     * The filter to search for the ChairmanAssociation to update in case it exists.
     */
    where: ChairmanAssociationWhereUniqueInput
    /**
     * In case the ChairmanAssociation found by the `where` argument doesn't exist, create a new ChairmanAssociation with this data.
     */
    create: XOR<ChairmanAssociationCreateInput, ChairmanAssociationUncheckedCreateInput>
    /**
     * In case the ChairmanAssociation was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ChairmanAssociationUpdateInput, ChairmanAssociationUncheckedUpdateInput>
  }


  /**
   * ChairmanAssociation delete
   */
  export type ChairmanAssociationDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanAssociation
     */
    select?: ChairmanAssociationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: ChairmanAssociationInclude<ExtArgs> | null
    /**
     * Filter which ChairmanAssociation to delete.
     */
    where: ChairmanAssociationWhereUniqueInput
  }


  /**
   * ChairmanAssociation deleteMany
   */
  export type ChairmanAssociationDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ChairmanAssociations to delete
     */
    where?: ChairmanAssociationWhereInput
  }


  /**
   * ChairmanAssociation.profile
   */
  export type ChairmanAssociation$profileArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanProfile
     */
    select?: ChairmanProfileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: ChairmanProfileInclude<ExtArgs> | null
    where?: ChairmanProfileWhereInput
  }


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



  /**
   * Model ChairmanClubs
   */

  export type AggregateChairmanClubs = {
    _count: ChairmanClubsCountAggregateOutputType | null
    _avg: ChairmanClubsAvgAggregateOutputType | null
    _sum: ChairmanClubsSumAggregateOutputType | null
    _min: ChairmanClubsMinAggregateOutputType | null
    _max: ChairmanClubsMaxAggregateOutputType | null
  }

  export type ChairmanClubsAvgAggregateOutputType = {
    id: number | null
    ChairmanProfileId: number | null
  }

  export type ChairmanClubsSumAggregateOutputType = {
    id: number | null
    ChairmanProfileId: number | null
  }

  export type ChairmanClubsMinAggregateOutputType = {
    id: number | null
    name: string | null
    text: string | null
    ChairmanProfileId: number | null
  }

  export type ChairmanClubsMaxAggregateOutputType = {
    id: number | null
    name: string | null
    text: string | null
    ChairmanProfileId: number | null
  }

  export type ChairmanClubsCountAggregateOutputType = {
    id: number
    name: number
    text: number
    ChairmanProfileId: number
    _all: number
  }


  export type ChairmanClubsAvgAggregateInputType = {
    id?: true
    ChairmanProfileId?: true
  }

  export type ChairmanClubsSumAggregateInputType = {
    id?: true
    ChairmanProfileId?: true
  }

  export type ChairmanClubsMinAggregateInputType = {
    id?: true
    name?: true
    text?: true
    ChairmanProfileId?: true
  }

  export type ChairmanClubsMaxAggregateInputType = {
    id?: true
    name?: true
    text?: true
    ChairmanProfileId?: true
  }

  export type ChairmanClubsCountAggregateInputType = {
    id?: true
    name?: true
    text?: true
    ChairmanProfileId?: true
    _all?: true
  }

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

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




  export type ChairmanClubsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ChairmanClubsWhereInput
    orderBy?: ChairmanClubsOrderByWithAggregationInput | ChairmanClubsOrderByWithAggregationInput[]
    by: ChairmanClubsScalarFieldEnum[] | ChairmanClubsScalarFieldEnum
    having?: ChairmanClubsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ChairmanClubsCountAggregateInputType | true
    _avg?: ChairmanClubsAvgAggregateInputType
    _sum?: ChairmanClubsSumAggregateInputType
    _min?: ChairmanClubsMinAggregateInputType
    _max?: ChairmanClubsMaxAggregateInputType
  }

  export type ChairmanClubsGroupByOutputType = {
    id: number
    name: string
    text: string
    ChairmanProfileId: number | null
    _count: ChairmanClubsCountAggregateOutputType | null
    _avg: ChairmanClubsAvgAggregateOutputType | null
    _sum: ChairmanClubsSumAggregateOutputType | null
    _min: ChairmanClubsMinAggregateOutputType | null
    _max: ChairmanClubsMaxAggregateOutputType | null
  }

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


  export type ChairmanClubsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    text?: boolean
    ChairmanProfileId?: boolean
    profile?: boolean | ChairmanClubs$profileArgs<ExtArgs>
  }, ExtArgs["result"]["chairmanClubs"]>

  export type ChairmanClubsSelectScalar = {
    id?: boolean
    name?: boolean
    text?: boolean
    ChairmanProfileId?: boolean
  }

  export type ChairmanClubsInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    profile?: boolean | ChairmanClubs$profileArgs<ExtArgs>
  }


  export type $ChairmanClubsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ChairmanClubs"
    objects: {
      profile: Prisma.$ChairmanProfilePayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      name: string
      text: string
      ChairmanProfileId: number | null
    }, ExtArgs["result"]["chairmanClubs"]>
    composites: {}
  }


  type ChairmanClubsGetPayload<S extends boolean | null | undefined | ChairmanClubsDefaultArgs> = $Result.GetResult<Prisma.$ChairmanClubsPayload, S>

  type ChairmanClubsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ChairmanClubsFindManyArgs, 'select' | 'include'> & {
      select?: ChairmanClubsCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a ChairmanClubs.
     * @param {ChairmanClubsCreateArgs} args - Arguments to create a ChairmanClubs.
     * @example
     * // Create one ChairmanClubs
     * const ChairmanClubs = await prisma.chairmanClubs.create({
     *   data: {
     *     // ... data to create a ChairmanClubs
     *   }
     * })
     * 
    **/
    create<T extends ChairmanClubsCreateArgs<ExtArgs>>(
      args: SelectSubset<T, ChairmanClubsCreateArgs<ExtArgs>>
    ): Prisma__ChairmanClubsClient<$Result.GetResult<Prisma.$ChairmanClubsPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a ChairmanClubs.
     * @param {ChairmanClubsDeleteArgs} args - Arguments to delete one ChairmanClubs.
     * @example
     * // Delete one ChairmanClubs
     * const ChairmanClubs = await prisma.chairmanClubs.delete({
     *   where: {
     *     // ... filter to delete one ChairmanClubs
     *   }
     * })
     * 
    **/
    delete<T extends ChairmanClubsDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, ChairmanClubsDeleteArgs<ExtArgs>>
    ): Prisma__ChairmanClubsClient<$Result.GetResult<Prisma.$ChairmanClubsPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

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

    profile<T extends ChairmanClubs$profileArgs<ExtArgs> = {}>(args?: Subset<T, ChairmanClubs$profileArgs<ExtArgs>>): Prisma__ChairmanProfileClient<$Result.GetResult<Prisma.$ChairmanProfilePayload<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 ChairmanClubs model
   */ 
  interface ChairmanClubsFieldRefs {
    readonly id: FieldRef<"ChairmanClubs", 'Int'>
    readonly name: FieldRef<"ChairmanClubs", 'String'>
    readonly text: FieldRef<"ChairmanClubs", 'String'>
    readonly ChairmanProfileId: FieldRef<"ChairmanClubs", 'Int'>
  }
    

  // Custom InputTypes

  /**
   * ChairmanClubs findUnique
   */
  export type ChairmanClubsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanClubs
     */
    select?: ChairmanClubsSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: ChairmanClubsInclude<ExtArgs> | null
    /**
     * Filter, which ChairmanClubs to fetch.
     */
    where: ChairmanClubsWhereUniqueInput
  }


  /**
   * ChairmanClubs findUniqueOrThrow
   */
  export type ChairmanClubsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanClubs
     */
    select?: ChairmanClubsSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: ChairmanClubsInclude<ExtArgs> | null
    /**
     * Filter, which ChairmanClubs to fetch.
     */
    where: ChairmanClubsWhereUniqueInput
  }


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


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


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


  /**
   * ChairmanClubs create
   */
  export type ChairmanClubsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanClubs
     */
    select?: ChairmanClubsSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: ChairmanClubsInclude<ExtArgs> | null
    /**
     * The data needed to create a ChairmanClubs.
     */
    data: XOR<ChairmanClubsCreateInput, ChairmanClubsUncheckedCreateInput>
  }


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


  /**
   * ChairmanClubs update
   */
  export type ChairmanClubsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanClubs
     */
    select?: ChairmanClubsSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: ChairmanClubsInclude<ExtArgs> | null
    /**
     * The data needed to update a ChairmanClubs.
     */
    data: XOR<ChairmanClubsUpdateInput, ChairmanClubsUncheckedUpdateInput>
    /**
     * Choose, which ChairmanClubs to update.
     */
    where: ChairmanClubsWhereUniqueInput
  }


  /**
   * ChairmanClubs updateMany
   */
  export type ChairmanClubsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ChairmanClubs.
     */
    data: XOR<ChairmanClubsUpdateManyMutationInput, ChairmanClubsUncheckedUpdateManyInput>
    /**
     * Filter which ChairmanClubs to update
     */
    where?: ChairmanClubsWhereInput
  }


  /**
   * ChairmanClubs upsert
   */
  export type ChairmanClubsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanClubs
     */
    select?: ChairmanClubsSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: ChairmanClubsInclude<ExtArgs> | null
    /**
     * The filter to search for the ChairmanClubs to update in case it exists.
     */
    where: ChairmanClubsWhereUniqueInput
    /**
     * In case the ChairmanClubs found by the `where` argument doesn't exist, create a new ChairmanClubs with this data.
     */
    create: XOR<ChairmanClubsCreateInput, ChairmanClubsUncheckedCreateInput>
    /**
     * In case the ChairmanClubs was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ChairmanClubsUpdateInput, ChairmanClubsUncheckedUpdateInput>
  }


  /**
   * ChairmanClubs delete
   */
  export type ChairmanClubsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanClubs
     */
    select?: ChairmanClubsSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: ChairmanClubsInclude<ExtArgs> | null
    /**
     * Filter which ChairmanClubs to delete.
     */
    where: ChairmanClubsWhereUniqueInput
  }


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


  /**
   * ChairmanClubs.profile
   */
  export type ChairmanClubs$profileArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanProfile
     */
    select?: ChairmanProfileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: ChairmanProfileInclude<ExtArgs> | null
    where?: ChairmanProfileWhereInput
  }


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



  /**
   * Model ChairmanMessage
   */

  export type AggregateChairmanMessage = {
    _count: ChairmanMessageCountAggregateOutputType | null
    _avg: ChairmanMessageAvgAggregateOutputType | null
    _sum: ChairmanMessageSumAggregateOutputType | null
    _min: ChairmanMessageMinAggregateOutputType | null
    _max: ChairmanMessageMaxAggregateOutputType | null
  }

  export type ChairmanMessageAvgAggregateOutputType = {
    id: number | null
  }

  export type ChairmanMessageSumAggregateOutputType = {
    id: number | null
  }

  export type ChairmanMessageMinAggregateOutputType = {
    id: number | null
    message: string | null
  }

  export type ChairmanMessageMaxAggregateOutputType = {
    id: number | null
    message: string | null
  }

  export type ChairmanMessageCountAggregateOutputType = {
    id: number
    message: number
    _all: number
  }


  export type ChairmanMessageAvgAggregateInputType = {
    id?: true
  }

  export type ChairmanMessageSumAggregateInputType = {
    id?: true
  }

  export type ChairmanMessageMinAggregateInputType = {
    id?: true
    message?: true
  }

  export type ChairmanMessageMaxAggregateInputType = {
    id?: true
    message?: true
  }

  export type ChairmanMessageCountAggregateInputType = {
    id?: true
    message?: true
    _all?: true
  }

  export type ChairmanMessageAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ChairmanMessage to aggregate.
     */
    where?: ChairmanMessageWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ChairmanMessages to fetch.
     */
    orderBy?: ChairmanMessageOrderByWithRelationInput | ChairmanMessageOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ChairmanMessageWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ChairmanMessages from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` ChairmanMessages.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ChairmanMessages
    **/
    _count?: true | ChairmanMessageCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ChairmanMessageAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ChairmanMessageSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ChairmanMessageMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ChairmanMessageMaxAggregateInputType
  }

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




  export type ChairmanMessageGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ChairmanMessageWhereInput
    orderBy?: ChairmanMessageOrderByWithAggregationInput | ChairmanMessageOrderByWithAggregationInput[]
    by: ChairmanMessageScalarFieldEnum[] | ChairmanMessageScalarFieldEnum
    having?: ChairmanMessageScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ChairmanMessageCountAggregateInputType | true
    _avg?: ChairmanMessageAvgAggregateInputType
    _sum?: ChairmanMessageSumAggregateInputType
    _min?: ChairmanMessageMinAggregateInputType
    _max?: ChairmanMessageMaxAggregateInputType
  }

  export type ChairmanMessageGroupByOutputType = {
    id: number
    message: string
    _count: ChairmanMessageCountAggregateOutputType | null
    _avg: ChairmanMessageAvgAggregateOutputType | null
    _sum: ChairmanMessageSumAggregateOutputType | null
    _min: ChairmanMessageMinAggregateOutputType | null
    _max: ChairmanMessageMaxAggregateOutputType | null
  }

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


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

  export type ChairmanMessageSelectScalar = {
    id?: boolean
    message?: boolean
  }


  export type $ChairmanMessagePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ChairmanMessage"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      message: string
    }, ExtArgs["result"]["chairmanMessage"]>
    composites: {}
  }


  type ChairmanMessageGetPayload<S extends boolean | null | undefined | ChairmanMessageDefaultArgs> = $Result.GetResult<Prisma.$ChairmanMessagePayload, S>

  type ChairmanMessageCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ChairmanMessageFindManyArgs, 'select' | 'include'> & {
      select?: ChairmanMessageCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a ChairmanMessage.
     * @param {ChairmanMessageCreateArgs} args - Arguments to create a ChairmanMessage.
     * @example
     * // Create one ChairmanMessage
     * const ChairmanMessage = await prisma.chairmanMessage.create({
     *   data: {
     *     // ... data to create a ChairmanMessage
     *   }
     * })
     * 
    **/
    create<T extends ChairmanMessageCreateArgs<ExtArgs>>(
      args: SelectSubset<T, ChairmanMessageCreateArgs<ExtArgs>>
    ): Prisma__ChairmanMessageClient<$Result.GetResult<Prisma.$ChairmanMessagePayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a ChairmanMessage.
     * @param {ChairmanMessageDeleteArgs} args - Arguments to delete one ChairmanMessage.
     * @example
     * // Delete one ChairmanMessage
     * const ChairmanMessage = await prisma.chairmanMessage.delete({
     *   where: {
     *     // ... filter to delete one ChairmanMessage
     *   }
     * })
     * 
    **/
    delete<T extends ChairmanMessageDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, ChairmanMessageDeleteArgs<ExtArgs>>
    ): Prisma__ChairmanMessageClient<$Result.GetResult<Prisma.$ChairmanMessagePayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for ChairmanMessage.
   * 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__ChairmanMessageClient<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 ChairmanMessage model
   */ 
  interface ChairmanMessageFieldRefs {
    readonly id: FieldRef<"ChairmanMessage", 'Int'>
    readonly message: FieldRef<"ChairmanMessage", 'String'>
  }
    

  // Custom InputTypes

  /**
   * ChairmanMessage findUnique
   */
  export type ChairmanMessageFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanMessage
     */
    select?: ChairmanMessageSelect<ExtArgs> | null
    /**
     * Filter, which ChairmanMessage to fetch.
     */
    where: ChairmanMessageWhereUniqueInput
  }


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


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


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


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


  /**
   * ChairmanMessage create
   */
  export type ChairmanMessageCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanMessage
     */
    select?: ChairmanMessageSelect<ExtArgs> | null
    /**
     * The data needed to create a ChairmanMessage.
     */
    data: XOR<ChairmanMessageCreateInput, ChairmanMessageUncheckedCreateInput>
  }


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


  /**
   * ChairmanMessage update
   */
  export type ChairmanMessageUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanMessage
     */
    select?: ChairmanMessageSelect<ExtArgs> | null
    /**
     * The data needed to update a ChairmanMessage.
     */
    data: XOR<ChairmanMessageUpdateInput, ChairmanMessageUncheckedUpdateInput>
    /**
     * Choose, which ChairmanMessage to update.
     */
    where: ChairmanMessageWhereUniqueInput
  }


  /**
   * ChairmanMessage updateMany
   */
  export type ChairmanMessageUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ChairmanMessages.
     */
    data: XOR<ChairmanMessageUpdateManyMutationInput, ChairmanMessageUncheckedUpdateManyInput>
    /**
     * Filter which ChairmanMessages to update
     */
    where?: ChairmanMessageWhereInput
  }


  /**
   * ChairmanMessage upsert
   */
  export type ChairmanMessageUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanMessage
     */
    select?: ChairmanMessageSelect<ExtArgs> | null
    /**
     * The filter to search for the ChairmanMessage to update in case it exists.
     */
    where: ChairmanMessageWhereUniqueInput
    /**
     * In case the ChairmanMessage found by the `where` argument doesn't exist, create a new ChairmanMessage with this data.
     */
    create: XOR<ChairmanMessageCreateInput, ChairmanMessageUncheckedCreateInput>
    /**
     * In case the ChairmanMessage was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ChairmanMessageUpdateInput, ChairmanMessageUncheckedUpdateInput>
  }


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


  /**
   * ChairmanMessage deleteMany
   */
  export type ChairmanMessageDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ChairmanMessages to delete
     */
    where?: ChairmanMessageWhereInput
  }


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



  /**
   * Model ChairmanSpeech
   */

  export type AggregateChairmanSpeech = {
    _count: ChairmanSpeechCountAggregateOutputType | null
    _avg: ChairmanSpeechAvgAggregateOutputType | null
    _sum: ChairmanSpeechSumAggregateOutputType | null
    _min: ChairmanSpeechMinAggregateOutputType | null
    _max: ChairmanSpeechMaxAggregateOutputType | null
  }

  export type ChairmanSpeechAvgAggregateOutputType = {
    id: number | null
  }

  export type ChairmanSpeechSumAggregateOutputType = {
    id: number | null
  }

  export type ChairmanSpeechMinAggregateOutputType = {
    id: number | null
    name: string | null
    pdf: string | null
    date: string | null
  }

  export type ChairmanSpeechMaxAggregateOutputType = {
    id: number | null
    name: string | null
    pdf: string | null
    date: string | null
  }

  export type ChairmanSpeechCountAggregateOutputType = {
    id: number
    name: number
    pdf: number
    date: number
    _all: number
  }


  export type ChairmanSpeechAvgAggregateInputType = {
    id?: true
  }

  export type ChairmanSpeechSumAggregateInputType = {
    id?: true
  }

  export type ChairmanSpeechMinAggregateInputType = {
    id?: true
    name?: true
    pdf?: true
    date?: true
  }

  export type ChairmanSpeechMaxAggregateInputType = {
    id?: true
    name?: true
    pdf?: true
    date?: true
  }

  export type ChairmanSpeechCountAggregateInputType = {
    id?: true
    name?: true
    pdf?: true
    date?: true
    _all?: true
  }

  export type ChairmanSpeechAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ChairmanSpeech to aggregate.
     */
    where?: ChairmanSpeechWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ChairmanSpeeches to fetch.
     */
    orderBy?: ChairmanSpeechOrderByWithRelationInput | ChairmanSpeechOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ChairmanSpeechWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ChairmanSpeeches from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` ChairmanSpeeches.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ChairmanSpeeches
    **/
    _count?: true | ChairmanSpeechCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ChairmanSpeechAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ChairmanSpeechSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ChairmanSpeechMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ChairmanSpeechMaxAggregateInputType
  }

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




  export type ChairmanSpeechGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ChairmanSpeechWhereInput
    orderBy?: ChairmanSpeechOrderByWithAggregationInput | ChairmanSpeechOrderByWithAggregationInput[]
    by: ChairmanSpeechScalarFieldEnum[] | ChairmanSpeechScalarFieldEnum
    having?: ChairmanSpeechScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ChairmanSpeechCountAggregateInputType | true
    _avg?: ChairmanSpeechAvgAggregateInputType
    _sum?: ChairmanSpeechSumAggregateInputType
    _min?: ChairmanSpeechMinAggregateInputType
    _max?: ChairmanSpeechMaxAggregateInputType
  }

  export type ChairmanSpeechGroupByOutputType = {
    id: number
    name: string
    pdf: string
    date: string
    _count: ChairmanSpeechCountAggregateOutputType | null
    _avg: ChairmanSpeechAvgAggregateOutputType | null
    _sum: ChairmanSpeechSumAggregateOutputType | null
    _min: ChairmanSpeechMinAggregateOutputType | null
    _max: ChairmanSpeechMaxAggregateOutputType | null
  }

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


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

  export type ChairmanSpeechSelectScalar = {
    id?: boolean
    name?: boolean
    pdf?: boolean
    date?: boolean
  }


  export type $ChairmanSpeechPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ChairmanSpeech"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      name: string
      pdf: string
      date: string
    }, ExtArgs["result"]["chairmanSpeech"]>
    composites: {}
  }


  type ChairmanSpeechGetPayload<S extends boolean | null | undefined | ChairmanSpeechDefaultArgs> = $Result.GetResult<Prisma.$ChairmanSpeechPayload, S>

  type ChairmanSpeechCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ChairmanSpeechFindManyArgs, 'select' | 'include'> & {
      select?: ChairmanSpeechCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a ChairmanSpeech.
     * @param {ChairmanSpeechCreateArgs} args - Arguments to create a ChairmanSpeech.
     * @example
     * // Create one ChairmanSpeech
     * const ChairmanSpeech = await prisma.chairmanSpeech.create({
     *   data: {
     *     // ... data to create a ChairmanSpeech
     *   }
     * })
     * 
    **/
    create<T extends ChairmanSpeechCreateArgs<ExtArgs>>(
      args: SelectSubset<T, ChairmanSpeechCreateArgs<ExtArgs>>
    ): Prisma__ChairmanSpeechClient<$Result.GetResult<Prisma.$ChairmanSpeechPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a ChairmanSpeech.
     * @param {ChairmanSpeechDeleteArgs} args - Arguments to delete one ChairmanSpeech.
     * @example
     * // Delete one ChairmanSpeech
     * const ChairmanSpeech = await prisma.chairmanSpeech.delete({
     *   where: {
     *     // ... filter to delete one ChairmanSpeech
     *   }
     * })
     * 
    **/
    delete<T extends ChairmanSpeechDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, ChairmanSpeechDeleteArgs<ExtArgs>>
    ): Prisma__ChairmanSpeechClient<$Result.GetResult<Prisma.$ChairmanSpeechPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for ChairmanSpeech.
   * 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__ChairmanSpeechClient<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 ChairmanSpeech model
   */ 
  interface ChairmanSpeechFieldRefs {
    readonly id: FieldRef<"ChairmanSpeech", 'Int'>
    readonly name: FieldRef<"ChairmanSpeech", 'String'>
    readonly pdf: FieldRef<"ChairmanSpeech", 'String'>
    readonly date: FieldRef<"ChairmanSpeech", 'String'>
  }
    

  // Custom InputTypes

  /**
   * ChairmanSpeech findUnique
   */
  export type ChairmanSpeechFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanSpeech
     */
    select?: ChairmanSpeechSelect<ExtArgs> | null
    /**
     * Filter, which ChairmanSpeech to fetch.
     */
    where: ChairmanSpeechWhereUniqueInput
  }


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


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


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


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


  /**
   * ChairmanSpeech create
   */
  export type ChairmanSpeechCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanSpeech
     */
    select?: ChairmanSpeechSelect<ExtArgs> | null
    /**
     * The data needed to create a ChairmanSpeech.
     */
    data: XOR<ChairmanSpeechCreateInput, ChairmanSpeechUncheckedCreateInput>
  }


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


  /**
   * ChairmanSpeech update
   */
  export type ChairmanSpeechUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanSpeech
     */
    select?: ChairmanSpeechSelect<ExtArgs> | null
    /**
     * The data needed to update a ChairmanSpeech.
     */
    data: XOR<ChairmanSpeechUpdateInput, ChairmanSpeechUncheckedUpdateInput>
    /**
     * Choose, which ChairmanSpeech to update.
     */
    where: ChairmanSpeechWhereUniqueInput
  }


  /**
   * ChairmanSpeech updateMany
   */
  export type ChairmanSpeechUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ChairmanSpeeches.
     */
    data: XOR<ChairmanSpeechUpdateManyMutationInput, ChairmanSpeechUncheckedUpdateManyInput>
    /**
     * Filter which ChairmanSpeeches to update
     */
    where?: ChairmanSpeechWhereInput
  }


  /**
   * ChairmanSpeech upsert
   */
  export type ChairmanSpeechUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanSpeech
     */
    select?: ChairmanSpeechSelect<ExtArgs> | null
    /**
     * The filter to search for the ChairmanSpeech to update in case it exists.
     */
    where: ChairmanSpeechWhereUniqueInput
    /**
     * In case the ChairmanSpeech found by the `where` argument doesn't exist, create a new ChairmanSpeech with this data.
     */
    create: XOR<ChairmanSpeechCreateInput, ChairmanSpeechUncheckedCreateInput>
    /**
     * In case the ChairmanSpeech was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ChairmanSpeechUpdateInput, ChairmanSpeechUncheckedUpdateInput>
  }


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


  /**
   * ChairmanSpeech deleteMany
   */
  export type ChairmanSpeechDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ChairmanSpeeches to delete
     */
    where?: ChairmanSpeechWhereInput
  }


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



  /**
   * Model ChairmanInterviewPrint
   */

  export type AggregateChairmanInterviewPrint = {
    _count: ChairmanInterviewPrintCountAggregateOutputType | null
    _avg: ChairmanInterviewPrintAvgAggregateOutputType | null
    _sum: ChairmanInterviewPrintSumAggregateOutputType | null
    _min: ChairmanInterviewPrintMinAggregateOutputType | null
    _max: ChairmanInterviewPrintMaxAggregateOutputType | null
  }

  export type ChairmanInterviewPrintAvgAggregateOutputType = {
    id: number | null
  }

  export type ChairmanInterviewPrintSumAggregateOutputType = {
    id: number | null
  }

  export type ChairmanInterviewPrintMinAggregateOutputType = {
    id: number | null
    name: string | null
    pdf: string | null
    date: string | null
  }

  export type ChairmanInterviewPrintMaxAggregateOutputType = {
    id: number | null
    name: string | null
    pdf: string | null
    date: string | null
  }

  export type ChairmanInterviewPrintCountAggregateOutputType = {
    id: number
    name: number
    pdf: number
    date: number
    _all: number
  }


  export type ChairmanInterviewPrintAvgAggregateInputType = {
    id?: true
  }

  export type ChairmanInterviewPrintSumAggregateInputType = {
    id?: true
  }

  export type ChairmanInterviewPrintMinAggregateInputType = {
    id?: true
    name?: true
    pdf?: true
    date?: true
  }

  export type ChairmanInterviewPrintMaxAggregateInputType = {
    id?: true
    name?: true
    pdf?: true
    date?: true
  }

  export type ChairmanInterviewPrintCountAggregateInputType = {
    id?: true
    name?: true
    pdf?: true
    date?: true
    _all?: true
  }

  export type ChairmanInterviewPrintAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ChairmanInterviewPrint to aggregate.
     */
    where?: ChairmanInterviewPrintWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ChairmanInterviewPrints to fetch.
     */
    orderBy?: ChairmanInterviewPrintOrderByWithRelationInput | ChairmanInterviewPrintOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ChairmanInterviewPrintWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ChairmanInterviewPrints from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` ChairmanInterviewPrints.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ChairmanInterviewPrints
    **/
    _count?: true | ChairmanInterviewPrintCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ChairmanInterviewPrintAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ChairmanInterviewPrintSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ChairmanInterviewPrintMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ChairmanInterviewPrintMaxAggregateInputType
  }

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




  export type ChairmanInterviewPrintGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ChairmanInterviewPrintWhereInput
    orderBy?: ChairmanInterviewPrintOrderByWithAggregationInput | ChairmanInterviewPrintOrderByWithAggregationInput[]
    by: ChairmanInterviewPrintScalarFieldEnum[] | ChairmanInterviewPrintScalarFieldEnum
    having?: ChairmanInterviewPrintScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ChairmanInterviewPrintCountAggregateInputType | true
    _avg?: ChairmanInterviewPrintAvgAggregateInputType
    _sum?: ChairmanInterviewPrintSumAggregateInputType
    _min?: ChairmanInterviewPrintMinAggregateInputType
    _max?: ChairmanInterviewPrintMaxAggregateInputType
  }

  export type ChairmanInterviewPrintGroupByOutputType = {
    id: number
    name: string
    pdf: string
    date: string
    _count: ChairmanInterviewPrintCountAggregateOutputType | null
    _avg: ChairmanInterviewPrintAvgAggregateOutputType | null
    _sum: ChairmanInterviewPrintSumAggregateOutputType | null
    _min: ChairmanInterviewPrintMinAggregateOutputType | null
    _max: ChairmanInterviewPrintMaxAggregateOutputType | null
  }

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


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

  export type ChairmanInterviewPrintSelectScalar = {
    id?: boolean
    name?: boolean
    pdf?: boolean
    date?: boolean
  }


  export type $ChairmanInterviewPrintPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ChairmanInterviewPrint"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      name: string
      pdf: string
      date: string
    }, ExtArgs["result"]["chairmanInterviewPrint"]>
    composites: {}
  }


  type ChairmanInterviewPrintGetPayload<S extends boolean | null | undefined | ChairmanInterviewPrintDefaultArgs> = $Result.GetResult<Prisma.$ChairmanInterviewPrintPayload, S>

  type ChairmanInterviewPrintCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ChairmanInterviewPrintFindManyArgs, 'select' | 'include'> & {
      select?: ChairmanInterviewPrintCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a ChairmanInterviewPrint.
     * @param {ChairmanInterviewPrintCreateArgs} args - Arguments to create a ChairmanInterviewPrint.
     * @example
     * // Create one ChairmanInterviewPrint
     * const ChairmanInterviewPrint = await prisma.chairmanInterviewPrint.create({
     *   data: {
     *     // ... data to create a ChairmanInterviewPrint
     *   }
     * })
     * 
    **/
    create<T extends ChairmanInterviewPrintCreateArgs<ExtArgs>>(
      args: SelectSubset<T, ChairmanInterviewPrintCreateArgs<ExtArgs>>
    ): Prisma__ChairmanInterviewPrintClient<$Result.GetResult<Prisma.$ChairmanInterviewPrintPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a ChairmanInterviewPrint.
     * @param {ChairmanInterviewPrintDeleteArgs} args - Arguments to delete one ChairmanInterviewPrint.
     * @example
     * // Delete one ChairmanInterviewPrint
     * const ChairmanInterviewPrint = await prisma.chairmanInterviewPrint.delete({
     *   where: {
     *     // ... filter to delete one ChairmanInterviewPrint
     *   }
     * })
     * 
    **/
    delete<T extends ChairmanInterviewPrintDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, ChairmanInterviewPrintDeleteArgs<ExtArgs>>
    ): Prisma__ChairmanInterviewPrintClient<$Result.GetResult<Prisma.$ChairmanInterviewPrintPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for ChairmanInterviewPrint.
   * 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__ChairmanInterviewPrintClient<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 ChairmanInterviewPrint model
   */ 
  interface ChairmanInterviewPrintFieldRefs {
    readonly id: FieldRef<"ChairmanInterviewPrint", 'Int'>
    readonly name: FieldRef<"ChairmanInterviewPrint", 'String'>
    readonly pdf: FieldRef<"ChairmanInterviewPrint", 'String'>
    readonly date: FieldRef<"ChairmanInterviewPrint", 'String'>
  }
    

  // Custom InputTypes

  /**
   * ChairmanInterviewPrint findUnique
   */
  export type ChairmanInterviewPrintFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanInterviewPrint
     */
    select?: ChairmanInterviewPrintSelect<ExtArgs> | null
    /**
     * Filter, which ChairmanInterviewPrint to fetch.
     */
    where: ChairmanInterviewPrintWhereUniqueInput
  }


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


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


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


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


  /**
   * ChairmanInterviewPrint create
   */
  export type ChairmanInterviewPrintCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanInterviewPrint
     */
    select?: ChairmanInterviewPrintSelect<ExtArgs> | null
    /**
     * The data needed to create a ChairmanInterviewPrint.
     */
    data: XOR<ChairmanInterviewPrintCreateInput, ChairmanInterviewPrintUncheckedCreateInput>
  }


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


  /**
   * ChairmanInterviewPrint update
   */
  export type ChairmanInterviewPrintUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanInterviewPrint
     */
    select?: ChairmanInterviewPrintSelect<ExtArgs> | null
    /**
     * The data needed to update a ChairmanInterviewPrint.
     */
    data: XOR<ChairmanInterviewPrintUpdateInput, ChairmanInterviewPrintUncheckedUpdateInput>
    /**
     * Choose, which ChairmanInterviewPrint to update.
     */
    where: ChairmanInterviewPrintWhereUniqueInput
  }


  /**
   * ChairmanInterviewPrint updateMany
   */
  export type ChairmanInterviewPrintUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ChairmanInterviewPrints.
     */
    data: XOR<ChairmanInterviewPrintUpdateManyMutationInput, ChairmanInterviewPrintUncheckedUpdateManyInput>
    /**
     * Filter which ChairmanInterviewPrints to update
     */
    where?: ChairmanInterviewPrintWhereInput
  }


  /**
   * ChairmanInterviewPrint upsert
   */
  export type ChairmanInterviewPrintUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanInterviewPrint
     */
    select?: ChairmanInterviewPrintSelect<ExtArgs> | null
    /**
     * The filter to search for the ChairmanInterviewPrint to update in case it exists.
     */
    where: ChairmanInterviewPrintWhereUniqueInput
    /**
     * In case the ChairmanInterviewPrint found by the `where` argument doesn't exist, create a new ChairmanInterviewPrint with this data.
     */
    create: XOR<ChairmanInterviewPrintCreateInput, ChairmanInterviewPrintUncheckedCreateInput>
    /**
     * In case the ChairmanInterviewPrint was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ChairmanInterviewPrintUpdateInput, ChairmanInterviewPrintUncheckedUpdateInput>
  }


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


  /**
   * ChairmanInterviewPrint deleteMany
   */
  export type ChairmanInterviewPrintDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ChairmanInterviewPrints to delete
     */
    where?: ChairmanInterviewPrintWhereInput
  }


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



  /**
   * Model ChairmanInterviewElectronic
   */

  export type AggregateChairmanInterviewElectronic = {
    _count: ChairmanInterviewElectronicCountAggregateOutputType | null
    _avg: ChairmanInterviewElectronicAvgAggregateOutputType | null
    _sum: ChairmanInterviewElectronicSumAggregateOutputType | null
    _min: ChairmanInterviewElectronicMinAggregateOutputType | null
    _max: ChairmanInterviewElectronicMaxAggregateOutputType | null
  }

  export type ChairmanInterviewElectronicAvgAggregateOutputType = {
    id: number | null
  }

  export type ChairmanInterviewElectronicSumAggregateOutputType = {
    id: number | null
  }

  export type ChairmanInterviewElectronicMinAggregateOutputType = {
    id: number | null
    title: string | null
    link: string | null
  }

  export type ChairmanInterviewElectronicMaxAggregateOutputType = {
    id: number | null
    title: string | null
    link: string | null
  }

  export type ChairmanInterviewElectronicCountAggregateOutputType = {
    id: number
    title: number
    link: number
    _all: number
  }


  export type ChairmanInterviewElectronicAvgAggregateInputType = {
    id?: true
  }

  export type ChairmanInterviewElectronicSumAggregateInputType = {
    id?: true
  }

  export type ChairmanInterviewElectronicMinAggregateInputType = {
    id?: true
    title?: true
    link?: true
  }

  export type ChairmanInterviewElectronicMaxAggregateInputType = {
    id?: true
    title?: true
    link?: true
  }

  export type ChairmanInterviewElectronicCountAggregateInputType = {
    id?: true
    title?: true
    link?: true
    _all?: true
  }

  export type ChairmanInterviewElectronicAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ChairmanInterviewElectronic to aggregate.
     */
    where?: ChairmanInterviewElectronicWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ChairmanInterviewElectronics to fetch.
     */
    orderBy?: ChairmanInterviewElectronicOrderByWithRelationInput | ChairmanInterviewElectronicOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ChairmanInterviewElectronicWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ChairmanInterviewElectronics from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` ChairmanInterviewElectronics.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ChairmanInterviewElectronics
    **/
    _count?: true | ChairmanInterviewElectronicCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ChairmanInterviewElectronicAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ChairmanInterviewElectronicSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ChairmanInterviewElectronicMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ChairmanInterviewElectronicMaxAggregateInputType
  }

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




  export type ChairmanInterviewElectronicGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ChairmanInterviewElectronicWhereInput
    orderBy?: ChairmanInterviewElectronicOrderByWithAggregationInput | ChairmanInterviewElectronicOrderByWithAggregationInput[]
    by: ChairmanInterviewElectronicScalarFieldEnum[] | ChairmanInterviewElectronicScalarFieldEnum
    having?: ChairmanInterviewElectronicScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ChairmanInterviewElectronicCountAggregateInputType | true
    _avg?: ChairmanInterviewElectronicAvgAggregateInputType
    _sum?: ChairmanInterviewElectronicSumAggregateInputType
    _min?: ChairmanInterviewElectronicMinAggregateInputType
    _max?: ChairmanInterviewElectronicMaxAggregateInputType
  }

  export type ChairmanInterviewElectronicGroupByOutputType = {
    id: number
    title: string
    link: string
    _count: ChairmanInterviewElectronicCountAggregateOutputType | null
    _avg: ChairmanInterviewElectronicAvgAggregateOutputType | null
    _sum: ChairmanInterviewElectronicSumAggregateOutputType | null
    _min: ChairmanInterviewElectronicMinAggregateOutputType | null
    _max: ChairmanInterviewElectronicMaxAggregateOutputType | null
  }

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


  export type ChairmanInterviewElectronicSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    link?: boolean
  }, ExtArgs["result"]["chairmanInterviewElectronic"]>

  export type ChairmanInterviewElectronicSelectScalar = {
    id?: boolean
    title?: boolean
    link?: boolean
  }


  export type $ChairmanInterviewElectronicPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ChairmanInterviewElectronic"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      title: string
      link: string
    }, ExtArgs["result"]["chairmanInterviewElectronic"]>
    composites: {}
  }


  type ChairmanInterviewElectronicGetPayload<S extends boolean | null | undefined | ChairmanInterviewElectronicDefaultArgs> = $Result.GetResult<Prisma.$ChairmanInterviewElectronicPayload, S>

  type ChairmanInterviewElectronicCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ChairmanInterviewElectronicFindManyArgs, 'select' | 'include'> & {
      select?: ChairmanInterviewElectronicCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a ChairmanInterviewElectronic.
     * @param {ChairmanInterviewElectronicCreateArgs} args - Arguments to create a ChairmanInterviewElectronic.
     * @example
     * // Create one ChairmanInterviewElectronic
     * const ChairmanInterviewElectronic = await prisma.chairmanInterviewElectronic.create({
     *   data: {
     *     // ... data to create a ChairmanInterviewElectronic
     *   }
     * })
     * 
    **/
    create<T extends ChairmanInterviewElectronicCreateArgs<ExtArgs>>(
      args: SelectSubset<T, ChairmanInterviewElectronicCreateArgs<ExtArgs>>
    ): Prisma__ChairmanInterviewElectronicClient<$Result.GetResult<Prisma.$ChairmanInterviewElectronicPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a ChairmanInterviewElectronic.
     * @param {ChairmanInterviewElectronicDeleteArgs} args - Arguments to delete one ChairmanInterviewElectronic.
     * @example
     * // Delete one ChairmanInterviewElectronic
     * const ChairmanInterviewElectronic = await prisma.chairmanInterviewElectronic.delete({
     *   where: {
     *     // ... filter to delete one ChairmanInterviewElectronic
     *   }
     * })
     * 
    **/
    delete<T extends ChairmanInterviewElectronicDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, ChairmanInterviewElectronicDeleteArgs<ExtArgs>>
    ): Prisma__ChairmanInterviewElectronicClient<$Result.GetResult<Prisma.$ChairmanInterviewElectronicPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for ChairmanInterviewElectronic.
   * 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__ChairmanInterviewElectronicClient<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 ChairmanInterviewElectronic model
   */ 
  interface ChairmanInterviewElectronicFieldRefs {
    readonly id: FieldRef<"ChairmanInterviewElectronic", 'Int'>
    readonly title: FieldRef<"ChairmanInterviewElectronic", 'String'>
    readonly link: FieldRef<"ChairmanInterviewElectronic", 'String'>
  }
    

  // Custom InputTypes

  /**
   * ChairmanInterviewElectronic findUnique
   */
  export type ChairmanInterviewElectronicFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanInterviewElectronic
     */
    select?: ChairmanInterviewElectronicSelect<ExtArgs> | null
    /**
     * Filter, which ChairmanInterviewElectronic to fetch.
     */
    where: ChairmanInterviewElectronicWhereUniqueInput
  }


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


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


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


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


  /**
   * ChairmanInterviewElectronic create
   */
  export type ChairmanInterviewElectronicCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanInterviewElectronic
     */
    select?: ChairmanInterviewElectronicSelect<ExtArgs> | null
    /**
     * The data needed to create a ChairmanInterviewElectronic.
     */
    data: XOR<ChairmanInterviewElectronicCreateInput, ChairmanInterviewElectronicUncheckedCreateInput>
  }


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


  /**
   * ChairmanInterviewElectronic update
   */
  export type ChairmanInterviewElectronicUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanInterviewElectronic
     */
    select?: ChairmanInterviewElectronicSelect<ExtArgs> | null
    /**
     * The data needed to update a ChairmanInterviewElectronic.
     */
    data: XOR<ChairmanInterviewElectronicUpdateInput, ChairmanInterviewElectronicUncheckedUpdateInput>
    /**
     * Choose, which ChairmanInterviewElectronic to update.
     */
    where: ChairmanInterviewElectronicWhereUniqueInput
  }


  /**
   * ChairmanInterviewElectronic updateMany
   */
  export type ChairmanInterviewElectronicUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ChairmanInterviewElectronics.
     */
    data: XOR<ChairmanInterviewElectronicUpdateManyMutationInput, ChairmanInterviewElectronicUncheckedUpdateManyInput>
    /**
     * Filter which ChairmanInterviewElectronics to update
     */
    where?: ChairmanInterviewElectronicWhereInput
  }


  /**
   * ChairmanInterviewElectronic upsert
   */
  export type ChairmanInterviewElectronicUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanInterviewElectronic
     */
    select?: ChairmanInterviewElectronicSelect<ExtArgs> | null
    /**
     * The filter to search for the ChairmanInterviewElectronic to update in case it exists.
     */
    where: ChairmanInterviewElectronicWhereUniqueInput
    /**
     * In case the ChairmanInterviewElectronic found by the `where` argument doesn't exist, create a new ChairmanInterviewElectronic with this data.
     */
    create: XOR<ChairmanInterviewElectronicCreateInput, ChairmanInterviewElectronicUncheckedCreateInput>
    /**
     * In case the ChairmanInterviewElectronic was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ChairmanInterviewElectronicUpdateInput, ChairmanInterviewElectronicUncheckedUpdateInput>
  }


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


  /**
   * ChairmanInterviewElectronic deleteMany
   */
  export type ChairmanInterviewElectronicDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ChairmanInterviewElectronics to delete
     */
    where?: ChairmanInterviewElectronicWhereInput
  }


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



  /**
   * Model ChairmanPresentation
   */

  export type AggregateChairmanPresentation = {
    _count: ChairmanPresentationCountAggregateOutputType | null
    _avg: ChairmanPresentationAvgAggregateOutputType | null
    _sum: ChairmanPresentationSumAggregateOutputType | null
    _min: ChairmanPresentationMinAggregateOutputType | null
    _max: ChairmanPresentationMaxAggregateOutputType | null
  }

  export type ChairmanPresentationAvgAggregateOutputType = {
    id: number | null
  }

  export type ChairmanPresentationSumAggregateOutputType = {
    id: number | null
  }

  export type ChairmanPresentationMinAggregateOutputType = {
    id: number | null
    name: string | null
    pdf: string | null
    date: string | null
  }

  export type ChairmanPresentationMaxAggregateOutputType = {
    id: number | null
    name: string | null
    pdf: string | null
    date: string | null
  }

  export type ChairmanPresentationCountAggregateOutputType = {
    id: number
    name: number
    pdf: number
    date: number
    _all: number
  }


  export type ChairmanPresentationAvgAggregateInputType = {
    id?: true
  }

  export type ChairmanPresentationSumAggregateInputType = {
    id?: true
  }

  export type ChairmanPresentationMinAggregateInputType = {
    id?: true
    name?: true
    pdf?: true
    date?: true
  }

  export type ChairmanPresentationMaxAggregateInputType = {
    id?: true
    name?: true
    pdf?: true
    date?: true
  }

  export type ChairmanPresentationCountAggregateInputType = {
    id?: true
    name?: true
    pdf?: true
    date?: true
    _all?: true
  }

  export type ChairmanPresentationAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ChairmanPresentation to aggregate.
     */
    where?: ChairmanPresentationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ChairmanPresentations to fetch.
     */
    orderBy?: ChairmanPresentationOrderByWithRelationInput | ChairmanPresentationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ChairmanPresentationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ChairmanPresentations from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` ChairmanPresentations.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ChairmanPresentations
    **/
    _count?: true | ChairmanPresentationCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ChairmanPresentationAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ChairmanPresentationSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ChairmanPresentationMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ChairmanPresentationMaxAggregateInputType
  }

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




  export type ChairmanPresentationGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ChairmanPresentationWhereInput
    orderBy?: ChairmanPresentationOrderByWithAggregationInput | ChairmanPresentationOrderByWithAggregationInput[]
    by: ChairmanPresentationScalarFieldEnum[] | ChairmanPresentationScalarFieldEnum
    having?: ChairmanPresentationScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ChairmanPresentationCountAggregateInputType | true
    _avg?: ChairmanPresentationAvgAggregateInputType
    _sum?: ChairmanPresentationSumAggregateInputType
    _min?: ChairmanPresentationMinAggregateInputType
    _max?: ChairmanPresentationMaxAggregateInputType
  }

  export type ChairmanPresentationGroupByOutputType = {
    id: number
    name: string
    pdf: string
    date: string
    _count: ChairmanPresentationCountAggregateOutputType | null
    _avg: ChairmanPresentationAvgAggregateOutputType | null
    _sum: ChairmanPresentationSumAggregateOutputType | null
    _min: ChairmanPresentationMinAggregateOutputType | null
    _max: ChairmanPresentationMaxAggregateOutputType | null
  }

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


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

  export type ChairmanPresentationSelectScalar = {
    id?: boolean
    name?: boolean
    pdf?: boolean
    date?: boolean
  }


  export type $ChairmanPresentationPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ChairmanPresentation"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      name: string
      pdf: string
      date: string
    }, ExtArgs["result"]["chairmanPresentation"]>
    composites: {}
  }


  type ChairmanPresentationGetPayload<S extends boolean | null | undefined | ChairmanPresentationDefaultArgs> = $Result.GetResult<Prisma.$ChairmanPresentationPayload, S>

  type ChairmanPresentationCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ChairmanPresentationFindManyArgs, 'select' | 'include'> & {
      select?: ChairmanPresentationCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a ChairmanPresentation.
     * @param {ChairmanPresentationCreateArgs} args - Arguments to create a ChairmanPresentation.
     * @example
     * // Create one ChairmanPresentation
     * const ChairmanPresentation = await prisma.chairmanPresentation.create({
     *   data: {
     *     // ... data to create a ChairmanPresentation
     *   }
     * })
     * 
    **/
    create<T extends ChairmanPresentationCreateArgs<ExtArgs>>(
      args: SelectSubset<T, ChairmanPresentationCreateArgs<ExtArgs>>
    ): Prisma__ChairmanPresentationClient<$Result.GetResult<Prisma.$ChairmanPresentationPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a ChairmanPresentation.
     * @param {ChairmanPresentationDeleteArgs} args - Arguments to delete one ChairmanPresentation.
     * @example
     * // Delete one ChairmanPresentation
     * const ChairmanPresentation = await prisma.chairmanPresentation.delete({
     *   where: {
     *     // ... filter to delete one ChairmanPresentation
     *   }
     * })
     * 
    **/
    delete<T extends ChairmanPresentationDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, ChairmanPresentationDeleteArgs<ExtArgs>>
    ): Prisma__ChairmanPresentationClient<$Result.GetResult<Prisma.$ChairmanPresentationPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for ChairmanPresentation.
   * 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__ChairmanPresentationClient<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 ChairmanPresentation model
   */ 
  interface ChairmanPresentationFieldRefs {
    readonly id: FieldRef<"ChairmanPresentation", 'Int'>
    readonly name: FieldRef<"ChairmanPresentation", 'String'>
    readonly pdf: FieldRef<"ChairmanPresentation", 'String'>
    readonly date: FieldRef<"ChairmanPresentation", 'String'>
  }
    

  // Custom InputTypes

  /**
   * ChairmanPresentation findUnique
   */
  export type ChairmanPresentationFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanPresentation
     */
    select?: ChairmanPresentationSelect<ExtArgs> | null
    /**
     * Filter, which ChairmanPresentation to fetch.
     */
    where: ChairmanPresentationWhereUniqueInput
  }


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


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


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


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


  /**
   * ChairmanPresentation create
   */
  export type ChairmanPresentationCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanPresentation
     */
    select?: ChairmanPresentationSelect<ExtArgs> | null
    /**
     * The data needed to create a ChairmanPresentation.
     */
    data: XOR<ChairmanPresentationCreateInput, ChairmanPresentationUncheckedCreateInput>
  }


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


  /**
   * ChairmanPresentation update
   */
  export type ChairmanPresentationUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanPresentation
     */
    select?: ChairmanPresentationSelect<ExtArgs> | null
    /**
     * The data needed to update a ChairmanPresentation.
     */
    data: XOR<ChairmanPresentationUpdateInput, ChairmanPresentationUncheckedUpdateInput>
    /**
     * Choose, which ChairmanPresentation to update.
     */
    where: ChairmanPresentationWhereUniqueInput
  }


  /**
   * ChairmanPresentation updateMany
   */
  export type ChairmanPresentationUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ChairmanPresentations.
     */
    data: XOR<ChairmanPresentationUpdateManyMutationInput, ChairmanPresentationUncheckedUpdateManyInput>
    /**
     * Filter which ChairmanPresentations to update
     */
    where?: ChairmanPresentationWhereInput
  }


  /**
   * ChairmanPresentation upsert
   */
  export type ChairmanPresentationUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ChairmanPresentation
     */
    select?: ChairmanPresentationSelect<ExtArgs> | null
    /**
     * The filter to search for the ChairmanPresentation to update in case it exists.
     */
    where: ChairmanPresentationWhereUniqueInput
    /**
     * In case the ChairmanPresentation found by the `where` argument doesn't exist, create a new ChairmanPresentation with this data.
     */
    create: XOR<ChairmanPresentationCreateInput, ChairmanPresentationUncheckedCreateInput>
    /**
     * In case the ChairmanPresentation was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ChairmanPresentationUpdateInput, ChairmanPresentationUncheckedUpdateInput>
  }


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


  /**
   * ChairmanPresentation deleteMany
   */
  export type ChairmanPresentationDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ChairmanPresentations to delete
     */
    where?: ChairmanPresentationWhereInput
  }


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



  /**
   * Model memorandum
   */

  export type AggregateMemorandum = {
    _count: MemorandumCountAggregateOutputType | null
    _avg: MemorandumAvgAggregateOutputType | null
    _sum: MemorandumSumAggregateOutputType | null
    _min: MemorandumMinAggregateOutputType | null
    _max: MemorandumMaxAggregateOutputType | null
  }

  export type MemorandumAvgAggregateOutputType = {
    id: number | null
  }

  export type MemorandumSumAggregateOutputType = {
    id: number | null
  }

  export type MemorandumMinAggregateOutputType = {
    id: number | null
    pdf: string | null
  }

  export type MemorandumMaxAggregateOutputType = {
    id: number | null
    pdf: string | null
  }

  export type MemorandumCountAggregateOutputType = {
    id: number
    pdf: number
    _all: number
  }


  export type MemorandumAvgAggregateInputType = {
    id?: true
  }

  export type MemorandumSumAggregateInputType = {
    id?: true
  }

  export type MemorandumMinAggregateInputType = {
    id?: true
    pdf?: true
  }

  export type MemorandumMaxAggregateInputType = {
    id?: true
    pdf?: true
  }

  export type MemorandumCountAggregateInputType = {
    id?: true
    pdf?: true
    _all?: true
  }

  export type MemorandumAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which memorandum to aggregate.
     */
    where?: memorandumWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of memorandums to fetch.
     */
    orderBy?: memorandumOrderByWithRelationInput | memorandumOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: memorandumWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` memorandums from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` memorandums.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned memorandums
    **/
    _count?: true | MemorandumCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: MemorandumAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: MemorandumSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: MemorandumMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: MemorandumMaxAggregateInputType
  }

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




  export type memorandumGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: memorandumWhereInput
    orderBy?: memorandumOrderByWithAggregationInput | memorandumOrderByWithAggregationInput[]
    by: MemorandumScalarFieldEnum[] | MemorandumScalarFieldEnum
    having?: memorandumScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: MemorandumCountAggregateInputType | true
    _avg?: MemorandumAvgAggregateInputType
    _sum?: MemorandumSumAggregateInputType
    _min?: MemorandumMinAggregateInputType
    _max?: MemorandumMaxAggregateInputType
  }

  export type MemorandumGroupByOutputType = {
    id: number
    pdf: string
    _count: MemorandumCountAggregateOutputType | null
    _avg: MemorandumAvgAggregateOutputType | null
    _sum: MemorandumSumAggregateOutputType | null
    _min: MemorandumMinAggregateOutputType | null
    _max: MemorandumMaxAggregateOutputType | null
  }

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


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

  export type memorandumSelectScalar = {
    id?: boolean
    pdf?: boolean
  }


  export type $memorandumPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "memorandum"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      pdf: string
    }, ExtArgs["result"]["memorandum"]>
    composites: {}
  }


  type memorandumGetPayload<S extends boolean | null | undefined | memorandumDefaultArgs> = $Result.GetResult<Prisma.$memorandumPayload, S>

  type memorandumCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<memorandumFindManyArgs, 'select' | 'include'> & {
      select?: MemorandumCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Memorandum.
     * @param {memorandumCreateArgs} args - Arguments to create a Memorandum.
     * @example
     * // Create one Memorandum
     * const Memorandum = await prisma.memorandum.create({
     *   data: {
     *     // ... data to create a Memorandum
     *   }
     * })
     * 
    **/
    create<T extends memorandumCreateArgs<ExtArgs>>(
      args: SelectSubset<T, memorandumCreateArgs<ExtArgs>>
    ): Prisma__memorandumClient<$Result.GetResult<Prisma.$memorandumPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a Memorandum.
     * @param {memorandumDeleteArgs} args - Arguments to delete one Memorandum.
     * @example
     * // Delete one Memorandum
     * const Memorandum = await prisma.memorandum.delete({
     *   where: {
     *     // ... filter to delete one Memorandum
     *   }
     * })
     * 
    **/
    delete<T extends memorandumDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, memorandumDeleteArgs<ExtArgs>>
    ): Prisma__memorandumClient<$Result.GetResult<Prisma.$memorandumPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for memorandum.
   * 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__memorandumClient<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 memorandum model
   */ 
  interface memorandumFieldRefs {
    readonly id: FieldRef<"memorandum", 'Int'>
    readonly pdf: FieldRef<"memorandum", 'String'>
  }
    

  // Custom InputTypes

  /**
   * memorandum findUnique
   */
  export type memorandumFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the memorandum
     */
    select?: memorandumSelect<ExtArgs> | null
    /**
     * Filter, which memorandum to fetch.
     */
    where: memorandumWhereUniqueInput
  }


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


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


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


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


  /**
   * memorandum create
   */
  export type memorandumCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the memorandum
     */
    select?: memorandumSelect<ExtArgs> | null
    /**
     * The data needed to create a memorandum.
     */
    data: XOR<memorandumCreateInput, memorandumUncheckedCreateInput>
  }


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


  /**
   * memorandum update
   */
  export type memorandumUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the memorandum
     */
    select?: memorandumSelect<ExtArgs> | null
    /**
     * The data needed to update a memorandum.
     */
    data: XOR<memorandumUpdateInput, memorandumUncheckedUpdateInput>
    /**
     * Choose, which memorandum to update.
     */
    where: memorandumWhereUniqueInput
  }


  /**
   * memorandum updateMany
   */
  export type memorandumUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update memorandums.
     */
    data: XOR<memorandumUpdateManyMutationInput, memorandumUncheckedUpdateManyInput>
    /**
     * Filter which memorandums to update
     */
    where?: memorandumWhereInput
  }


  /**
   * memorandum upsert
   */
  export type memorandumUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the memorandum
     */
    select?: memorandumSelect<ExtArgs> | null
    /**
     * The filter to search for the memorandum to update in case it exists.
     */
    where: memorandumWhereUniqueInput
    /**
     * In case the memorandum found by the `where` argument doesn't exist, create a new memorandum with this data.
     */
    create: XOR<memorandumCreateInput, memorandumUncheckedCreateInput>
    /**
     * In case the memorandum was found with the provided `where` argument, update it with this data.
     */
    update: XOR<memorandumUpdateInput, memorandumUncheckedUpdateInput>
  }


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


  /**
   * memorandum deleteMany
   */
  export type memorandumDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which memorandums to delete
     */
    where?: memorandumWhereInput
  }


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



  /**
   * Model BoardOfDirectors
   */

  export type AggregateBoardOfDirectors = {
    _count: BoardOfDirectorsCountAggregateOutputType | null
    _avg: BoardOfDirectorsAvgAggregateOutputType | null
    _sum: BoardOfDirectorsSumAggregateOutputType | null
    _min: BoardOfDirectorsMinAggregateOutputType | null
    _max: BoardOfDirectorsMaxAggregateOutputType | null
  }

  export type BoardOfDirectorsAvgAggregateOutputType = {
    id: number | null
  }

  export type BoardOfDirectorsSumAggregateOutputType = {
    id: number | null
  }

  export type BoardOfDirectorsMinAggregateOutputType = {
    id: number | null
    image: string | null
    name: string | null
    designation: string | null
  }

  export type BoardOfDirectorsMaxAggregateOutputType = {
    id: number | null
    image: string | null
    name: string | null
    designation: string | null
  }

  export type BoardOfDirectorsCountAggregateOutputType = {
    id: number
    image: number
    name: number
    designation: number
    _all: number
  }


  export type BoardOfDirectorsAvgAggregateInputType = {
    id?: true
  }

  export type BoardOfDirectorsSumAggregateInputType = {
    id?: true
  }

  export type BoardOfDirectorsMinAggregateInputType = {
    id?: true
    image?: true
    name?: true
    designation?: true
  }

  export type BoardOfDirectorsMaxAggregateInputType = {
    id?: true
    image?: true
    name?: true
    designation?: true
  }

  export type BoardOfDirectorsCountAggregateInputType = {
    id?: true
    image?: true
    name?: true
    designation?: true
    _all?: true
  }

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

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




  export type BoardOfDirectorsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: BoardOfDirectorsWhereInput
    orderBy?: BoardOfDirectorsOrderByWithAggregationInput | BoardOfDirectorsOrderByWithAggregationInput[]
    by: BoardOfDirectorsScalarFieldEnum[] | BoardOfDirectorsScalarFieldEnum
    having?: BoardOfDirectorsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: BoardOfDirectorsCountAggregateInputType | true
    _avg?: BoardOfDirectorsAvgAggregateInputType
    _sum?: BoardOfDirectorsSumAggregateInputType
    _min?: BoardOfDirectorsMinAggregateInputType
    _max?: BoardOfDirectorsMaxAggregateInputType
  }

  export type BoardOfDirectorsGroupByOutputType = {
    id: number
    image: string
    name: string
    designation: string
    _count: BoardOfDirectorsCountAggregateOutputType | null
    _avg: BoardOfDirectorsAvgAggregateOutputType | null
    _sum: BoardOfDirectorsSumAggregateOutputType | null
    _min: BoardOfDirectorsMinAggregateOutputType | null
    _max: BoardOfDirectorsMaxAggregateOutputType | null
  }

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


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

  export type BoardOfDirectorsSelectScalar = {
    id?: boolean
    image?: boolean
    name?: boolean
    designation?: boolean
  }


  export type $BoardOfDirectorsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "BoardOfDirectors"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      image: string
      name: string
      designation: string
    }, ExtArgs["result"]["boardOfDirectors"]>
    composites: {}
  }


  type BoardOfDirectorsGetPayload<S extends boolean | null | undefined | BoardOfDirectorsDefaultArgs> = $Result.GetResult<Prisma.$BoardOfDirectorsPayload, S>

  type BoardOfDirectorsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<BoardOfDirectorsFindManyArgs, 'select' | 'include'> & {
      select?: BoardOfDirectorsCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a BoardOfDirectors.
     * @param {BoardOfDirectorsCreateArgs} args - Arguments to create a BoardOfDirectors.
     * @example
     * // Create one BoardOfDirectors
     * const BoardOfDirectors = await prisma.boardOfDirectors.create({
     *   data: {
     *     // ... data to create a BoardOfDirectors
     *   }
     * })
     * 
    **/
    create<T extends BoardOfDirectorsCreateArgs<ExtArgs>>(
      args: SelectSubset<T, BoardOfDirectorsCreateArgs<ExtArgs>>
    ): Prisma__BoardOfDirectorsClient<$Result.GetResult<Prisma.$BoardOfDirectorsPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a BoardOfDirectors.
     * @param {BoardOfDirectorsDeleteArgs} args - Arguments to delete one BoardOfDirectors.
     * @example
     * // Delete one BoardOfDirectors
     * const BoardOfDirectors = await prisma.boardOfDirectors.delete({
     *   where: {
     *     // ... filter to delete one BoardOfDirectors
     *   }
     * })
     * 
    **/
    delete<T extends BoardOfDirectorsDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, BoardOfDirectorsDeleteArgs<ExtArgs>>
    ): Prisma__BoardOfDirectorsClient<$Result.GetResult<Prisma.$BoardOfDirectorsPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for BoardOfDirectors.
   * 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__BoardOfDirectorsClient<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 BoardOfDirectors model
   */ 
  interface BoardOfDirectorsFieldRefs {
    readonly id: FieldRef<"BoardOfDirectors", 'Int'>
    readonly image: FieldRef<"BoardOfDirectors", 'String'>
    readonly name: FieldRef<"BoardOfDirectors", 'String'>
    readonly designation: FieldRef<"BoardOfDirectors", 'String'>
  }
    

  // Custom InputTypes

  /**
   * BoardOfDirectors findUnique
   */
  export type BoardOfDirectorsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BoardOfDirectors
     */
    select?: BoardOfDirectorsSelect<ExtArgs> | null
    /**
     * Filter, which BoardOfDirectors to fetch.
     */
    where: BoardOfDirectorsWhereUniqueInput
  }


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


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


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


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


  /**
   * BoardOfDirectors create
   */
  export type BoardOfDirectorsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BoardOfDirectors
     */
    select?: BoardOfDirectorsSelect<ExtArgs> | null
    /**
     * The data needed to create a BoardOfDirectors.
     */
    data: XOR<BoardOfDirectorsCreateInput, BoardOfDirectorsUncheckedCreateInput>
  }


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


  /**
   * BoardOfDirectors update
   */
  export type BoardOfDirectorsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BoardOfDirectors
     */
    select?: BoardOfDirectorsSelect<ExtArgs> | null
    /**
     * The data needed to update a BoardOfDirectors.
     */
    data: XOR<BoardOfDirectorsUpdateInput, BoardOfDirectorsUncheckedUpdateInput>
    /**
     * Choose, which BoardOfDirectors to update.
     */
    where: BoardOfDirectorsWhereUniqueInput
  }


  /**
   * BoardOfDirectors updateMany
   */
  export type BoardOfDirectorsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update BoardOfDirectors.
     */
    data: XOR<BoardOfDirectorsUpdateManyMutationInput, BoardOfDirectorsUncheckedUpdateManyInput>
    /**
     * Filter which BoardOfDirectors to update
     */
    where?: BoardOfDirectorsWhereInput
  }


  /**
   * BoardOfDirectors upsert
   */
  export type BoardOfDirectorsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BoardOfDirectors
     */
    select?: BoardOfDirectorsSelect<ExtArgs> | null
    /**
     * The filter to search for the BoardOfDirectors to update in case it exists.
     */
    where: BoardOfDirectorsWhereUniqueInput
    /**
     * In case the BoardOfDirectors found by the `where` argument doesn't exist, create a new BoardOfDirectors with this data.
     */
    create: XOR<BoardOfDirectorsCreateInput, BoardOfDirectorsUncheckedCreateInput>
    /**
     * In case the BoardOfDirectors was found with the provided `where` argument, update it with this data.
     */
    update: XOR<BoardOfDirectorsUpdateInput, BoardOfDirectorsUncheckedUpdateInput>
  }


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


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


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



  /**
   * Model ShippersNews
   */

  export type AggregateShippersNews = {
    _count: ShippersNewsCountAggregateOutputType | null
    _avg: ShippersNewsAvgAggregateOutputType | null
    _sum: ShippersNewsSumAggregateOutputType | null
    _min: ShippersNewsMinAggregateOutputType | null
    _max: ShippersNewsMaxAggregateOutputType | null
  }

  export type ShippersNewsAvgAggregateOutputType = {
    id: number | null
    volume: number | null
  }

  export type ShippersNewsSumAggregateOutputType = {
    id: number | null
    volume: number | null
  }

  export type ShippersNewsMinAggregateOutputType = {
    id: number | null
    image: string | null
    name: string | null
    date: string | null
    volume: number | null
    pdf: string | null
  }

  export type ShippersNewsMaxAggregateOutputType = {
    id: number | null
    image: string | null
    name: string | null
    date: string | null
    volume: number | null
    pdf: string | null
  }

  export type ShippersNewsCountAggregateOutputType = {
    id: number
    image: number
    name: number
    date: number
    volume: number
    pdf: number
    _all: number
  }


  export type ShippersNewsAvgAggregateInputType = {
    id?: true
    volume?: true
  }

  export type ShippersNewsSumAggregateInputType = {
    id?: true
    volume?: true
  }

  export type ShippersNewsMinAggregateInputType = {
    id?: true
    image?: true
    name?: true
    date?: true
    volume?: true
    pdf?: true
  }

  export type ShippersNewsMaxAggregateInputType = {
    id?: true
    image?: true
    name?: true
    date?: true
    volume?: true
    pdf?: true
  }

  export type ShippersNewsCountAggregateInputType = {
    id?: true
    image?: true
    name?: true
    date?: true
    volume?: true
    pdf?: true
    _all?: true
  }

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

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




  export type ShippersNewsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ShippersNewsWhereInput
    orderBy?: ShippersNewsOrderByWithAggregationInput | ShippersNewsOrderByWithAggregationInput[]
    by: ShippersNewsScalarFieldEnum[] | ShippersNewsScalarFieldEnum
    having?: ShippersNewsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ShippersNewsCountAggregateInputType | true
    _avg?: ShippersNewsAvgAggregateInputType
    _sum?: ShippersNewsSumAggregateInputType
    _min?: ShippersNewsMinAggregateInputType
    _max?: ShippersNewsMaxAggregateInputType
  }

  export type ShippersNewsGroupByOutputType = {
    id: number
    image: string | null
    name: string
    date: string
    volume: number
    pdf: string
    _count: ShippersNewsCountAggregateOutputType | null
    _avg: ShippersNewsAvgAggregateOutputType | null
    _sum: ShippersNewsSumAggregateOutputType | null
    _min: ShippersNewsMinAggregateOutputType | null
    _max: ShippersNewsMaxAggregateOutputType | null
  }

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


  export type ShippersNewsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    image?: boolean
    name?: boolean
    date?: boolean
    volume?: boolean
    pdf?: boolean
  }, ExtArgs["result"]["shippersNews"]>

  export type ShippersNewsSelectScalar = {
    id?: boolean
    image?: boolean
    name?: boolean
    date?: boolean
    volume?: boolean
    pdf?: boolean
  }


  export type $ShippersNewsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ShippersNews"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      image: string | null
      name: string
      date: string
      volume: number
      pdf: string
    }, ExtArgs["result"]["shippersNews"]>
    composites: {}
  }


  type ShippersNewsGetPayload<S extends boolean | null | undefined | ShippersNewsDefaultArgs> = $Result.GetResult<Prisma.$ShippersNewsPayload, S>

  type ShippersNewsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ShippersNewsFindManyArgs, 'select' | 'include'> & {
      select?: ShippersNewsCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a ShippersNews.
     * @param {ShippersNewsCreateArgs} args - Arguments to create a ShippersNews.
     * @example
     * // Create one ShippersNews
     * const ShippersNews = await prisma.shippersNews.create({
     *   data: {
     *     // ... data to create a ShippersNews
     *   }
     * })
     * 
    **/
    create<T extends ShippersNewsCreateArgs<ExtArgs>>(
      args: SelectSubset<T, ShippersNewsCreateArgs<ExtArgs>>
    ): Prisma__ShippersNewsClient<$Result.GetResult<Prisma.$ShippersNewsPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a ShippersNews.
     * @param {ShippersNewsDeleteArgs} args - Arguments to delete one ShippersNews.
     * @example
     * // Delete one ShippersNews
     * const ShippersNews = await prisma.shippersNews.delete({
     *   where: {
     *     // ... filter to delete one ShippersNews
     *   }
     * })
     * 
    **/
    delete<T extends ShippersNewsDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, ShippersNewsDeleteArgs<ExtArgs>>
    ): Prisma__ShippersNewsClient<$Result.GetResult<Prisma.$ShippersNewsPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for ShippersNews.
   * 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__ShippersNewsClient<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 ShippersNews model
   */ 
  interface ShippersNewsFieldRefs {
    readonly id: FieldRef<"ShippersNews", 'Int'>
    readonly image: FieldRef<"ShippersNews", 'String'>
    readonly name: FieldRef<"ShippersNews", 'String'>
    readonly date: FieldRef<"ShippersNews", 'String'>
    readonly volume: FieldRef<"ShippersNews", 'Int'>
    readonly pdf: FieldRef<"ShippersNews", 'String'>
  }
    

  // Custom InputTypes

  /**
   * ShippersNews findUnique
   */
  export type ShippersNewsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ShippersNews
     */
    select?: ShippersNewsSelect<ExtArgs> | null
    /**
     * Filter, which ShippersNews to fetch.
     */
    where: ShippersNewsWhereUniqueInput
  }


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


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


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


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


  /**
   * ShippersNews create
   */
  export type ShippersNewsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ShippersNews
     */
    select?: ShippersNewsSelect<ExtArgs> | null
    /**
     * The data needed to create a ShippersNews.
     */
    data: XOR<ShippersNewsCreateInput, ShippersNewsUncheckedCreateInput>
  }


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


  /**
   * ShippersNews update
   */
  export type ShippersNewsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ShippersNews
     */
    select?: ShippersNewsSelect<ExtArgs> | null
    /**
     * The data needed to update a ShippersNews.
     */
    data: XOR<ShippersNewsUpdateInput, ShippersNewsUncheckedUpdateInput>
    /**
     * Choose, which ShippersNews to update.
     */
    where: ShippersNewsWhereUniqueInput
  }


  /**
   * ShippersNews updateMany
   */
  export type ShippersNewsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ShippersNews.
     */
    data: XOR<ShippersNewsUpdateManyMutationInput, ShippersNewsUncheckedUpdateManyInput>
    /**
     * Filter which ShippersNews to update
     */
    where?: ShippersNewsWhereInput
  }


  /**
   * ShippersNews upsert
   */
  export type ShippersNewsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ShippersNews
     */
    select?: ShippersNewsSelect<ExtArgs> | null
    /**
     * The filter to search for the ShippersNews to update in case it exists.
     */
    where: ShippersNewsWhereUniqueInput
    /**
     * In case the ShippersNews found by the `where` argument doesn't exist, create a new ShippersNews with this data.
     */
    create: XOR<ShippersNewsCreateInput, ShippersNewsUncheckedCreateInput>
    /**
     * In case the ShippersNews was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ShippersNewsUpdateInput, ShippersNewsUncheckedUpdateInput>
  }


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


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


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



  /**
   * Model AnnualReport
   */

  export type AggregateAnnualReport = {
    _count: AnnualReportCountAggregateOutputType | null
    _avg: AnnualReportAvgAggregateOutputType | null
    _sum: AnnualReportSumAggregateOutputType | null
    _min: AnnualReportMinAggregateOutputType | null
    _max: AnnualReportMaxAggregateOutputType | null
  }

  export type AnnualReportAvgAggregateOutputType = {
    id: number | null
  }

  export type AnnualReportSumAggregateOutputType = {
    id: number | null
  }

  export type AnnualReportMinAggregateOutputType = {
    id: number | null
    image: string | null
    name: string | null
    date: string | null
    pdf: string | null
  }

  export type AnnualReportMaxAggregateOutputType = {
    id: number | null
    image: string | null
    name: string | null
    date: string | null
    pdf: string | null
  }

  export type AnnualReportCountAggregateOutputType = {
    id: number
    image: number
    name: number
    date: number
    pdf: number
    _all: number
  }


  export type AnnualReportAvgAggregateInputType = {
    id?: true
  }

  export type AnnualReportSumAggregateInputType = {
    id?: true
  }

  export type AnnualReportMinAggregateInputType = {
    id?: true
    image?: true
    name?: true
    date?: true
    pdf?: true
  }

  export type AnnualReportMaxAggregateInputType = {
    id?: true
    image?: true
    name?: true
    date?: true
    pdf?: true
  }

  export type AnnualReportCountAggregateInputType = {
    id?: true
    image?: true
    name?: true
    date?: true
    pdf?: true
    _all?: true
  }

  export type AnnualReportAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which AnnualReport to aggregate.
     */
    where?: AnnualReportWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of AnnualReports to fetch.
     */
    orderBy?: AnnualReportOrderByWithRelationInput | AnnualReportOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: AnnualReportWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` AnnualReports from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` AnnualReports.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned AnnualReports
    **/
    _count?: true | AnnualReportCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: AnnualReportAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: AnnualReportSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: AnnualReportMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: AnnualReportMaxAggregateInputType
  }

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




  export type AnnualReportGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AnnualReportWhereInput
    orderBy?: AnnualReportOrderByWithAggregationInput | AnnualReportOrderByWithAggregationInput[]
    by: AnnualReportScalarFieldEnum[] | AnnualReportScalarFieldEnum
    having?: AnnualReportScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AnnualReportCountAggregateInputType | true
    _avg?: AnnualReportAvgAggregateInputType
    _sum?: AnnualReportSumAggregateInputType
    _min?: AnnualReportMinAggregateInputType
    _max?: AnnualReportMaxAggregateInputType
  }

  export type AnnualReportGroupByOutputType = {
    id: number
    image: string | null
    name: string
    date: string
    pdf: string
    _count: AnnualReportCountAggregateOutputType | null
    _avg: AnnualReportAvgAggregateOutputType | null
    _sum: AnnualReportSumAggregateOutputType | null
    _min: AnnualReportMinAggregateOutputType | null
    _max: AnnualReportMaxAggregateOutputType | null
  }

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


  export type AnnualReportSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    image?: boolean
    name?: boolean
    date?: boolean
    pdf?: boolean
  }, ExtArgs["result"]["annualReport"]>

  export type AnnualReportSelectScalar = {
    id?: boolean
    image?: boolean
    name?: boolean
    date?: boolean
    pdf?: boolean
  }


  export type $AnnualReportPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "AnnualReport"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      image: string | null
      name: string
      date: string
      pdf: string
    }, ExtArgs["result"]["annualReport"]>
    composites: {}
  }


  type AnnualReportGetPayload<S extends boolean | null | undefined | AnnualReportDefaultArgs> = $Result.GetResult<Prisma.$AnnualReportPayload, S>

  type AnnualReportCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<AnnualReportFindManyArgs, 'select' | 'include'> & {
      select?: AnnualReportCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a AnnualReport.
     * @param {AnnualReportCreateArgs} args - Arguments to create a AnnualReport.
     * @example
     * // Create one AnnualReport
     * const AnnualReport = await prisma.annualReport.create({
     *   data: {
     *     // ... data to create a AnnualReport
     *   }
     * })
     * 
    **/
    create<T extends AnnualReportCreateArgs<ExtArgs>>(
      args: SelectSubset<T, AnnualReportCreateArgs<ExtArgs>>
    ): Prisma__AnnualReportClient<$Result.GetResult<Prisma.$AnnualReportPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a AnnualReport.
     * @param {AnnualReportDeleteArgs} args - Arguments to delete one AnnualReport.
     * @example
     * // Delete one AnnualReport
     * const AnnualReport = await prisma.annualReport.delete({
     *   where: {
     *     // ... filter to delete one AnnualReport
     *   }
     * })
     * 
    **/
    delete<T extends AnnualReportDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, AnnualReportDeleteArgs<ExtArgs>>
    ): Prisma__AnnualReportClient<$Result.GetResult<Prisma.$AnnualReportPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for AnnualReport.
   * 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__AnnualReportClient<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 AnnualReport model
   */ 
  interface AnnualReportFieldRefs {
    readonly id: FieldRef<"AnnualReport", 'Int'>
    readonly image: FieldRef<"AnnualReport", 'String'>
    readonly name: FieldRef<"AnnualReport", 'String'>
    readonly date: FieldRef<"AnnualReport", 'String'>
    readonly pdf: FieldRef<"AnnualReport", 'String'>
  }
    

  // Custom InputTypes

  /**
   * AnnualReport findUnique
   */
  export type AnnualReportFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AnnualReport
     */
    select?: AnnualReportSelect<ExtArgs> | null
    /**
     * Filter, which AnnualReport to fetch.
     */
    where: AnnualReportWhereUniqueInput
  }


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


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


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


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


  /**
   * AnnualReport create
   */
  export type AnnualReportCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AnnualReport
     */
    select?: AnnualReportSelect<ExtArgs> | null
    /**
     * The data needed to create a AnnualReport.
     */
    data: XOR<AnnualReportCreateInput, AnnualReportUncheckedCreateInput>
  }


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


  /**
   * AnnualReport update
   */
  export type AnnualReportUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AnnualReport
     */
    select?: AnnualReportSelect<ExtArgs> | null
    /**
     * The data needed to update a AnnualReport.
     */
    data: XOR<AnnualReportUpdateInput, AnnualReportUncheckedUpdateInput>
    /**
     * Choose, which AnnualReport to update.
     */
    where: AnnualReportWhereUniqueInput
  }


  /**
   * AnnualReport updateMany
   */
  export type AnnualReportUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update AnnualReports.
     */
    data: XOR<AnnualReportUpdateManyMutationInput, AnnualReportUncheckedUpdateManyInput>
    /**
     * Filter which AnnualReports to update
     */
    where?: AnnualReportWhereInput
  }


  /**
   * AnnualReport upsert
   */
  export type AnnualReportUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AnnualReport
     */
    select?: AnnualReportSelect<ExtArgs> | null
    /**
     * The filter to search for the AnnualReport to update in case it exists.
     */
    where: AnnualReportWhereUniqueInput
    /**
     * In case the AnnualReport found by the `where` argument doesn't exist, create a new AnnualReport with this data.
     */
    create: XOR<AnnualReportCreateInput, AnnualReportUncheckedCreateInput>
    /**
     * In case the AnnualReport was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AnnualReportUpdateInput, AnnualReportUncheckedUpdateInput>
  }


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


  /**
   * AnnualReport deleteMany
   */
  export type AnnualReportDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which AnnualReports to delete
     */
    where?: AnnualReportWhereInput
  }


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



  /**
   * Model OtherPublications
   */

  export type AggregateOtherPublications = {
    _count: OtherPublicationsCountAggregateOutputType | null
    _avg: OtherPublicationsAvgAggregateOutputType | null
    _sum: OtherPublicationsSumAggregateOutputType | null
    _min: OtherPublicationsMinAggregateOutputType | null
    _max: OtherPublicationsMaxAggregateOutputType | null
  }

  export type OtherPublicationsAvgAggregateOutputType = {
    id: number | null
  }

  export type OtherPublicationsSumAggregateOutputType = {
    id: number | null
  }

  export type OtherPublicationsMinAggregateOutputType = {
    id: number | null
    image: string | null
    name: string | null
    date: string | null
    pdf: string | null
  }

  export type OtherPublicationsMaxAggregateOutputType = {
    id: number | null
    image: string | null
    name: string | null
    date: string | null
    pdf: string | null
  }

  export type OtherPublicationsCountAggregateOutputType = {
    id: number
    image: number
    name: number
    date: number
    pdf: number
    _all: number
  }


  export type OtherPublicationsAvgAggregateInputType = {
    id?: true
  }

  export type OtherPublicationsSumAggregateInputType = {
    id?: true
  }

  export type OtherPublicationsMinAggregateInputType = {
    id?: true
    image?: true
    name?: true
    date?: true
    pdf?: true
  }

  export type OtherPublicationsMaxAggregateInputType = {
    id?: true
    image?: true
    name?: true
    date?: true
    pdf?: true
  }

  export type OtherPublicationsCountAggregateInputType = {
    id?: true
    image?: true
    name?: true
    date?: true
    pdf?: true
    _all?: true
  }

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

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




  export type OtherPublicationsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: OtherPublicationsWhereInput
    orderBy?: OtherPublicationsOrderByWithAggregationInput | OtherPublicationsOrderByWithAggregationInput[]
    by: OtherPublicationsScalarFieldEnum[] | OtherPublicationsScalarFieldEnum
    having?: OtherPublicationsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: OtherPublicationsCountAggregateInputType | true
    _avg?: OtherPublicationsAvgAggregateInputType
    _sum?: OtherPublicationsSumAggregateInputType
    _min?: OtherPublicationsMinAggregateInputType
    _max?: OtherPublicationsMaxAggregateInputType
  }

  export type OtherPublicationsGroupByOutputType = {
    id: number
    image: string | null
    name: string
    date: string
    pdf: string
    _count: OtherPublicationsCountAggregateOutputType | null
    _avg: OtherPublicationsAvgAggregateOutputType | null
    _sum: OtherPublicationsSumAggregateOutputType | null
    _min: OtherPublicationsMinAggregateOutputType | null
    _max: OtherPublicationsMaxAggregateOutputType | null
  }

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


  export type OtherPublicationsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    image?: boolean
    name?: boolean
    date?: boolean
    pdf?: boolean
  }, ExtArgs["result"]["otherPublications"]>

  export type OtherPublicationsSelectScalar = {
    id?: boolean
    image?: boolean
    name?: boolean
    date?: boolean
    pdf?: boolean
  }


  export type $OtherPublicationsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "OtherPublications"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      image: string | null
      name: string
      date: string
      pdf: string
    }, ExtArgs["result"]["otherPublications"]>
    composites: {}
  }


  type OtherPublicationsGetPayload<S extends boolean | null | undefined | OtherPublicationsDefaultArgs> = $Result.GetResult<Prisma.$OtherPublicationsPayload, S>

  type OtherPublicationsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<OtherPublicationsFindManyArgs, 'select' | 'include'> & {
      select?: OtherPublicationsCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a OtherPublications.
     * @param {OtherPublicationsCreateArgs} args - Arguments to create a OtherPublications.
     * @example
     * // Create one OtherPublications
     * const OtherPublications = await prisma.otherPublications.create({
     *   data: {
     *     // ... data to create a OtherPublications
     *   }
     * })
     * 
    **/
    create<T extends OtherPublicationsCreateArgs<ExtArgs>>(
      args: SelectSubset<T, OtherPublicationsCreateArgs<ExtArgs>>
    ): Prisma__OtherPublicationsClient<$Result.GetResult<Prisma.$OtherPublicationsPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a OtherPublications.
     * @param {OtherPublicationsDeleteArgs} args - Arguments to delete one OtherPublications.
     * @example
     * // Delete one OtherPublications
     * const OtherPublications = await prisma.otherPublications.delete({
     *   where: {
     *     // ... filter to delete one OtherPublications
     *   }
     * })
     * 
    **/
    delete<T extends OtherPublicationsDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, OtherPublicationsDeleteArgs<ExtArgs>>
    ): Prisma__OtherPublicationsClient<$Result.GetResult<Prisma.$OtherPublicationsPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for OtherPublications.
   * 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__OtherPublicationsClient<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 OtherPublications model
   */ 
  interface OtherPublicationsFieldRefs {
    readonly id: FieldRef<"OtherPublications", 'Int'>
    readonly image: FieldRef<"OtherPublications", 'String'>
    readonly name: FieldRef<"OtherPublications", 'String'>
    readonly date: FieldRef<"OtherPublications", 'String'>
    readonly pdf: FieldRef<"OtherPublications", 'String'>
  }
    

  // Custom InputTypes

  /**
   * OtherPublications findUnique
   */
  export type OtherPublicationsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OtherPublications
     */
    select?: OtherPublicationsSelect<ExtArgs> | null
    /**
     * Filter, which OtherPublications to fetch.
     */
    where: OtherPublicationsWhereUniqueInput
  }


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


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


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


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


  /**
   * OtherPublications create
   */
  export type OtherPublicationsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OtherPublications
     */
    select?: OtherPublicationsSelect<ExtArgs> | null
    /**
     * The data needed to create a OtherPublications.
     */
    data: XOR<OtherPublicationsCreateInput, OtherPublicationsUncheckedCreateInput>
  }


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


  /**
   * OtherPublications update
   */
  export type OtherPublicationsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OtherPublications
     */
    select?: OtherPublicationsSelect<ExtArgs> | null
    /**
     * The data needed to update a OtherPublications.
     */
    data: XOR<OtherPublicationsUpdateInput, OtherPublicationsUncheckedUpdateInput>
    /**
     * Choose, which OtherPublications to update.
     */
    where: OtherPublicationsWhereUniqueInput
  }


  /**
   * OtherPublications updateMany
   */
  export type OtherPublicationsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update OtherPublications.
     */
    data: XOR<OtherPublicationsUpdateManyMutationInput, OtherPublicationsUncheckedUpdateManyInput>
    /**
     * Filter which OtherPublications to update
     */
    where?: OtherPublicationsWhereInput
  }


  /**
   * OtherPublications upsert
   */
  export type OtherPublicationsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OtherPublications
     */
    select?: OtherPublicationsSelect<ExtArgs> | null
    /**
     * The filter to search for the OtherPublications to update in case it exists.
     */
    where: OtherPublicationsWhereUniqueInput
    /**
     * In case the OtherPublications found by the `where` argument doesn't exist, create a new OtherPublications with this data.
     */
    create: XOR<OtherPublicationsCreateInput, OtherPublicationsUncheckedCreateInput>
    /**
     * In case the OtherPublications was found with the provided `where` argument, update it with this data.
     */
    update: XOR<OtherPublicationsUpdateInput, OtherPublicationsUncheckedUpdateInput>
  }


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


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


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



  /**
   * Model SCBRecommendations
   */

  export type AggregateSCBRecommendations = {
    _count: SCBRecommendationsCountAggregateOutputType | null
    _avg: SCBRecommendationsAvgAggregateOutputType | null
    _sum: SCBRecommendationsSumAggregateOutputType | null
    _min: SCBRecommendationsMinAggregateOutputType | null
    _max: SCBRecommendationsMaxAggregateOutputType | null
  }

  export type SCBRecommendationsAvgAggregateOutputType = {
    id: number | null
  }

  export type SCBRecommendationsSumAggregateOutputType = {
    id: number | null
  }

  export type SCBRecommendationsMinAggregateOutputType = {
    id: number | null
    type: string | null
    name: string | null
    date: string | null
    pdf: string | null
  }

  export type SCBRecommendationsMaxAggregateOutputType = {
    id: number | null
    type: string | null
    name: string | null
    date: string | null
    pdf: string | null
  }

  export type SCBRecommendationsCountAggregateOutputType = {
    id: number
    type: number
    name: number
    date: number
    pdf: number
    _all: number
  }


  export type SCBRecommendationsAvgAggregateInputType = {
    id?: true
  }

  export type SCBRecommendationsSumAggregateInputType = {
    id?: true
  }

  export type SCBRecommendationsMinAggregateInputType = {
    id?: true
    type?: true
    name?: true
    date?: true
    pdf?: true
  }

  export type SCBRecommendationsMaxAggregateInputType = {
    id?: true
    type?: true
    name?: true
    date?: true
    pdf?: true
  }

  export type SCBRecommendationsCountAggregateInputType = {
    id?: true
    type?: true
    name?: true
    date?: true
    pdf?: true
    _all?: true
  }

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

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




  export type SCBRecommendationsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SCBRecommendationsWhereInput
    orderBy?: SCBRecommendationsOrderByWithAggregationInput | SCBRecommendationsOrderByWithAggregationInput[]
    by: SCBRecommendationsScalarFieldEnum[] | SCBRecommendationsScalarFieldEnum
    having?: SCBRecommendationsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: SCBRecommendationsCountAggregateInputType | true
    _avg?: SCBRecommendationsAvgAggregateInputType
    _sum?: SCBRecommendationsSumAggregateInputType
    _min?: SCBRecommendationsMinAggregateInputType
    _max?: SCBRecommendationsMaxAggregateInputType
  }

  export type SCBRecommendationsGroupByOutputType = {
    id: number
    type: string
    name: string
    date: string
    pdf: string
    _count: SCBRecommendationsCountAggregateOutputType | null
    _avg: SCBRecommendationsAvgAggregateOutputType | null
    _sum: SCBRecommendationsSumAggregateOutputType | null
    _min: SCBRecommendationsMinAggregateOutputType | null
    _max: SCBRecommendationsMaxAggregateOutputType | null
  }

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


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

  export type SCBRecommendationsSelectScalar = {
    id?: boolean
    type?: boolean
    name?: boolean
    date?: boolean
    pdf?: boolean
  }


  export type $SCBRecommendationsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "SCBRecommendations"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      type: string
      name: string
      date: string
      pdf: string
    }, ExtArgs["result"]["sCBRecommendations"]>
    composites: {}
  }


  type SCBRecommendationsGetPayload<S extends boolean | null | undefined | SCBRecommendationsDefaultArgs> = $Result.GetResult<Prisma.$SCBRecommendationsPayload, S>

  type SCBRecommendationsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<SCBRecommendationsFindManyArgs, 'select' | 'include'> & {
      select?: SCBRecommendationsCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a SCBRecommendations.
     * @param {SCBRecommendationsCreateArgs} args - Arguments to create a SCBRecommendations.
     * @example
     * // Create one SCBRecommendations
     * const SCBRecommendations = await prisma.sCBRecommendations.create({
     *   data: {
     *     // ... data to create a SCBRecommendations
     *   }
     * })
     * 
    **/
    create<T extends SCBRecommendationsCreateArgs<ExtArgs>>(
      args: SelectSubset<T, SCBRecommendationsCreateArgs<ExtArgs>>
    ): Prisma__SCBRecommendationsClient<$Result.GetResult<Prisma.$SCBRecommendationsPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a SCBRecommendations.
     * @param {SCBRecommendationsDeleteArgs} args - Arguments to delete one SCBRecommendations.
     * @example
     * // Delete one SCBRecommendations
     * const SCBRecommendations = await prisma.sCBRecommendations.delete({
     *   where: {
     *     // ... filter to delete one SCBRecommendations
     *   }
     * })
     * 
    **/
    delete<T extends SCBRecommendationsDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, SCBRecommendationsDeleteArgs<ExtArgs>>
    ): Prisma__SCBRecommendationsClient<$Result.GetResult<Prisma.$SCBRecommendationsPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for SCBRecommendations.
   * 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__SCBRecommendationsClient<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 SCBRecommendations model
   */ 
  interface SCBRecommendationsFieldRefs {
    readonly id: FieldRef<"SCBRecommendations", 'Int'>
    readonly type: FieldRef<"SCBRecommendations", 'String'>
    readonly name: FieldRef<"SCBRecommendations", 'String'>
    readonly date: FieldRef<"SCBRecommendations", 'String'>
    readonly pdf: FieldRef<"SCBRecommendations", 'String'>
  }
    

  // Custom InputTypes

  /**
   * SCBRecommendations findUnique
   */
  export type SCBRecommendationsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SCBRecommendations
     */
    select?: SCBRecommendationsSelect<ExtArgs> | null
    /**
     * Filter, which SCBRecommendations to fetch.
     */
    where: SCBRecommendationsWhereUniqueInput
  }


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


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


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


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


  /**
   * SCBRecommendations create
   */
  export type SCBRecommendationsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SCBRecommendations
     */
    select?: SCBRecommendationsSelect<ExtArgs> | null
    /**
     * The data needed to create a SCBRecommendations.
     */
    data: XOR<SCBRecommendationsCreateInput, SCBRecommendationsUncheckedCreateInput>
  }


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


  /**
   * SCBRecommendations update
   */
  export type SCBRecommendationsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SCBRecommendations
     */
    select?: SCBRecommendationsSelect<ExtArgs> | null
    /**
     * The data needed to update a SCBRecommendations.
     */
    data: XOR<SCBRecommendationsUpdateInput, SCBRecommendationsUncheckedUpdateInput>
    /**
     * Choose, which SCBRecommendations to update.
     */
    where: SCBRecommendationsWhereUniqueInput
  }


  /**
   * SCBRecommendations updateMany
   */
  export type SCBRecommendationsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update SCBRecommendations.
     */
    data: XOR<SCBRecommendationsUpdateManyMutationInput, SCBRecommendationsUncheckedUpdateManyInput>
    /**
     * Filter which SCBRecommendations to update
     */
    where?: SCBRecommendationsWhereInput
  }


  /**
   * SCBRecommendations upsert
   */
  export type SCBRecommendationsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SCBRecommendations
     */
    select?: SCBRecommendationsSelect<ExtArgs> | null
    /**
     * The filter to search for the SCBRecommendations to update in case it exists.
     */
    where: SCBRecommendationsWhereUniqueInput
    /**
     * In case the SCBRecommendations found by the `where` argument doesn't exist, create a new SCBRecommendations with this data.
     */
    create: XOR<SCBRecommendationsCreateInput, SCBRecommendationsUncheckedCreateInput>
    /**
     * In case the SCBRecommendations was found with the provided `where` argument, update it with this data.
     */
    update: XOR<SCBRecommendationsUpdateInput, SCBRecommendationsUncheckedUpdateInput>
  }


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


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


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



  /**
   * Model SCBSeminar
   */

  export type AggregateSCBSeminar = {
    _count: SCBSeminarCountAggregateOutputType | null
    _avg: SCBSeminarAvgAggregateOutputType | null
    _sum: SCBSeminarSumAggregateOutputType | null
    _min: SCBSeminarMinAggregateOutputType | null
    _max: SCBSeminarMaxAggregateOutputType | null
  }

  export type SCBSeminarAvgAggregateOutputType = {
    id: number | null
  }

  export type SCBSeminarSumAggregateOutputType = {
    id: number | null
  }

  export type SCBSeminarMinAggregateOutputType = {
    id: number | null
    type: string | null
    name: string | null
    date: string | null
    pdf: string | null
  }

  export type SCBSeminarMaxAggregateOutputType = {
    id: number | null
    type: string | null
    name: string | null
    date: string | null
    pdf: string | null
  }

  export type SCBSeminarCountAggregateOutputType = {
    id: number
    type: number
    name: number
    date: number
    pdf: number
    _all: number
  }


  export type SCBSeminarAvgAggregateInputType = {
    id?: true
  }

  export type SCBSeminarSumAggregateInputType = {
    id?: true
  }

  export type SCBSeminarMinAggregateInputType = {
    id?: true
    type?: true
    name?: true
    date?: true
    pdf?: true
  }

  export type SCBSeminarMaxAggregateInputType = {
    id?: true
    type?: true
    name?: true
    date?: true
    pdf?: true
  }

  export type SCBSeminarCountAggregateInputType = {
    id?: true
    type?: true
    name?: true
    date?: true
    pdf?: true
    _all?: true
  }

  export type SCBSeminarAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which SCBSeminar to aggregate.
     */
    where?: SCBSeminarWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SCBSeminars to fetch.
     */
    orderBy?: SCBSeminarOrderByWithRelationInput | SCBSeminarOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: SCBSeminarWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SCBSeminars from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` SCBSeminars.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned SCBSeminars
    **/
    _count?: true | SCBSeminarCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: SCBSeminarAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: SCBSeminarSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: SCBSeminarMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: SCBSeminarMaxAggregateInputType
  }

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




  export type SCBSeminarGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SCBSeminarWhereInput
    orderBy?: SCBSeminarOrderByWithAggregationInput | SCBSeminarOrderByWithAggregationInput[]
    by: SCBSeminarScalarFieldEnum[] | SCBSeminarScalarFieldEnum
    having?: SCBSeminarScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: SCBSeminarCountAggregateInputType | true
    _avg?: SCBSeminarAvgAggregateInputType
    _sum?: SCBSeminarSumAggregateInputType
    _min?: SCBSeminarMinAggregateInputType
    _max?: SCBSeminarMaxAggregateInputType
  }

  export type SCBSeminarGroupByOutputType = {
    id: number
    type: string
    name: string
    date: string
    pdf: string
    _count: SCBSeminarCountAggregateOutputType | null
    _avg: SCBSeminarAvgAggregateOutputType | null
    _sum: SCBSeminarSumAggregateOutputType | null
    _min: SCBSeminarMinAggregateOutputType | null
    _max: SCBSeminarMaxAggregateOutputType | null
  }

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


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

  export type SCBSeminarSelectScalar = {
    id?: boolean
    type?: boolean
    name?: boolean
    date?: boolean
    pdf?: boolean
  }


  export type $SCBSeminarPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "SCBSeminar"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      type: string
      name: string
      date: string
      pdf: string
    }, ExtArgs["result"]["sCBSeminar"]>
    composites: {}
  }


  type SCBSeminarGetPayload<S extends boolean | null | undefined | SCBSeminarDefaultArgs> = $Result.GetResult<Prisma.$SCBSeminarPayload, S>

  type SCBSeminarCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<SCBSeminarFindManyArgs, 'select' | 'include'> & {
      select?: SCBSeminarCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a SCBSeminar.
     * @param {SCBSeminarCreateArgs} args - Arguments to create a SCBSeminar.
     * @example
     * // Create one SCBSeminar
     * const SCBSeminar = await prisma.sCBSeminar.create({
     *   data: {
     *     // ... data to create a SCBSeminar
     *   }
     * })
     * 
    **/
    create<T extends SCBSeminarCreateArgs<ExtArgs>>(
      args: SelectSubset<T, SCBSeminarCreateArgs<ExtArgs>>
    ): Prisma__SCBSeminarClient<$Result.GetResult<Prisma.$SCBSeminarPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a SCBSeminar.
     * @param {SCBSeminarDeleteArgs} args - Arguments to delete one SCBSeminar.
     * @example
     * // Delete one SCBSeminar
     * const SCBSeminar = await prisma.sCBSeminar.delete({
     *   where: {
     *     // ... filter to delete one SCBSeminar
     *   }
     * })
     * 
    **/
    delete<T extends SCBSeminarDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, SCBSeminarDeleteArgs<ExtArgs>>
    ): Prisma__SCBSeminarClient<$Result.GetResult<Prisma.$SCBSeminarPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for SCBSeminar.
   * 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__SCBSeminarClient<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 SCBSeminar model
   */ 
  interface SCBSeminarFieldRefs {
    readonly id: FieldRef<"SCBSeminar", 'Int'>
    readonly type: FieldRef<"SCBSeminar", 'String'>
    readonly name: FieldRef<"SCBSeminar", 'String'>
    readonly date: FieldRef<"SCBSeminar", 'String'>
    readonly pdf: FieldRef<"SCBSeminar", 'String'>
  }
    

  // Custom InputTypes

  /**
   * SCBSeminar findUnique
   */
  export type SCBSeminarFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SCBSeminar
     */
    select?: SCBSeminarSelect<ExtArgs> | null
    /**
     * Filter, which SCBSeminar to fetch.
     */
    where: SCBSeminarWhereUniqueInput
  }


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


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


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


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


  /**
   * SCBSeminar create
   */
  export type SCBSeminarCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SCBSeminar
     */
    select?: SCBSeminarSelect<ExtArgs> | null
    /**
     * The data needed to create a SCBSeminar.
     */
    data: XOR<SCBSeminarCreateInput, SCBSeminarUncheckedCreateInput>
  }


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


  /**
   * SCBSeminar update
   */
  export type SCBSeminarUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SCBSeminar
     */
    select?: SCBSeminarSelect<ExtArgs> | null
    /**
     * The data needed to update a SCBSeminar.
     */
    data: XOR<SCBSeminarUpdateInput, SCBSeminarUncheckedUpdateInput>
    /**
     * Choose, which SCBSeminar to update.
     */
    where: SCBSeminarWhereUniqueInput
  }


  /**
   * SCBSeminar updateMany
   */
  export type SCBSeminarUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update SCBSeminars.
     */
    data: XOR<SCBSeminarUpdateManyMutationInput, SCBSeminarUncheckedUpdateManyInput>
    /**
     * Filter which SCBSeminars to update
     */
    where?: SCBSeminarWhereInput
  }


  /**
   * SCBSeminar upsert
   */
  export type SCBSeminarUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SCBSeminar
     */
    select?: SCBSeminarSelect<ExtArgs> | null
    /**
     * The filter to search for the SCBSeminar to update in case it exists.
     */
    where: SCBSeminarWhereUniqueInput
    /**
     * In case the SCBSeminar found by the `where` argument doesn't exist, create a new SCBSeminar with this data.
     */
    create: XOR<SCBSeminarCreateInput, SCBSeminarUncheckedCreateInput>
    /**
     * In case the SCBSeminar was found with the provided `where` argument, update it with this data.
     */
    update: XOR<SCBSeminarUpdateInput, SCBSeminarUncheckedUpdateInput>
  }


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


  /**
   * SCBSeminar deleteMany
   */
  export type SCBSeminarDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which SCBSeminars to delete
     */
    where?: SCBSeminarWhereInput
  }


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



  /**
   * Model Eligibility
   */

  export type AggregateEligibility = {
    _count: EligibilityCountAggregateOutputType | null
    _avg: EligibilityAvgAggregateOutputType | null
    _sum: EligibilitySumAggregateOutputType | null
    _min: EligibilityMinAggregateOutputType | null
    _max: EligibilityMaxAggregateOutputType | null
  }

  export type EligibilityAvgAggregateOutputType = {
    id: number | null
    admission: number | null
    subscription: number | null
  }

  export type EligibilitySumAggregateOutputType = {
    id: number | null
    admission: number | null
    subscription: number | null
  }

  export type EligibilityMinAggregateOutputType = {
    id: number | null
    type: string | null
    text: string | null
    admission: number | null
    subscription: number | null
  }

  export type EligibilityMaxAggregateOutputType = {
    id: number | null
    type: string | null
    text: string | null
    admission: number | null
    subscription: number | null
  }

  export type EligibilityCountAggregateOutputType = {
    id: number
    type: number
    text: number
    admission: number
    subscription: number
    _all: number
  }


  export type EligibilityAvgAggregateInputType = {
    id?: true
    admission?: true
    subscription?: true
  }

  export type EligibilitySumAggregateInputType = {
    id?: true
    admission?: true
    subscription?: true
  }

  export type EligibilityMinAggregateInputType = {
    id?: true
    type?: true
    text?: true
    admission?: true
    subscription?: true
  }

  export type EligibilityMaxAggregateInputType = {
    id?: true
    type?: true
    text?: true
    admission?: true
    subscription?: true
  }

  export type EligibilityCountAggregateInputType = {
    id?: true
    type?: true
    text?: true
    admission?: true
    subscription?: true
    _all?: true
  }

  export type EligibilityAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Eligibility to aggregate.
     */
    where?: EligibilityWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Eligibilities to fetch.
     */
    orderBy?: EligibilityOrderByWithRelationInput | EligibilityOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: EligibilityWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Eligibilities from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Eligibilities.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Eligibilities
    **/
    _count?: true | EligibilityCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: EligibilityAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: EligibilitySumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: EligibilityMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: EligibilityMaxAggregateInputType
  }

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




  export type EligibilityGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: EligibilityWhereInput
    orderBy?: EligibilityOrderByWithAggregationInput | EligibilityOrderByWithAggregationInput[]
    by: EligibilityScalarFieldEnum[] | EligibilityScalarFieldEnum
    having?: EligibilityScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: EligibilityCountAggregateInputType | true
    _avg?: EligibilityAvgAggregateInputType
    _sum?: EligibilitySumAggregateInputType
    _min?: EligibilityMinAggregateInputType
    _max?: EligibilityMaxAggregateInputType
  }

  export type EligibilityGroupByOutputType = {
    id: number
    type: string
    text: string
    admission: number
    subscription: number
    _count: EligibilityCountAggregateOutputType | null
    _avg: EligibilityAvgAggregateOutputType | null
    _sum: EligibilitySumAggregateOutputType | null
    _min: EligibilityMinAggregateOutputType | null
    _max: EligibilityMaxAggregateOutputType | null
  }

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


  export type EligibilitySelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    type?: boolean
    text?: boolean
    admission?: boolean
    subscription?: boolean
  }, ExtArgs["result"]["eligibility"]>

  export type EligibilitySelectScalar = {
    id?: boolean
    type?: boolean
    text?: boolean
    admission?: boolean
    subscription?: boolean
  }


  export type $EligibilityPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Eligibility"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      type: string
      text: string
      admission: number
      subscription: number
    }, ExtArgs["result"]["eligibility"]>
    composites: {}
  }


  type EligibilityGetPayload<S extends boolean | null | undefined | EligibilityDefaultArgs> = $Result.GetResult<Prisma.$EligibilityPayload, S>

  type EligibilityCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<EligibilityFindManyArgs, 'select' | 'include'> & {
      select?: EligibilityCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Eligibility.
     * @param {EligibilityCreateArgs} args - Arguments to create a Eligibility.
     * @example
     * // Create one Eligibility
     * const Eligibility = await prisma.eligibility.create({
     *   data: {
     *     // ... data to create a Eligibility
     *   }
     * })
     * 
    **/
    create<T extends EligibilityCreateArgs<ExtArgs>>(
      args: SelectSubset<T, EligibilityCreateArgs<ExtArgs>>
    ): Prisma__EligibilityClient<$Result.GetResult<Prisma.$EligibilityPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a Eligibility.
     * @param {EligibilityDeleteArgs} args - Arguments to delete one Eligibility.
     * @example
     * // Delete one Eligibility
     * const Eligibility = await prisma.eligibility.delete({
     *   where: {
     *     // ... filter to delete one Eligibility
     *   }
     * })
     * 
    **/
    delete<T extends EligibilityDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, EligibilityDeleteArgs<ExtArgs>>
    ): Prisma__EligibilityClient<$Result.GetResult<Prisma.$EligibilityPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Eligibility.
   * 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__EligibilityClient<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 Eligibility model
   */ 
  interface EligibilityFieldRefs {
    readonly id: FieldRef<"Eligibility", 'Int'>
    readonly type: FieldRef<"Eligibility", 'String'>
    readonly text: FieldRef<"Eligibility", 'String'>
    readonly admission: FieldRef<"Eligibility", 'Int'>
    readonly subscription: FieldRef<"Eligibility", 'Int'>
  }
    

  // Custom InputTypes

  /**
   * Eligibility findUnique
   */
  export type EligibilityFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Eligibility
     */
    select?: EligibilitySelect<ExtArgs> | null
    /**
     * Filter, which Eligibility to fetch.
     */
    where: EligibilityWhereUniqueInput
  }


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


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


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


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


  /**
   * Eligibility create
   */
  export type EligibilityCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Eligibility
     */
    select?: EligibilitySelect<ExtArgs> | null
    /**
     * The data needed to create a Eligibility.
     */
    data: XOR<EligibilityCreateInput, EligibilityUncheckedCreateInput>
  }


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


  /**
   * Eligibility update
   */
  export type EligibilityUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Eligibility
     */
    select?: EligibilitySelect<ExtArgs> | null
    /**
     * The data needed to update a Eligibility.
     */
    data: XOR<EligibilityUpdateInput, EligibilityUncheckedUpdateInput>
    /**
     * Choose, which Eligibility to update.
     */
    where: EligibilityWhereUniqueInput
  }


  /**
   * Eligibility updateMany
   */
  export type EligibilityUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Eligibilities.
     */
    data: XOR<EligibilityUpdateManyMutationInput, EligibilityUncheckedUpdateManyInput>
    /**
     * Filter which Eligibilities to update
     */
    where?: EligibilityWhereInput
  }


  /**
   * Eligibility upsert
   */
  export type EligibilityUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Eligibility
     */
    select?: EligibilitySelect<ExtArgs> | null
    /**
     * The filter to search for the Eligibility to update in case it exists.
     */
    where: EligibilityWhereUniqueInput
    /**
     * In case the Eligibility found by the `where` argument doesn't exist, create a new Eligibility with this data.
     */
    create: XOR<EligibilityCreateInput, EligibilityUncheckedCreateInput>
    /**
     * In case the Eligibility was found with the provided `where` argument, update it with this data.
     */
    update: XOR<EligibilityUpdateInput, EligibilityUncheckedUpdateInput>
  }


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


  /**
   * Eligibility deleteMany
   */
  export type EligibilityDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Eligibilities to delete
     */
    where?: EligibilityWhereInput
  }


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



  /**
   * Model RelevantPapers
   */

  export type AggregateRelevantPapers = {
    _count: RelevantPapersCountAggregateOutputType | null
    _avg: RelevantPapersAvgAggregateOutputType | null
    _sum: RelevantPapersSumAggregateOutputType | null
    _min: RelevantPapersMinAggregateOutputType | null
    _max: RelevantPapersMaxAggregateOutputType | null
  }

  export type RelevantPapersAvgAggregateOutputType = {
    id: number | null
  }

  export type RelevantPapersSumAggregateOutputType = {
    id: number | null
  }

  export type RelevantPapersMinAggregateOutputType = {
    id: number | null
    type: string | null
    papers: string | null
  }

  export type RelevantPapersMaxAggregateOutputType = {
    id: number | null
    type: string | null
    papers: string | null
  }

  export type RelevantPapersCountAggregateOutputType = {
    id: number
    type: number
    papers: number
    _all: number
  }


  export type RelevantPapersAvgAggregateInputType = {
    id?: true
  }

  export type RelevantPapersSumAggregateInputType = {
    id?: true
  }

  export type RelevantPapersMinAggregateInputType = {
    id?: true
    type?: true
    papers?: true
  }

  export type RelevantPapersMaxAggregateInputType = {
    id?: true
    type?: true
    papers?: true
  }

  export type RelevantPapersCountAggregateInputType = {
    id?: true
    type?: true
    papers?: true
    _all?: true
  }

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

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




  export type RelevantPapersGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: RelevantPapersWhereInput
    orderBy?: RelevantPapersOrderByWithAggregationInput | RelevantPapersOrderByWithAggregationInput[]
    by: RelevantPapersScalarFieldEnum[] | RelevantPapersScalarFieldEnum
    having?: RelevantPapersScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: RelevantPapersCountAggregateInputType | true
    _avg?: RelevantPapersAvgAggregateInputType
    _sum?: RelevantPapersSumAggregateInputType
    _min?: RelevantPapersMinAggregateInputType
    _max?: RelevantPapersMaxAggregateInputType
  }

  export type RelevantPapersGroupByOutputType = {
    id: number
    type: string
    papers: string
    _count: RelevantPapersCountAggregateOutputType | null
    _avg: RelevantPapersAvgAggregateOutputType | null
    _sum: RelevantPapersSumAggregateOutputType | null
    _min: RelevantPapersMinAggregateOutputType | null
    _max: RelevantPapersMaxAggregateOutputType | null
  }

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


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

  export type RelevantPapersSelectScalar = {
    id?: boolean
    type?: boolean
    papers?: boolean
  }


  export type $RelevantPapersPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "RelevantPapers"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      type: string
      papers: string
    }, ExtArgs["result"]["relevantPapers"]>
    composites: {}
  }


  type RelevantPapersGetPayload<S extends boolean | null | undefined | RelevantPapersDefaultArgs> = $Result.GetResult<Prisma.$RelevantPapersPayload, S>

  type RelevantPapersCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<RelevantPapersFindManyArgs, 'select' | 'include'> & {
      select?: RelevantPapersCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a RelevantPapers.
     * @param {RelevantPapersCreateArgs} args - Arguments to create a RelevantPapers.
     * @example
     * // Create one RelevantPapers
     * const RelevantPapers = await prisma.relevantPapers.create({
     *   data: {
     *     // ... data to create a RelevantPapers
     *   }
     * })
     * 
    **/
    create<T extends RelevantPapersCreateArgs<ExtArgs>>(
      args: SelectSubset<T, RelevantPapersCreateArgs<ExtArgs>>
    ): Prisma__RelevantPapersClient<$Result.GetResult<Prisma.$RelevantPapersPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a RelevantPapers.
     * @param {RelevantPapersDeleteArgs} args - Arguments to delete one RelevantPapers.
     * @example
     * // Delete one RelevantPapers
     * const RelevantPapers = await prisma.relevantPapers.delete({
     *   where: {
     *     // ... filter to delete one RelevantPapers
     *   }
     * })
     * 
    **/
    delete<T extends RelevantPapersDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, RelevantPapersDeleteArgs<ExtArgs>>
    ): Prisma__RelevantPapersClient<$Result.GetResult<Prisma.$RelevantPapersPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for RelevantPapers.
   * 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__RelevantPapersClient<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 RelevantPapers model
   */ 
  interface RelevantPapersFieldRefs {
    readonly id: FieldRef<"RelevantPapers", 'Int'>
    readonly type: FieldRef<"RelevantPapers", 'String'>
    readonly papers: FieldRef<"RelevantPapers", 'String'>
  }
    

  // Custom InputTypes

  /**
   * RelevantPapers findUnique
   */
  export type RelevantPapersFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RelevantPapers
     */
    select?: RelevantPapersSelect<ExtArgs> | null
    /**
     * Filter, which RelevantPapers to fetch.
     */
    where: RelevantPapersWhereUniqueInput
  }


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


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


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


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


  /**
   * RelevantPapers create
   */
  export type RelevantPapersCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RelevantPapers
     */
    select?: RelevantPapersSelect<ExtArgs> | null
    /**
     * The data needed to create a RelevantPapers.
     */
    data: XOR<RelevantPapersCreateInput, RelevantPapersUncheckedCreateInput>
  }


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


  /**
   * RelevantPapers update
   */
  export type RelevantPapersUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RelevantPapers
     */
    select?: RelevantPapersSelect<ExtArgs> | null
    /**
     * The data needed to update a RelevantPapers.
     */
    data: XOR<RelevantPapersUpdateInput, RelevantPapersUncheckedUpdateInput>
    /**
     * Choose, which RelevantPapers to update.
     */
    where: RelevantPapersWhereUniqueInput
  }


  /**
   * RelevantPapers updateMany
   */
  export type RelevantPapersUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update RelevantPapers.
     */
    data: XOR<RelevantPapersUpdateManyMutationInput, RelevantPapersUncheckedUpdateManyInput>
    /**
     * Filter which RelevantPapers to update
     */
    where?: RelevantPapersWhereInput
  }


  /**
   * RelevantPapers upsert
   */
  export type RelevantPapersUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the RelevantPapers
     */
    select?: RelevantPapersSelect<ExtArgs> | null
    /**
     * The filter to search for the RelevantPapers to update in case it exists.
     */
    where: RelevantPapersWhereUniqueInput
    /**
     * In case the RelevantPapers found by the `where` argument doesn't exist, create a new RelevantPapers with this data.
     */
    create: XOR<RelevantPapersCreateInput, RelevantPapersUncheckedCreateInput>
    /**
     * In case the RelevantPapers was found with the provided `where` argument, update it with this data.
     */
    update: XOR<RelevantPapersUpdateInput, RelevantPapersUncheckedUpdateInput>
  }


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


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


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



  /**
   * Model MembersList
   */

  export type AggregateMembersList = {
    _count: MembersListCountAggregateOutputType | null
    _avg: MembersListAvgAggregateOutputType | null
    _sum: MembersListSumAggregateOutputType | null
    _min: MembersListMinAggregateOutputType | null
    _max: MembersListMaxAggregateOutputType | null
  }

  export type MembersListAvgAggregateOutputType = {
    id: number | null
  }

  export type MembersListSumAggregateOutputType = {
    id: number | null
  }

  export type MembersListMinAggregateOutputType = {
    id: number | null
    name: string | null
    type: string | null
    membershipId: string | null
  }

  export type MembersListMaxAggregateOutputType = {
    id: number | null
    name: string | null
    type: string | null
    membershipId: string | null
  }

  export type MembersListCountAggregateOutputType = {
    id: number
    name: number
    type: number
    membershipId: number
    _all: number
  }


  export type MembersListAvgAggregateInputType = {
    id?: true
  }

  export type MembersListSumAggregateInputType = {
    id?: true
  }

  export type MembersListMinAggregateInputType = {
    id?: true
    name?: true
    type?: true
    membershipId?: true
  }

  export type MembersListMaxAggregateInputType = {
    id?: true
    name?: true
    type?: true
    membershipId?: true
  }

  export type MembersListCountAggregateInputType = {
    id?: true
    name?: true
    type?: true
    membershipId?: true
    _all?: true
  }

  export type MembersListAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which MembersList to aggregate.
     */
    where?: MembersListWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MembersLists to fetch.
     */
    orderBy?: MembersListOrderByWithRelationInput | MembersListOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: MembersListWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MembersLists from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` MembersLists.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned MembersLists
    **/
    _count?: true | MembersListCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: MembersListAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: MembersListSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: MembersListMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: MembersListMaxAggregateInputType
  }

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




  export type MembersListGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MembersListWhereInput
    orderBy?: MembersListOrderByWithAggregationInput | MembersListOrderByWithAggregationInput[]
    by: MembersListScalarFieldEnum[] | MembersListScalarFieldEnum
    having?: MembersListScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: MembersListCountAggregateInputType | true
    _avg?: MembersListAvgAggregateInputType
    _sum?: MembersListSumAggregateInputType
    _min?: MembersListMinAggregateInputType
    _max?: MembersListMaxAggregateInputType
  }

  export type MembersListGroupByOutputType = {
    id: number
    name: string
    type: string
    membershipId: string
    _count: MembersListCountAggregateOutputType | null
    _avg: MembersListAvgAggregateOutputType | null
    _sum: MembersListSumAggregateOutputType | null
    _min: MembersListMinAggregateOutputType | null
    _max: MembersListMaxAggregateOutputType | null
  }

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


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

  export type MembersListSelectScalar = {
    id?: boolean
    name?: boolean
    type?: boolean
    membershipId?: boolean
  }


  export type $MembersListPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "MembersList"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      name: string
      type: string
      membershipId: string
    }, ExtArgs["result"]["membersList"]>
    composites: {}
  }


  type MembersListGetPayload<S extends boolean | null | undefined | MembersListDefaultArgs> = $Result.GetResult<Prisma.$MembersListPayload, S>

  type MembersListCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<MembersListFindManyArgs, 'select' | 'include'> & {
      select?: MembersListCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a MembersList.
     * @param {MembersListCreateArgs} args - Arguments to create a MembersList.
     * @example
     * // Create one MembersList
     * const MembersList = await prisma.membersList.create({
     *   data: {
     *     // ... data to create a MembersList
     *   }
     * })
     * 
    **/
    create<T extends MembersListCreateArgs<ExtArgs>>(
      args: SelectSubset<T, MembersListCreateArgs<ExtArgs>>
    ): Prisma__MembersListClient<$Result.GetResult<Prisma.$MembersListPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a MembersList.
     * @param {MembersListDeleteArgs} args - Arguments to delete one MembersList.
     * @example
     * // Delete one MembersList
     * const MembersList = await prisma.membersList.delete({
     *   where: {
     *     // ... filter to delete one MembersList
     *   }
     * })
     * 
    **/
    delete<T extends MembersListDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, MembersListDeleteArgs<ExtArgs>>
    ): Prisma__MembersListClient<$Result.GetResult<Prisma.$MembersListPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for MembersList.
   * 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__MembersListClient<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 MembersList model
   */ 
  interface MembersListFieldRefs {
    readonly id: FieldRef<"MembersList", 'Int'>
    readonly name: FieldRef<"MembersList", 'String'>
    readonly type: FieldRef<"MembersList", 'String'>
    readonly membershipId: FieldRef<"MembersList", 'String'>
  }
    

  // Custom InputTypes

  /**
   * MembersList findUnique
   */
  export type MembersListFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MembersList
     */
    select?: MembersListSelect<ExtArgs> | null
    /**
     * Filter, which MembersList to fetch.
     */
    where: MembersListWhereUniqueInput
  }


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


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


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


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


  /**
   * MembersList create
   */
  export type MembersListCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MembersList
     */
    select?: MembersListSelect<ExtArgs> | null
    /**
     * The data needed to create a MembersList.
     */
    data: XOR<MembersListCreateInput, MembersListUncheckedCreateInput>
  }


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


  /**
   * MembersList update
   */
  export type MembersListUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MembersList
     */
    select?: MembersListSelect<ExtArgs> | null
    /**
     * The data needed to update a MembersList.
     */
    data: XOR<MembersListUpdateInput, MembersListUncheckedUpdateInput>
    /**
     * Choose, which MembersList to update.
     */
    where: MembersListWhereUniqueInput
  }


  /**
   * MembersList updateMany
   */
  export type MembersListUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update MembersLists.
     */
    data: XOR<MembersListUpdateManyMutationInput, MembersListUncheckedUpdateManyInput>
    /**
     * Filter which MembersLists to update
     */
    where?: MembersListWhereInput
  }


  /**
   * MembersList upsert
   */
  export type MembersListUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MembersList
     */
    select?: MembersListSelect<ExtArgs> | null
    /**
     * The filter to search for the MembersList to update in case it exists.
     */
    where: MembersListWhereUniqueInput
    /**
     * In case the MembersList found by the `where` argument doesn't exist, create a new MembersList with this data.
     */
    create: XOR<MembersListCreateInput, MembersListUncheckedCreateInput>
    /**
     * In case the MembersList was found with the provided `where` argument, update it with this data.
     */
    update: XOR<MembersListUpdateInput, MembersListUncheckedUpdateInput>
  }


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


  /**
   * MembersList deleteMany
   */
  export type MembersListDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which MembersLists to delete
     */
    where?: MembersListWhereInput
  }


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



  /**
   * Model UsefulLinks
   */

  export type AggregateUsefulLinks = {
    _count: UsefulLinksCountAggregateOutputType | null
    _avg: UsefulLinksAvgAggregateOutputType | null
    _sum: UsefulLinksSumAggregateOutputType | null
    _min: UsefulLinksMinAggregateOutputType | null
    _max: UsefulLinksMaxAggregateOutputType | null
  }

  export type UsefulLinksAvgAggregateOutputType = {
    id: number | null
  }

  export type UsefulLinksSumAggregateOutputType = {
    id: number | null
  }

  export type UsefulLinksMinAggregateOutputType = {
    id: number | null
    type: string | null
    logo: string | null
    Name: string | null
    text: string | null
  }

  export type UsefulLinksMaxAggregateOutputType = {
    id: number | null
    type: string | null
    logo: string | null
    Name: string | null
    text: string | null
  }

  export type UsefulLinksCountAggregateOutputType = {
    id: number
    type: number
    logo: number
    Name: number
    text: number
    _all: number
  }


  export type UsefulLinksAvgAggregateInputType = {
    id?: true
  }

  export type UsefulLinksSumAggregateInputType = {
    id?: true
  }

  export type UsefulLinksMinAggregateInputType = {
    id?: true
    type?: true
    logo?: true
    Name?: true
    text?: true
  }

  export type UsefulLinksMaxAggregateInputType = {
    id?: true
    type?: true
    logo?: true
    Name?: true
    text?: true
  }

  export type UsefulLinksCountAggregateInputType = {
    id?: true
    type?: true
    logo?: true
    Name?: true
    text?: true
    _all?: true
  }

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

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




  export type UsefulLinksGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: UsefulLinksWhereInput
    orderBy?: UsefulLinksOrderByWithAggregationInput | UsefulLinksOrderByWithAggregationInput[]
    by: UsefulLinksScalarFieldEnum[] | UsefulLinksScalarFieldEnum
    having?: UsefulLinksScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: UsefulLinksCountAggregateInputType | true
    _avg?: UsefulLinksAvgAggregateInputType
    _sum?: UsefulLinksSumAggregateInputType
    _min?: UsefulLinksMinAggregateInputType
    _max?: UsefulLinksMaxAggregateInputType
  }

  export type UsefulLinksGroupByOutputType = {
    id: number
    type: string
    logo: string
    Name: string
    text: string | null
    _count: UsefulLinksCountAggregateOutputType | null
    _avg: UsefulLinksAvgAggregateOutputType | null
    _sum: UsefulLinksSumAggregateOutputType | null
    _min: UsefulLinksMinAggregateOutputType | null
    _max: UsefulLinksMaxAggregateOutputType | null
  }

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


  export type UsefulLinksSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    type?: boolean
    logo?: boolean
    Name?: boolean
    text?: boolean
  }, ExtArgs["result"]["usefulLinks"]>

  export type UsefulLinksSelectScalar = {
    id?: boolean
    type?: boolean
    logo?: boolean
    Name?: boolean
    text?: boolean
  }


  export type $UsefulLinksPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "UsefulLinks"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      type: string
      logo: string
      Name: string
      text: string | null
    }, ExtArgs["result"]["usefulLinks"]>
    composites: {}
  }


  type UsefulLinksGetPayload<S extends boolean | null | undefined | UsefulLinksDefaultArgs> = $Result.GetResult<Prisma.$UsefulLinksPayload, S>

  type UsefulLinksCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<UsefulLinksFindManyArgs, 'select' | 'include'> & {
      select?: UsefulLinksCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a UsefulLinks.
     * @param {UsefulLinksCreateArgs} args - Arguments to create a UsefulLinks.
     * @example
     * // Create one UsefulLinks
     * const UsefulLinks = await prisma.usefulLinks.create({
     *   data: {
     *     // ... data to create a UsefulLinks
     *   }
     * })
     * 
    **/
    create<T extends UsefulLinksCreateArgs<ExtArgs>>(
      args: SelectSubset<T, UsefulLinksCreateArgs<ExtArgs>>
    ): Prisma__UsefulLinksClient<$Result.GetResult<Prisma.$UsefulLinksPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a UsefulLinks.
     * @param {UsefulLinksDeleteArgs} args - Arguments to delete one UsefulLinks.
     * @example
     * // Delete one UsefulLinks
     * const UsefulLinks = await prisma.usefulLinks.delete({
     *   where: {
     *     // ... filter to delete one UsefulLinks
     *   }
     * })
     * 
    **/
    delete<T extends UsefulLinksDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, UsefulLinksDeleteArgs<ExtArgs>>
    ): Prisma__UsefulLinksClient<$Result.GetResult<Prisma.$UsefulLinksPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for UsefulLinks.
   * 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__UsefulLinksClient<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 UsefulLinks model
   */ 
  interface UsefulLinksFieldRefs {
    readonly id: FieldRef<"UsefulLinks", 'Int'>
    readonly type: FieldRef<"UsefulLinks", 'String'>
    readonly logo: FieldRef<"UsefulLinks", 'String'>
    readonly Name: FieldRef<"UsefulLinks", 'String'>
    readonly text: FieldRef<"UsefulLinks", 'String'>
  }
    

  // Custom InputTypes

  /**
   * UsefulLinks findUnique
   */
  export type UsefulLinksFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UsefulLinks
     */
    select?: UsefulLinksSelect<ExtArgs> | null
    /**
     * Filter, which UsefulLinks to fetch.
     */
    where: UsefulLinksWhereUniqueInput
  }


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


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


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


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


  /**
   * UsefulLinks create
   */
  export type UsefulLinksCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UsefulLinks
     */
    select?: UsefulLinksSelect<ExtArgs> | null
    /**
     * The data needed to create a UsefulLinks.
     */
    data: XOR<UsefulLinksCreateInput, UsefulLinksUncheckedCreateInput>
  }


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


  /**
   * UsefulLinks update
   */
  export type UsefulLinksUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UsefulLinks
     */
    select?: UsefulLinksSelect<ExtArgs> | null
    /**
     * The data needed to update a UsefulLinks.
     */
    data: XOR<UsefulLinksUpdateInput, UsefulLinksUncheckedUpdateInput>
    /**
     * Choose, which UsefulLinks to update.
     */
    where: UsefulLinksWhereUniqueInput
  }


  /**
   * UsefulLinks updateMany
   */
  export type UsefulLinksUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update UsefulLinks.
     */
    data: XOR<UsefulLinksUpdateManyMutationInput, UsefulLinksUncheckedUpdateManyInput>
    /**
     * Filter which UsefulLinks to update
     */
    where?: UsefulLinksWhereInput
  }


  /**
   * UsefulLinks upsert
   */
  export type UsefulLinksUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UsefulLinks
     */
    select?: UsefulLinksSelect<ExtArgs> | null
    /**
     * The filter to search for the UsefulLinks to update in case it exists.
     */
    where: UsefulLinksWhereUniqueInput
    /**
     * In case the UsefulLinks found by the `where` argument doesn't exist, create a new UsefulLinks with this data.
     */
    create: XOR<UsefulLinksCreateInput, UsefulLinksUncheckedCreateInput>
    /**
     * In case the UsefulLinks was found with the provided `where` argument, update it with this data.
     */
    update: XOR<UsefulLinksUpdateInput, UsefulLinksUncheckedUpdateInput>
  }


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


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


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



  /**
   * Model ContactUs
   */

  export type AggregateContactUs = {
    _count: ContactUsCountAggregateOutputType | null
    _avg: ContactUsAvgAggregateOutputType | null
    _sum: ContactUsSumAggregateOutputType | null
    _min: ContactUsMinAggregateOutputType | null
    _max: ContactUsMaxAggregateOutputType | null
  }

  export type ContactUsAvgAggregateOutputType = {
    id: number | null
  }

  export type ContactUsSumAggregateOutputType = {
    id: number | null
  }

  export type ContactUsMinAggregateOutputType = {
    id: number | null
    address: string | null
    telephone: string | null
    email: string | null
  }

  export type ContactUsMaxAggregateOutputType = {
    id: number | null
    address: string | null
    telephone: string | null
    email: string | null
  }

  export type ContactUsCountAggregateOutputType = {
    id: number
    address: number
    telephone: number
    email: number
    _all: number
  }


  export type ContactUsAvgAggregateInputType = {
    id?: true
  }

  export type ContactUsSumAggregateInputType = {
    id?: true
  }

  export type ContactUsMinAggregateInputType = {
    id?: true
    address?: true
    telephone?: true
    email?: true
  }

  export type ContactUsMaxAggregateInputType = {
    id?: true
    address?: true
    telephone?: true
    email?: true
  }

  export type ContactUsCountAggregateInputType = {
    id?: true
    address?: true
    telephone?: true
    email?: true
    _all?: true
  }

  export type ContactUsAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ContactUs to aggregate.
     */
    where?: ContactUsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Contactuses to fetch.
     */
    orderBy?: ContactUsOrderByWithRelationInput | ContactUsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ContactUsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Contactuses from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Contactuses.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Contactuses
    **/
    _count?: true | ContactUsCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ContactUsAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ContactUsSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ContactUsMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ContactUsMaxAggregateInputType
  }

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




  export type ContactUsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ContactUsWhereInput
    orderBy?: ContactUsOrderByWithAggregationInput | ContactUsOrderByWithAggregationInput[]
    by: ContactUsScalarFieldEnum[] | ContactUsScalarFieldEnum
    having?: ContactUsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ContactUsCountAggregateInputType | true
    _avg?: ContactUsAvgAggregateInputType
    _sum?: ContactUsSumAggregateInputType
    _min?: ContactUsMinAggregateInputType
    _max?: ContactUsMaxAggregateInputType
  }

  export type ContactUsGroupByOutputType = {
    id: number
    address: string
    telephone: string
    email: string
    _count: ContactUsCountAggregateOutputType | null
    _avg: ContactUsAvgAggregateOutputType | null
    _sum: ContactUsSumAggregateOutputType | null
    _min: ContactUsMinAggregateOutputType | null
    _max: ContactUsMaxAggregateOutputType | null
  }

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


  export type ContactUsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    address?: boolean
    telephone?: boolean
    email?: boolean
  }, ExtArgs["result"]["contactUs"]>

  export type ContactUsSelectScalar = {
    id?: boolean
    address?: boolean
    telephone?: boolean
    email?: boolean
  }


  export type $ContactUsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ContactUs"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      address: string
      telephone: string
      email: string
    }, ExtArgs["result"]["contactUs"]>
    composites: {}
  }


  type ContactUsGetPayload<S extends boolean | null | undefined | ContactUsDefaultArgs> = $Result.GetResult<Prisma.$ContactUsPayload, S>

  type ContactUsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ContactUsFindManyArgs, 'select' | 'include'> & {
      select?: ContactUsCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a ContactUs.
     * @param {ContactUsCreateArgs} args - Arguments to create a ContactUs.
     * @example
     * // Create one ContactUs
     * const ContactUs = await prisma.contactUs.create({
     *   data: {
     *     // ... data to create a ContactUs
     *   }
     * })
     * 
    **/
    create<T extends ContactUsCreateArgs<ExtArgs>>(
      args: SelectSubset<T, ContactUsCreateArgs<ExtArgs>>
    ): Prisma__ContactUsClient<$Result.GetResult<Prisma.$ContactUsPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a ContactUs.
     * @param {ContactUsDeleteArgs} args - Arguments to delete one ContactUs.
     * @example
     * // Delete one ContactUs
     * const ContactUs = await prisma.contactUs.delete({
     *   where: {
     *     // ... filter to delete one ContactUs
     *   }
     * })
     * 
    **/
    delete<T extends ContactUsDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, ContactUsDeleteArgs<ExtArgs>>
    ): Prisma__ContactUsClient<$Result.GetResult<Prisma.$ContactUsPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for ContactUs.
   * 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__ContactUsClient<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 ContactUs model
   */ 
  interface ContactUsFieldRefs {
    readonly id: FieldRef<"ContactUs", 'Int'>
    readonly address: FieldRef<"ContactUs", 'String'>
    readonly telephone: FieldRef<"ContactUs", 'String'>
    readonly email: FieldRef<"ContactUs", 'String'>
  }
    

  // Custom InputTypes

  /**
   * ContactUs findUnique
   */
  export type ContactUsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ContactUs
     */
    select?: ContactUsSelect<ExtArgs> | null
    /**
     * Filter, which ContactUs to fetch.
     */
    where: ContactUsWhereUniqueInput
  }


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


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


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


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


  /**
   * ContactUs create
   */
  export type ContactUsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ContactUs
     */
    select?: ContactUsSelect<ExtArgs> | null
    /**
     * The data needed to create a ContactUs.
     */
    data: XOR<ContactUsCreateInput, ContactUsUncheckedCreateInput>
  }


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


  /**
   * ContactUs update
   */
  export type ContactUsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ContactUs
     */
    select?: ContactUsSelect<ExtArgs> | null
    /**
     * The data needed to update a ContactUs.
     */
    data: XOR<ContactUsUpdateInput, ContactUsUncheckedUpdateInput>
    /**
     * Choose, which ContactUs to update.
     */
    where: ContactUsWhereUniqueInput
  }


  /**
   * ContactUs updateMany
   */
  export type ContactUsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Contactuses.
     */
    data: XOR<ContactUsUpdateManyMutationInput, ContactUsUncheckedUpdateManyInput>
    /**
     * Filter which Contactuses to update
     */
    where?: ContactUsWhereInput
  }


  /**
   * ContactUs upsert
   */
  export type ContactUsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ContactUs
     */
    select?: ContactUsSelect<ExtArgs> | null
    /**
     * The filter to search for the ContactUs to update in case it exists.
     */
    where: ContactUsWhereUniqueInput
    /**
     * In case the ContactUs found by the `where` argument doesn't exist, create a new ContactUs with this data.
     */
    create: XOR<ContactUsCreateInput, ContactUsUncheckedCreateInput>
    /**
     * In case the ContactUs was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ContactUsUpdateInput, ContactUsUncheckedUpdateInput>
  }


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


  /**
   * ContactUs deleteMany
   */
  export type ContactUsDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Contactuses to delete
     */
    where?: ContactUsWhereInput
  }


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



  /**
   * Model Secretariat
   */

  export type AggregateSecretariat = {
    _count: SecretariatCountAggregateOutputType | null
    _avg: SecretariatAvgAggregateOutputType | null
    _sum: SecretariatSumAggregateOutputType | null
    _min: SecretariatMinAggregateOutputType | null
    _max: SecretariatMaxAggregateOutputType | null
  }

  export type SecretariatAvgAggregateOutputType = {
    id: number | null
  }

  export type SecretariatSumAggregateOutputType = {
    id: number | null
  }

  export type SecretariatMinAggregateOutputType = {
    id: number | null
    name: string | null
    position: string | null
  }

  export type SecretariatMaxAggregateOutputType = {
    id: number | null
    name: string | null
    position: string | null
  }

  export type SecretariatCountAggregateOutputType = {
    id: number
    name: number
    position: number
    _all: number
  }


  export type SecretariatAvgAggregateInputType = {
    id?: true
  }

  export type SecretariatSumAggregateInputType = {
    id?: true
  }

  export type SecretariatMinAggregateInputType = {
    id?: true
    name?: true
    position?: true
  }

  export type SecretariatMaxAggregateInputType = {
    id?: true
    name?: true
    position?: true
  }

  export type SecretariatCountAggregateInputType = {
    id?: true
    name?: true
    position?: true
    _all?: true
  }

  export type SecretariatAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Secretariat to aggregate.
     */
    where?: SecretariatWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Secretariats to fetch.
     */
    orderBy?: SecretariatOrderByWithRelationInput | SecretariatOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: SecretariatWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Secretariats from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Secretariats.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Secretariats
    **/
    _count?: true | SecretariatCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: SecretariatAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: SecretariatSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: SecretariatMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: SecretariatMaxAggregateInputType
  }

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




  export type SecretariatGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SecretariatWhereInput
    orderBy?: SecretariatOrderByWithAggregationInput | SecretariatOrderByWithAggregationInput[]
    by: SecretariatScalarFieldEnum[] | SecretariatScalarFieldEnum
    having?: SecretariatScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: SecretariatCountAggregateInputType | true
    _avg?: SecretariatAvgAggregateInputType
    _sum?: SecretariatSumAggregateInputType
    _min?: SecretariatMinAggregateInputType
    _max?: SecretariatMaxAggregateInputType
  }

  export type SecretariatGroupByOutputType = {
    id: number
    name: string
    position: string
    _count: SecretariatCountAggregateOutputType | null
    _avg: SecretariatAvgAggregateOutputType | null
    _sum: SecretariatSumAggregateOutputType | null
    _min: SecretariatMinAggregateOutputType | null
    _max: SecretariatMaxAggregateOutputType | null
  }

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


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

  export type SecretariatSelectScalar = {
    id?: boolean
    name?: boolean
    position?: boolean
  }


  export type $SecretariatPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Secretariat"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      name: string
      position: string
    }, ExtArgs["result"]["secretariat"]>
    composites: {}
  }


  type SecretariatGetPayload<S extends boolean | null | undefined | SecretariatDefaultArgs> = $Result.GetResult<Prisma.$SecretariatPayload, S>

  type SecretariatCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<SecretariatFindManyArgs, 'select' | 'include'> & {
      select?: SecretariatCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a Secretariat.
     * @param {SecretariatCreateArgs} args - Arguments to create a Secretariat.
     * @example
     * // Create one Secretariat
     * const Secretariat = await prisma.secretariat.create({
     *   data: {
     *     // ... data to create a Secretariat
     *   }
     * })
     * 
    **/
    create<T extends SecretariatCreateArgs<ExtArgs>>(
      args: SelectSubset<T, SecretariatCreateArgs<ExtArgs>>
    ): Prisma__SecretariatClient<$Result.GetResult<Prisma.$SecretariatPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a Secretariat.
     * @param {SecretariatDeleteArgs} args - Arguments to delete one Secretariat.
     * @example
     * // Delete one Secretariat
     * const Secretariat = await prisma.secretariat.delete({
     *   where: {
     *     // ... filter to delete one Secretariat
     *   }
     * })
     * 
    **/
    delete<T extends SecretariatDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, SecretariatDeleteArgs<ExtArgs>>
    ): Prisma__SecretariatClient<$Result.GetResult<Prisma.$SecretariatPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

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

  // Custom InputTypes

  /**
   * Secretariat findUnique
   */
  export type SecretariatFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Secretariat
     */
    select?: SecretariatSelect<ExtArgs> | null
    /**
     * Filter, which Secretariat to fetch.
     */
    where: SecretariatWhereUniqueInput
  }


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


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


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


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


  /**
   * Secretariat create
   */
  export type SecretariatCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Secretariat
     */
    select?: SecretariatSelect<ExtArgs> | null
    /**
     * The data needed to create a Secretariat.
     */
    data: XOR<SecretariatCreateInput, SecretariatUncheckedCreateInput>
  }


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


  /**
   * Secretariat update
   */
  export type SecretariatUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Secretariat
     */
    select?: SecretariatSelect<ExtArgs> | null
    /**
     * The data needed to update a Secretariat.
     */
    data: XOR<SecretariatUpdateInput, SecretariatUncheckedUpdateInput>
    /**
     * Choose, which Secretariat to update.
     */
    where: SecretariatWhereUniqueInput
  }


  /**
   * Secretariat updateMany
   */
  export type SecretariatUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Secretariats.
     */
    data: XOR<SecretariatUpdateManyMutationInput, SecretariatUncheckedUpdateManyInput>
    /**
     * Filter which Secretariats to update
     */
    where?: SecretariatWhereInput
  }


  /**
   * Secretariat upsert
   */
  export type SecretariatUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Secretariat
     */
    select?: SecretariatSelect<ExtArgs> | null
    /**
     * The filter to search for the Secretariat to update in case it exists.
     */
    where: SecretariatWhereUniqueInput
    /**
     * In case the Secretariat found by the `where` argument doesn't exist, create a new Secretariat with this data.
     */
    create: XOR<SecretariatCreateInput, SecretariatUncheckedCreateInput>
    /**
     * In case the Secretariat was found with the provided `where` argument, update it with this data.
     */
    update: XOR<SecretariatUpdateInput, SecretariatUncheckedUpdateInput>
  }


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


  /**
   * Secretariat deleteMany
   */
  export type SecretariatDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Secretariats to delete
     */
    where?: SecretariatWhereInput
  }


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



  /**
   * Model PDFs
   */

  export type AggregatePDFs = {
    _count: PDFsCountAggregateOutputType | null
    _avg: PDFsAvgAggregateOutputType | null
    _sum: PDFsSumAggregateOutputType | null
    _min: PDFsMinAggregateOutputType | null
    _max: PDFsMaxAggregateOutputType | null
  }

  export type PDFsAvgAggregateOutputType = {
    id: number | null
  }

  export type PDFsSumAggregateOutputType = {
    id: number | null
  }

  export type PDFsMinAggregateOutputType = {
    id: number | null
    pdf: string | null
    image: string | null
    title: string | null
    type: string | null
  }

  export type PDFsMaxAggregateOutputType = {
    id: number | null
    pdf: string | null
    image: string | null
    title: string | null
    type: string | null
  }

  export type PDFsCountAggregateOutputType = {
    id: number
    pdf: number
    image: number
    title: number
    type: number
    _all: number
  }


  export type PDFsAvgAggregateInputType = {
    id?: true
  }

  export type PDFsSumAggregateInputType = {
    id?: true
  }

  export type PDFsMinAggregateInputType = {
    id?: true
    pdf?: true
    image?: true
    title?: true
    type?: true
  }

  export type PDFsMaxAggregateInputType = {
    id?: true
    pdf?: true
    image?: true
    title?: true
    type?: true
  }

  export type PDFsCountAggregateInputType = {
    id?: true
    pdf?: true
    image?: true
    title?: true
    type?: true
    _all?: true
  }

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

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




  export type PDFsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PDFsWhereInput
    orderBy?: PDFsOrderByWithAggregationInput | PDFsOrderByWithAggregationInput[]
    by: PDFsScalarFieldEnum[] | PDFsScalarFieldEnum
    having?: PDFsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: PDFsCountAggregateInputType | true
    _avg?: PDFsAvgAggregateInputType
    _sum?: PDFsSumAggregateInputType
    _min?: PDFsMinAggregateInputType
    _max?: PDFsMaxAggregateInputType
  }

  export type PDFsGroupByOutputType = {
    id: number
    pdf: string
    image: string | null
    title: string
    type: string
    _count: PDFsCountAggregateOutputType | null
    _avg: PDFsAvgAggregateOutputType | null
    _sum: PDFsSumAggregateOutputType | null
    _min: PDFsMinAggregateOutputType | null
    _max: PDFsMaxAggregateOutputType | null
  }

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


  export type PDFsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    pdf?: boolean
    image?: boolean
    title?: boolean
    type?: boolean
  }, ExtArgs["result"]["pDFs"]>

  export type PDFsSelectScalar = {
    id?: boolean
    pdf?: boolean
    image?: boolean
    title?: boolean
    type?: boolean
  }


  export type $PDFsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "PDFs"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      pdf: string
      image: string | null
      title: string
      type: string
    }, ExtArgs["result"]["pDFs"]>
    composites: {}
  }


  type PDFsGetPayload<S extends boolean | null | undefined | PDFsDefaultArgs> = $Result.GetResult<Prisma.$PDFsPayload, S>

  type PDFsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<PDFsFindManyArgs, 'select' | 'include'> & {
      select?: PDFsCountAggregateInputType | true
    }

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

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

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

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

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

    /**
     * Create a PDFs.
     * @param {PDFsCreateArgs} args - Arguments to create a PDFs.
     * @example
     * // Create one PDFs
     * const PDFs = await prisma.pDFs.create({
     *   data: {
     *     // ... data to create a PDFs
     *   }
     * })
     * 
    **/
    create<T extends PDFsCreateArgs<ExtArgs>>(
      args: SelectSubset<T, PDFsCreateArgs<ExtArgs>>
    ): Prisma__PDFsClient<$Result.GetResult<Prisma.$PDFsPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

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

    /**
     * Delete a PDFs.
     * @param {PDFsDeleteArgs} args - Arguments to delete one PDFs.
     * @example
     * // Delete one PDFs
     * const PDFs = await prisma.pDFs.delete({
     *   where: {
     *     // ... filter to delete one PDFs
     *   }
     * })
     * 
    **/
    delete<T extends PDFsDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, PDFsDeleteArgs<ExtArgs>>
    ): Prisma__PDFsClient<$Result.GetResult<Prisma.$PDFsPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

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

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

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

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

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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for PDFs.
   * 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__PDFsClient<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 PDFs model
   */ 
  interface PDFsFieldRefs {
    readonly id: FieldRef<"PDFs", 'Int'>
    readonly pdf: FieldRef<"PDFs", 'String'>
    readonly image: FieldRef<"PDFs", 'String'>
    readonly title: FieldRef<"PDFs", 'String'>
    readonly type: FieldRef<"PDFs", 'String'>
  }
    

  // Custom InputTypes

  /**
   * PDFs findUnique
   */
  export type PDFsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PDFs
     */
    select?: PDFsSelect<ExtArgs> | null
    /**
     * Filter, which PDFs to fetch.
     */
    where: PDFsWhereUniqueInput
  }


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


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


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


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


  /**
   * PDFs create
   */
  export type PDFsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PDFs
     */
    select?: PDFsSelect<ExtArgs> | null
    /**
     * The data needed to create a PDFs.
     */
    data: XOR<PDFsCreateInput, PDFsUncheckedCreateInput>
  }


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


  /**
   * PDFs update
   */
  export type PDFsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PDFs
     */
    select?: PDFsSelect<ExtArgs> | null
    /**
     * The data needed to update a PDFs.
     */
    data: XOR<PDFsUpdateInput, PDFsUncheckedUpdateInput>
    /**
     * Choose, which PDFs to update.
     */
    where: PDFsWhereUniqueInput
  }


  /**
   * PDFs updateMany
   */
  export type PDFsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update PDFs.
     */
    data: XOR<PDFsUpdateManyMutationInput, PDFsUncheckedUpdateManyInput>
    /**
     * Filter which PDFs to update
     */
    where?: PDFsWhereInput
  }


  /**
   * PDFs upsert
   */
  export type PDFsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PDFs
     */
    select?: PDFsSelect<ExtArgs> | null
    /**
     * The filter to search for the PDFs to update in case it exists.
     */
    where: PDFsWhereUniqueInput
    /**
     * In case the PDFs found by the `where` argument doesn't exist, create a new PDFs with this data.
     */
    create: XOR<PDFsCreateInput, PDFsUncheckedCreateInput>
    /**
     * In case the PDFs was found with the provided `where` argument, update it with this data.
     */
    update: XOR<PDFsUpdateInput, PDFsUncheckedUpdateInput>
  }


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


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


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



  /**
   * Model Forms
   */

  export type AggregateForms = {
    _count: FormsCountAggregateOutputType | null
    _avg: FormsAvgAggregateOutputType | null
    _sum: FormsSumAggregateOutputType | null
    _min: FormsMinAggregateOutputType | null
    _max: FormsMaxAggregateOutputType | null
  }

  export type FormsAvgAggregateOutputType = {
    id: number | null
  }

  export type FormsSumAggregateOutputType = {
    id: number | null
  }

  export type FormsMinAggregateOutputType = {
    id: number | null
    pdf: string | null
    title: string | null
    type: string | null
  }

  export type FormsMaxAggregateOutputType = {
    id: number | null
    pdf: string | null
    title: string | null
    type: string | null
  }

  export type FormsCountAggregateOutputType = {
    id: number
    pdf: number
    title: number
    type: number
    _all: number
  }


  export type FormsAvgAggregateInputType = {
    id?: true
  }

  export type FormsSumAggregateInputType = {
    id?: true
  }

  export type FormsMinAggregateInputType = {
    id?: true
    pdf?: true
    title?: true
    type?: true
  }

  export type FormsMaxAggregateInputType = {
    id?: true
    pdf?: true
    title?: true
    type?: true
  }

  export type FormsCountAggregateInputType = {
    id?: true
    pdf?: true
    title?: true
    type?: true
    _all?: true
  }

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

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




  export type FormsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: FormsWhereInput
    orderBy?: FormsOrderByWithAggregationInput | FormsOrderByWithAggregationInput[]
    by: FormsScalarFieldEnum[] | FormsScalarFieldEnum
    having?: FormsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: FormsCountAggregateInputType | true
    _avg?: FormsAvgAggregateInputType
    _sum?: FormsSumAggregateInputType
    _min?: FormsMinAggregateInputType
    _max?: FormsMaxAggregateInputType
  }

  export type FormsGroupByOutputType = {
    id: number
    pdf: string
    title: string
    type: string
    _count: FormsCountAggregateOutputType | null
    _avg: FormsAvgAggregateOutputType | null
    _sum: FormsSumAggregateOutputType | null
    _min: FormsMinAggregateOutputType | null
    _max: FormsMaxAggregateOutputType | null
  }

  type GetFormsGroupByPayload<T extends FormsGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<FormsGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof FormsGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], FormsGroupByOutputType[P]>
            : GetScalarType<T[P], FormsGroupByOutputType[P]>
        }
      >
    >


  export type FormsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    pdf?: boolean
    title?: boolean
    type?: boolean
  }, ExtArgs["result"]["forms"]>

  export type FormsSelectScalar = {
    id?: boolean
    pdf?: boolean
    title?: boolean
    type?: boolean
  }


  export type $FormsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Forms"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      pdf: string
      title: string
      type: string
    }, ExtArgs["result"]["forms"]>
    composites: {}
  }


  type FormsGetPayload<S extends boolean | null | undefined | FormsDefaultArgs> = $Result.GetResult<Prisma.$FormsPayload, S>

  type FormsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<FormsFindManyArgs, 'select' | 'include'> & {
      select?: FormsCountAggregateInputType | true
    }

  export interface FormsDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Forms'], meta: { name: 'Forms' } }
    /**
     * Find zero or one Forms that matches the filter.
     * @param {FormsFindUniqueArgs} args - Arguments to find a Forms
     * @example
     * // Get one Forms
     * const forms = await prisma.forms.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends FormsFindUniqueArgs<ExtArgs>>(
      args: SelectSubset<T, FormsFindUniqueArgs<ExtArgs>>
    ): Prisma__FormsClient<$Result.GetResult<Prisma.$FormsPayload<ExtArgs>, T, 'findUnique'> | null, null, ExtArgs>

    /**
     * Find one Forms that matches the filter or throw an error  with `error.code='P2025'` 
     *     if no matches were found.
     * @param {FormsFindUniqueOrThrowArgs} args - Arguments to find a Forms
     * @example
     * // Get one Forms
     * const forms = await prisma.forms.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUniqueOrThrow<T extends FormsFindUniqueOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, FormsFindUniqueOrThrowArgs<ExtArgs>>
    ): Prisma__FormsClient<$Result.GetResult<Prisma.$FormsPayload<ExtArgs>, T, 'findUniqueOrThrow'>, never, ExtArgs>

    /**
     * Find the first Forms 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 {FormsFindFirstArgs} args - Arguments to find a Forms
     * @example
     * // Get one Forms
     * const forms = await prisma.forms.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends FormsFindFirstArgs<ExtArgs>>(
      args?: SelectSubset<T, FormsFindFirstArgs<ExtArgs>>
    ): Prisma__FormsClient<$Result.GetResult<Prisma.$FormsPayload<ExtArgs>, T, 'findFirst'> | null, null, ExtArgs>

    /**
     * Find the first Forms 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 {FormsFindFirstOrThrowArgs} args - Arguments to find a Forms
     * @example
     * // Get one Forms
     * const forms = await prisma.forms.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirstOrThrow<T extends FormsFindFirstOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, FormsFindFirstOrThrowArgs<ExtArgs>>
    ): Prisma__FormsClient<$Result.GetResult<Prisma.$FormsPayload<ExtArgs>, T, 'findFirstOrThrow'>, never, ExtArgs>

    /**
     * Find zero or more Forms 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 {FormsFindManyArgs=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Forms
     * const forms = await prisma.forms.findMany()
     * 
     * // Get first 10 Forms
     * const forms = await prisma.forms.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const formsWithIdOnly = await prisma.forms.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends FormsFindManyArgs<ExtArgs>>(
      args?: SelectSubset<T, FormsFindManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<$Result.GetResult<Prisma.$FormsPayload<ExtArgs>, T, 'findMany'>>

    /**
     * Create a Forms.
     * @param {FormsCreateArgs} args - Arguments to create a Forms.
     * @example
     * // Create one Forms
     * const Forms = await prisma.forms.create({
     *   data: {
     *     // ... data to create a Forms
     *   }
     * })
     * 
    **/
    create<T extends FormsCreateArgs<ExtArgs>>(
      args: SelectSubset<T, FormsCreateArgs<ExtArgs>>
    ): Prisma__FormsClient<$Result.GetResult<Prisma.$FormsPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

    /**
     * Create many Forms.
     *     @param {FormsCreateManyArgs} args - Arguments to create many Forms.
     *     @example
     *     // Create many Forms
     *     const forms = await prisma.forms.createMany({
     *       data: {
     *         // ... provide data here
     *       }
     *     })
     *     
    **/
    createMany<T extends FormsCreateManyArgs<ExtArgs>>(
      args?: SelectSubset<T, FormsCreateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Forms.
     * @param {FormsDeleteArgs} args - Arguments to delete one Forms.
     * @example
     * // Delete one Forms
     * const Forms = await prisma.forms.delete({
     *   where: {
     *     // ... filter to delete one Forms
     *   }
     * })
     * 
    **/
    delete<T extends FormsDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, FormsDeleteArgs<ExtArgs>>
    ): Prisma__FormsClient<$Result.GetResult<Prisma.$FormsPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one Forms.
     * @param {FormsUpdateArgs} args - Arguments to update one Forms.
     * @example
     * // Update one Forms
     * const forms = await prisma.forms.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends FormsUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, FormsUpdateArgs<ExtArgs>>
    ): Prisma__FormsClient<$Result.GetResult<Prisma.$FormsPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

    /**
     * Delete zero or more Forms.
     * @param {FormsDeleteManyArgs} args - Arguments to filter Forms to delete.
     * @example
     * // Delete a few Forms
     * const { count } = await prisma.forms.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends FormsDeleteManyArgs<ExtArgs>>(
      args?: SelectSubset<T, FormsDeleteManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Forms.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FormsUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Forms
     * const forms = await prisma.forms.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends FormsUpdateManyArgs<ExtArgs>>(
      args: SelectSubset<T, FormsUpdateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Forms.
     * @param {FormsUpsertArgs} args - Arguments to update or create a Forms.
     * @example
     * // Update or create a Forms
     * const forms = await prisma.forms.upsert({
     *   create: {
     *     // ... data to create a Forms
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Forms we want to update
     *   }
     * })
    **/
    upsert<T extends FormsUpsertArgs<ExtArgs>>(
      args: SelectSubset<T, FormsUpsertArgs<ExtArgs>>
    ): Prisma__FormsClient<$Result.GetResult<Prisma.$FormsPayload<ExtArgs>, T, 'upsert'>, never, ExtArgs>

    /**
     * Count the number of Forms.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FormsCountArgs} args - Arguments to filter Forms to count.
     * @example
     * // Count the number of Forms
     * const count = await prisma.forms.count({
     *   where: {
     *     // ... the filter for the Forms we want to count
     *   }
     * })
    **/
    count<T extends FormsCountArgs>(
      args?: Subset<T, FormsCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], FormsCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Forms.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FormsAggregateArgs} 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 FormsAggregateArgs>(args: Subset<T, FormsAggregateArgs>): Prisma.PrismaPromise<GetFormsAggregateType<T>>

    /**
     * Group by Forms.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FormsGroupByArgs} 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 FormsGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: FormsGroupByArgs['orderBy'] }
        : { orderBy?: FormsGroupByArgs['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, FormsGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetFormsGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Forms model
   */
  readonly fields: FormsFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Forms.
   * 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__FormsClient<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 Forms model
   */ 
  interface FormsFieldRefs {
    readonly id: FieldRef<"Forms", 'Int'>
    readonly pdf: FieldRef<"Forms", 'String'>
    readonly title: FieldRef<"Forms", 'String'>
    readonly type: FieldRef<"Forms", 'String'>
  }
    

  // Custom InputTypes

  /**
   * Forms findUnique
   */
  export type FormsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Forms
     */
    select?: FormsSelect<ExtArgs> | null
    /**
     * Filter, which Forms to fetch.
     */
    where: FormsWhereUniqueInput
  }


  /**
   * Forms findUniqueOrThrow
   */
  export type FormsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Forms
     */
    select?: FormsSelect<ExtArgs> | null
    /**
     * Filter, which Forms to fetch.
     */
    where: FormsWhereUniqueInput
  }


  /**
   * Forms findFirst
   */
  export type FormsFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Forms
     */
    select?: FormsSelect<ExtArgs> | null
    /**
     * Filter, which Forms to fetch.
     */
    where?: FormsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Forms to fetch.
     */
    orderBy?: FormsOrderByWithRelationInput | FormsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Forms.
     */
    cursor?: FormsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Forms from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Forms.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Forms.
     */
    distinct?: FormsScalarFieldEnum | FormsScalarFieldEnum[]
  }


  /**
   * Forms findFirstOrThrow
   */
  export type FormsFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Forms
     */
    select?: FormsSelect<ExtArgs> | null
    /**
     * Filter, which Forms to fetch.
     */
    where?: FormsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Forms to fetch.
     */
    orderBy?: FormsOrderByWithRelationInput | FormsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Forms.
     */
    cursor?: FormsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Forms from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Forms.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Forms.
     */
    distinct?: FormsScalarFieldEnum | FormsScalarFieldEnum[]
  }


  /**
   * Forms findMany
   */
  export type FormsFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Forms
     */
    select?: FormsSelect<ExtArgs> | null
    /**
     * Filter, which Forms to fetch.
     */
    where?: FormsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Forms to fetch.
     */
    orderBy?: FormsOrderByWithRelationInput | FormsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Forms.
     */
    cursor?: FormsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Forms from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Forms.
     */
    skip?: number
    distinct?: FormsScalarFieldEnum | FormsScalarFieldEnum[]
  }


  /**
   * Forms create
   */
  export type FormsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Forms
     */
    select?: FormsSelect<ExtArgs> | null
    /**
     * The data needed to create a Forms.
     */
    data: XOR<FormsCreateInput, FormsUncheckedCreateInput>
  }


  /**
   * Forms createMany
   */
  export type FormsCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Forms.
     */
    data: FormsCreateManyInput | FormsCreateManyInput[]
    skipDuplicates?: boolean
  }


  /**
   * Forms update
   */
  export type FormsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Forms
     */
    select?: FormsSelect<ExtArgs> | null
    /**
     * The data needed to update a Forms.
     */
    data: XOR<FormsUpdateInput, FormsUncheckedUpdateInput>
    /**
     * Choose, which Forms to update.
     */
    where: FormsWhereUniqueInput
  }


  /**
   * Forms updateMany
   */
  export type FormsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Forms.
     */
    data: XOR<FormsUpdateManyMutationInput, FormsUncheckedUpdateManyInput>
    /**
     * Filter which Forms to update
     */
    where?: FormsWhereInput
  }


  /**
   * Forms upsert
   */
  export type FormsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Forms
     */
    select?: FormsSelect<ExtArgs> | null
    /**
     * The filter to search for the Forms to update in case it exists.
     */
    where: FormsWhereUniqueInput
    /**
     * In case the Forms found by the `where` argument doesn't exist, create a new Forms with this data.
     */
    create: XOR<FormsCreateInput, FormsUncheckedCreateInput>
    /**
     * In case the Forms was found with the provided `where` argument, update it with this data.
     */
    update: XOR<FormsUpdateInput, FormsUncheckedUpdateInput>
  }


  /**
   * Forms delete
   */
  export type FormsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Forms
     */
    select?: FormsSelect<ExtArgs> | null
    /**
     * Filter which Forms to delete.
     */
    where: FormsWhereUniqueInput
  }


  /**
   * Forms deleteMany
   */
  export type FormsDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Forms to delete
     */
    where?: FormsWhereInput
  }


  /**
   * Forms without action
   */
  export type FormsDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Forms
     */
    select?: FormsSelect<ExtArgs> | null
  }



  /**
   * Model MembershipText
   */

  export type AggregateMembershipText = {
    _count: MembershipTextCountAggregateOutputType | null
    _avg: MembershipTextAvgAggregateOutputType | null
    _sum: MembershipTextSumAggregateOutputType | null
    _min: MembershipTextMinAggregateOutputType | null
    _max: MembershipTextMaxAggregateOutputType | null
  }

  export type MembershipTextAvgAggregateOutputType = {
    id: number | null
  }

  export type MembershipTextSumAggregateOutputType = {
    id: number | null
  }

  export type MembershipTextMinAggregateOutputType = {
    id: number | null
    title: string | null
    text: string | null
  }

  export type MembershipTextMaxAggregateOutputType = {
    id: number | null
    title: string | null
    text: string | null
  }

  export type MembershipTextCountAggregateOutputType = {
    id: number
    title: number
    text: number
    _all: number
  }


  export type MembershipTextAvgAggregateInputType = {
    id?: true
  }

  export type MembershipTextSumAggregateInputType = {
    id?: true
  }

  export type MembershipTextMinAggregateInputType = {
    id?: true
    title?: true
    text?: true
  }

  export type MembershipTextMaxAggregateInputType = {
    id?: true
    title?: true
    text?: true
  }

  export type MembershipTextCountAggregateInputType = {
    id?: true
    title?: true
    text?: true
    _all?: true
  }

  export type MembershipTextAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which MembershipText to aggregate.
     */
    where?: MembershipTextWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MembershipTexts to fetch.
     */
    orderBy?: MembershipTextOrderByWithRelationInput | MembershipTextOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: MembershipTextWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MembershipTexts from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` MembershipTexts.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned MembershipTexts
    **/
    _count?: true | MembershipTextCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: MembershipTextAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: MembershipTextSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: MembershipTextMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: MembershipTextMaxAggregateInputType
  }

  export type GetMembershipTextAggregateType<T extends MembershipTextAggregateArgs> = {
        [P in keyof T & keyof AggregateMembershipText]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateMembershipText[P]>
      : GetScalarType<T[P], AggregateMembershipText[P]>
  }




  export type MembershipTextGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MembershipTextWhereInput
    orderBy?: MembershipTextOrderByWithAggregationInput | MembershipTextOrderByWithAggregationInput[]
    by: MembershipTextScalarFieldEnum[] | MembershipTextScalarFieldEnum
    having?: MembershipTextScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: MembershipTextCountAggregateInputType | true
    _avg?: MembershipTextAvgAggregateInputType
    _sum?: MembershipTextSumAggregateInputType
    _min?: MembershipTextMinAggregateInputType
    _max?: MembershipTextMaxAggregateInputType
  }

  export type MembershipTextGroupByOutputType = {
    id: number
    title: string
    text: string
    _count: MembershipTextCountAggregateOutputType | null
    _avg: MembershipTextAvgAggregateOutputType | null
    _sum: MembershipTextSumAggregateOutputType | null
    _min: MembershipTextMinAggregateOutputType | null
    _max: MembershipTextMaxAggregateOutputType | null
  }

  type GetMembershipTextGroupByPayload<T extends MembershipTextGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<MembershipTextGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof MembershipTextGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], MembershipTextGroupByOutputType[P]>
            : GetScalarType<T[P], MembershipTextGroupByOutputType[P]>
        }
      >
    >


  export type MembershipTextSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    text?: boolean
  }, ExtArgs["result"]["membershipText"]>

  export type MembershipTextSelectScalar = {
    id?: boolean
    title?: boolean
    text?: boolean
  }


  export type $MembershipTextPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "MembershipText"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      title: string
      text: string
    }, ExtArgs["result"]["membershipText"]>
    composites: {}
  }


  type MembershipTextGetPayload<S extends boolean | null | undefined | MembershipTextDefaultArgs> = $Result.GetResult<Prisma.$MembershipTextPayload, S>

  type MembershipTextCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<MembershipTextFindManyArgs, 'select' | 'include'> & {
      select?: MembershipTextCountAggregateInputType | true
    }

  export interface MembershipTextDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['MembershipText'], meta: { name: 'MembershipText' } }
    /**
     * Find zero or one MembershipText that matches the filter.
     * @param {MembershipTextFindUniqueArgs} args - Arguments to find a MembershipText
     * @example
     * // Get one MembershipText
     * const membershipText = await prisma.membershipText.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends MembershipTextFindUniqueArgs<ExtArgs>>(
      args: SelectSubset<T, MembershipTextFindUniqueArgs<ExtArgs>>
    ): Prisma__MembershipTextClient<$Result.GetResult<Prisma.$MembershipTextPayload<ExtArgs>, T, 'findUnique'> | null, null, ExtArgs>

    /**
     * Find one MembershipText that matches the filter or throw an error  with `error.code='P2025'` 
     *     if no matches were found.
     * @param {MembershipTextFindUniqueOrThrowArgs} args - Arguments to find a MembershipText
     * @example
     * // Get one MembershipText
     * const membershipText = await prisma.membershipText.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUniqueOrThrow<T extends MembershipTextFindUniqueOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, MembershipTextFindUniqueOrThrowArgs<ExtArgs>>
    ): Prisma__MembershipTextClient<$Result.GetResult<Prisma.$MembershipTextPayload<ExtArgs>, T, 'findUniqueOrThrow'>, never, ExtArgs>

    /**
     * Find the first MembershipText 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 {MembershipTextFindFirstArgs} args - Arguments to find a MembershipText
     * @example
     * // Get one MembershipText
     * const membershipText = await prisma.membershipText.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends MembershipTextFindFirstArgs<ExtArgs>>(
      args?: SelectSubset<T, MembershipTextFindFirstArgs<ExtArgs>>
    ): Prisma__MembershipTextClient<$Result.GetResult<Prisma.$MembershipTextPayload<ExtArgs>, T, 'findFirst'> | null, null, ExtArgs>

    /**
     * Find the first MembershipText 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 {MembershipTextFindFirstOrThrowArgs} args - Arguments to find a MembershipText
     * @example
     * // Get one MembershipText
     * const membershipText = await prisma.membershipText.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirstOrThrow<T extends MembershipTextFindFirstOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, MembershipTextFindFirstOrThrowArgs<ExtArgs>>
    ): Prisma__MembershipTextClient<$Result.GetResult<Prisma.$MembershipTextPayload<ExtArgs>, T, 'findFirstOrThrow'>, never, ExtArgs>

    /**
     * Find zero or more MembershipTexts 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 {MembershipTextFindManyArgs=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all MembershipTexts
     * const membershipTexts = await prisma.membershipText.findMany()
     * 
     * // Get first 10 MembershipTexts
     * const membershipTexts = await prisma.membershipText.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const membershipTextWithIdOnly = await prisma.membershipText.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends MembershipTextFindManyArgs<ExtArgs>>(
      args?: SelectSubset<T, MembershipTextFindManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MembershipTextPayload<ExtArgs>, T, 'findMany'>>

    /**
     * Create a MembershipText.
     * @param {MembershipTextCreateArgs} args - Arguments to create a MembershipText.
     * @example
     * // Create one MembershipText
     * const MembershipText = await prisma.membershipText.create({
     *   data: {
     *     // ... data to create a MembershipText
     *   }
     * })
     * 
    **/
    create<T extends MembershipTextCreateArgs<ExtArgs>>(
      args: SelectSubset<T, MembershipTextCreateArgs<ExtArgs>>
    ): Prisma__MembershipTextClient<$Result.GetResult<Prisma.$MembershipTextPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

    /**
     * Create many MembershipTexts.
     *     @param {MembershipTextCreateManyArgs} args - Arguments to create many MembershipTexts.
     *     @example
     *     // Create many MembershipTexts
     *     const membershipText = await prisma.membershipText.createMany({
     *       data: {
     *         // ... provide data here
     *       }
     *     })
     *     
    **/
    createMany<T extends MembershipTextCreateManyArgs<ExtArgs>>(
      args?: SelectSubset<T, MembershipTextCreateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a MembershipText.
     * @param {MembershipTextDeleteArgs} args - Arguments to delete one MembershipText.
     * @example
     * // Delete one MembershipText
     * const MembershipText = await prisma.membershipText.delete({
     *   where: {
     *     // ... filter to delete one MembershipText
     *   }
     * })
     * 
    **/
    delete<T extends MembershipTextDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, MembershipTextDeleteArgs<ExtArgs>>
    ): Prisma__MembershipTextClient<$Result.GetResult<Prisma.$MembershipTextPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one MembershipText.
     * @param {MembershipTextUpdateArgs} args - Arguments to update one MembershipText.
     * @example
     * // Update one MembershipText
     * const membershipText = await prisma.membershipText.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends MembershipTextUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, MembershipTextUpdateArgs<ExtArgs>>
    ): Prisma__MembershipTextClient<$Result.GetResult<Prisma.$MembershipTextPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

    /**
     * Delete zero or more MembershipTexts.
     * @param {MembershipTextDeleteManyArgs} args - Arguments to filter MembershipTexts to delete.
     * @example
     * // Delete a few MembershipTexts
     * const { count } = await prisma.membershipText.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends MembershipTextDeleteManyArgs<ExtArgs>>(
      args?: SelectSubset<T, MembershipTextDeleteManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more MembershipTexts.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MembershipTextUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many MembershipTexts
     * const membershipText = await prisma.membershipText.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends MembershipTextUpdateManyArgs<ExtArgs>>(
      args: SelectSubset<T, MembershipTextUpdateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one MembershipText.
     * @param {MembershipTextUpsertArgs} args - Arguments to update or create a MembershipText.
     * @example
     * // Update or create a MembershipText
     * const membershipText = await prisma.membershipText.upsert({
     *   create: {
     *     // ... data to create a MembershipText
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the MembershipText we want to update
     *   }
     * })
    **/
    upsert<T extends MembershipTextUpsertArgs<ExtArgs>>(
      args: SelectSubset<T, MembershipTextUpsertArgs<ExtArgs>>
    ): Prisma__MembershipTextClient<$Result.GetResult<Prisma.$MembershipTextPayload<ExtArgs>, T, 'upsert'>, never, ExtArgs>

    /**
     * Count the number of MembershipTexts.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MembershipTextCountArgs} args - Arguments to filter MembershipTexts to count.
     * @example
     * // Count the number of MembershipTexts
     * const count = await prisma.membershipText.count({
     *   where: {
     *     // ... the filter for the MembershipTexts we want to count
     *   }
     * })
    **/
    count<T extends MembershipTextCountArgs>(
      args?: Subset<T, MembershipTextCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], MembershipTextCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a MembershipText.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MembershipTextAggregateArgs} 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 MembershipTextAggregateArgs>(args: Subset<T, MembershipTextAggregateArgs>): Prisma.PrismaPromise<GetMembershipTextAggregateType<T>>

    /**
     * Group by MembershipText.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MembershipTextGroupByArgs} 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 MembershipTextGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: MembershipTextGroupByArgs['orderBy'] }
        : { orderBy?: MembershipTextGroupByArgs['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, MembershipTextGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetMembershipTextGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the MembershipText model
   */
  readonly fields: MembershipTextFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for MembershipText.
   * 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__MembershipTextClient<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 MembershipText model
   */ 
  interface MembershipTextFieldRefs {
    readonly id: FieldRef<"MembershipText", 'Int'>
    readonly title: FieldRef<"MembershipText", 'String'>
    readonly text: FieldRef<"MembershipText", 'String'>
  }
    

  // Custom InputTypes

  /**
   * MembershipText findUnique
   */
  export type MembershipTextFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MembershipText
     */
    select?: MembershipTextSelect<ExtArgs> | null
    /**
     * Filter, which MembershipText to fetch.
     */
    where: MembershipTextWhereUniqueInput
  }


  /**
   * MembershipText findUniqueOrThrow
   */
  export type MembershipTextFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MembershipText
     */
    select?: MembershipTextSelect<ExtArgs> | null
    /**
     * Filter, which MembershipText to fetch.
     */
    where: MembershipTextWhereUniqueInput
  }


  /**
   * MembershipText findFirst
   */
  export type MembershipTextFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MembershipText
     */
    select?: MembershipTextSelect<ExtArgs> | null
    /**
     * Filter, which MembershipText to fetch.
     */
    where?: MembershipTextWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MembershipTexts to fetch.
     */
    orderBy?: MembershipTextOrderByWithRelationInput | MembershipTextOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for MembershipTexts.
     */
    cursor?: MembershipTextWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MembershipTexts from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` MembershipTexts.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of MembershipTexts.
     */
    distinct?: MembershipTextScalarFieldEnum | MembershipTextScalarFieldEnum[]
  }


  /**
   * MembershipText findFirstOrThrow
   */
  export type MembershipTextFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MembershipText
     */
    select?: MembershipTextSelect<ExtArgs> | null
    /**
     * Filter, which MembershipText to fetch.
     */
    where?: MembershipTextWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MembershipTexts to fetch.
     */
    orderBy?: MembershipTextOrderByWithRelationInput | MembershipTextOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for MembershipTexts.
     */
    cursor?: MembershipTextWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MembershipTexts from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` MembershipTexts.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of MembershipTexts.
     */
    distinct?: MembershipTextScalarFieldEnum | MembershipTextScalarFieldEnum[]
  }


  /**
   * MembershipText findMany
   */
  export type MembershipTextFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MembershipText
     */
    select?: MembershipTextSelect<ExtArgs> | null
    /**
     * Filter, which MembershipTexts to fetch.
     */
    where?: MembershipTextWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MembershipTexts to fetch.
     */
    orderBy?: MembershipTextOrderByWithRelationInput | MembershipTextOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing MembershipTexts.
     */
    cursor?: MembershipTextWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MembershipTexts from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` MembershipTexts.
     */
    skip?: number
    distinct?: MembershipTextScalarFieldEnum | MembershipTextScalarFieldEnum[]
  }


  /**
   * MembershipText create
   */
  export type MembershipTextCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MembershipText
     */
    select?: MembershipTextSelect<ExtArgs> | null
    /**
     * The data needed to create a MembershipText.
     */
    data: XOR<MembershipTextCreateInput, MembershipTextUncheckedCreateInput>
  }


  /**
   * MembershipText createMany
   */
  export type MembershipTextCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many MembershipTexts.
     */
    data: MembershipTextCreateManyInput | MembershipTextCreateManyInput[]
    skipDuplicates?: boolean
  }


  /**
   * MembershipText update
   */
  export type MembershipTextUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MembershipText
     */
    select?: MembershipTextSelect<ExtArgs> | null
    /**
     * The data needed to update a MembershipText.
     */
    data: XOR<MembershipTextUpdateInput, MembershipTextUncheckedUpdateInput>
    /**
     * Choose, which MembershipText to update.
     */
    where: MembershipTextWhereUniqueInput
  }


  /**
   * MembershipText updateMany
   */
  export type MembershipTextUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update MembershipTexts.
     */
    data: XOR<MembershipTextUpdateManyMutationInput, MembershipTextUncheckedUpdateManyInput>
    /**
     * Filter which MembershipTexts to update
     */
    where?: MembershipTextWhereInput
  }


  /**
   * MembershipText upsert
   */
  export type MembershipTextUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MembershipText
     */
    select?: MembershipTextSelect<ExtArgs> | null
    /**
     * The filter to search for the MembershipText to update in case it exists.
     */
    where: MembershipTextWhereUniqueInput
    /**
     * In case the MembershipText found by the `where` argument doesn't exist, create a new MembershipText with this data.
     */
    create: XOR<MembershipTextCreateInput, MembershipTextUncheckedCreateInput>
    /**
     * In case the MembershipText was found with the provided `where` argument, update it with this data.
     */
    update: XOR<MembershipTextUpdateInput, MembershipTextUncheckedUpdateInput>
  }


  /**
   * MembershipText delete
   */
  export type MembershipTextDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MembershipText
     */
    select?: MembershipTextSelect<ExtArgs> | null
    /**
     * Filter which MembershipText to delete.
     */
    where: MembershipTextWhereUniqueInput
  }


  /**
   * MembershipText deleteMany
   */
  export type MembershipTextDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which MembershipTexts to delete
     */
    where?: MembershipTextWhereInput
  }


  /**
   * MembershipText without action
   */
  export type MembershipTextDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MembershipText
     */
    select?: MembershipTextSelect<ExtArgs> | null
  }



  /**
   * Model ApplicationProcedure
   */

  export type AggregateApplicationProcedure = {
    _count: ApplicationProcedureCountAggregateOutputType | null
    _avg: ApplicationProcedureAvgAggregateOutputType | null
    _sum: ApplicationProcedureSumAggregateOutputType | null
    _min: ApplicationProcedureMinAggregateOutputType | null
    _max: ApplicationProcedureMaxAggregateOutputType | null
  }

  export type ApplicationProcedureAvgAggregateOutputType = {
    id: number | null
  }

  export type ApplicationProcedureSumAggregateOutputType = {
    id: number | null
  }

  export type ApplicationProcedureMinAggregateOutputType = {
    id: number | null
    text: string | null
  }

  export type ApplicationProcedureMaxAggregateOutputType = {
    id: number | null
    text: string | null
  }

  export type ApplicationProcedureCountAggregateOutputType = {
    id: number
    text: number
    _all: number
  }


  export type ApplicationProcedureAvgAggregateInputType = {
    id?: true
  }

  export type ApplicationProcedureSumAggregateInputType = {
    id?: true
  }

  export type ApplicationProcedureMinAggregateInputType = {
    id?: true
    text?: true
  }

  export type ApplicationProcedureMaxAggregateInputType = {
    id?: true
    text?: true
  }

  export type ApplicationProcedureCountAggregateInputType = {
    id?: true
    text?: true
    _all?: true
  }

  export type ApplicationProcedureAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ApplicationProcedure to aggregate.
     */
    where?: ApplicationProcedureWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ApplicationProcedures to fetch.
     */
    orderBy?: ApplicationProcedureOrderByWithRelationInput | ApplicationProcedureOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ApplicationProcedureWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ApplicationProcedures from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` ApplicationProcedures.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ApplicationProcedures
    **/
    _count?: true | ApplicationProcedureCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ApplicationProcedureAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ApplicationProcedureSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ApplicationProcedureMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ApplicationProcedureMaxAggregateInputType
  }

  export type GetApplicationProcedureAggregateType<T extends ApplicationProcedureAggregateArgs> = {
        [P in keyof T & keyof AggregateApplicationProcedure]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateApplicationProcedure[P]>
      : GetScalarType<T[P], AggregateApplicationProcedure[P]>
  }




  export type ApplicationProcedureGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ApplicationProcedureWhereInput
    orderBy?: ApplicationProcedureOrderByWithAggregationInput | ApplicationProcedureOrderByWithAggregationInput[]
    by: ApplicationProcedureScalarFieldEnum[] | ApplicationProcedureScalarFieldEnum
    having?: ApplicationProcedureScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ApplicationProcedureCountAggregateInputType | true
    _avg?: ApplicationProcedureAvgAggregateInputType
    _sum?: ApplicationProcedureSumAggregateInputType
    _min?: ApplicationProcedureMinAggregateInputType
    _max?: ApplicationProcedureMaxAggregateInputType
  }

  export type ApplicationProcedureGroupByOutputType = {
    id: number
    text: string
    _count: ApplicationProcedureCountAggregateOutputType | null
    _avg: ApplicationProcedureAvgAggregateOutputType | null
    _sum: ApplicationProcedureSumAggregateOutputType | null
    _min: ApplicationProcedureMinAggregateOutputType | null
    _max: ApplicationProcedureMaxAggregateOutputType | null
  }

  type GetApplicationProcedureGroupByPayload<T extends ApplicationProcedureGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<ApplicationProcedureGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof ApplicationProcedureGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], ApplicationProcedureGroupByOutputType[P]>
            : GetScalarType<T[P], ApplicationProcedureGroupByOutputType[P]>
        }
      >
    >


  export type ApplicationProcedureSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    text?: boolean
  }, ExtArgs["result"]["applicationProcedure"]>

  export type ApplicationProcedureSelectScalar = {
    id?: boolean
    text?: boolean
  }


  export type $ApplicationProcedurePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ApplicationProcedure"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      text: string
    }, ExtArgs["result"]["applicationProcedure"]>
    composites: {}
  }


  type ApplicationProcedureGetPayload<S extends boolean | null | undefined | ApplicationProcedureDefaultArgs> = $Result.GetResult<Prisma.$ApplicationProcedurePayload, S>

  type ApplicationProcedureCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ApplicationProcedureFindManyArgs, 'select' | 'include'> & {
      select?: ApplicationProcedureCountAggregateInputType | true
    }

  export interface ApplicationProcedureDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['ApplicationProcedure'], meta: { name: 'ApplicationProcedure' } }
    /**
     * Find zero or one ApplicationProcedure that matches the filter.
     * @param {ApplicationProcedureFindUniqueArgs} args - Arguments to find a ApplicationProcedure
     * @example
     * // Get one ApplicationProcedure
     * const applicationProcedure = await prisma.applicationProcedure.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends ApplicationProcedureFindUniqueArgs<ExtArgs>>(
      args: SelectSubset<T, ApplicationProcedureFindUniqueArgs<ExtArgs>>
    ): Prisma__ApplicationProcedureClient<$Result.GetResult<Prisma.$ApplicationProcedurePayload<ExtArgs>, T, 'findUnique'> | null, null, ExtArgs>

    /**
     * Find one ApplicationProcedure that matches the filter or throw an error  with `error.code='P2025'` 
     *     if no matches were found.
     * @param {ApplicationProcedureFindUniqueOrThrowArgs} args - Arguments to find a ApplicationProcedure
     * @example
     * // Get one ApplicationProcedure
     * const applicationProcedure = await prisma.applicationProcedure.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUniqueOrThrow<T extends ApplicationProcedureFindUniqueOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, ApplicationProcedureFindUniqueOrThrowArgs<ExtArgs>>
    ): Prisma__ApplicationProcedureClient<$Result.GetResult<Prisma.$ApplicationProcedurePayload<ExtArgs>, T, 'findUniqueOrThrow'>, never, ExtArgs>

    /**
     * Find the first ApplicationProcedure 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 {ApplicationProcedureFindFirstArgs} args - Arguments to find a ApplicationProcedure
     * @example
     * // Get one ApplicationProcedure
     * const applicationProcedure = await prisma.applicationProcedure.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends ApplicationProcedureFindFirstArgs<ExtArgs>>(
      args?: SelectSubset<T, ApplicationProcedureFindFirstArgs<ExtArgs>>
    ): Prisma__ApplicationProcedureClient<$Result.GetResult<Prisma.$ApplicationProcedurePayload<ExtArgs>, T, 'findFirst'> | null, null, ExtArgs>

    /**
     * Find the first ApplicationProcedure 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 {ApplicationProcedureFindFirstOrThrowArgs} args - Arguments to find a ApplicationProcedure
     * @example
     * // Get one ApplicationProcedure
     * const applicationProcedure = await prisma.applicationProcedure.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirstOrThrow<T extends ApplicationProcedureFindFirstOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, ApplicationProcedureFindFirstOrThrowArgs<ExtArgs>>
    ): Prisma__ApplicationProcedureClient<$Result.GetResult<Prisma.$ApplicationProcedurePayload<ExtArgs>, T, 'findFirstOrThrow'>, never, ExtArgs>

    /**
     * Find zero or more ApplicationProcedures 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 {ApplicationProcedureFindManyArgs=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all ApplicationProcedures
     * const applicationProcedures = await prisma.applicationProcedure.findMany()
     * 
     * // Get first 10 ApplicationProcedures
     * const applicationProcedures = await prisma.applicationProcedure.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const applicationProcedureWithIdOnly = await prisma.applicationProcedure.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends ApplicationProcedureFindManyArgs<ExtArgs>>(
      args?: SelectSubset<T, ApplicationProcedureFindManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ApplicationProcedurePayload<ExtArgs>, T, 'findMany'>>

    /**
     * Create a ApplicationProcedure.
     * @param {ApplicationProcedureCreateArgs} args - Arguments to create a ApplicationProcedure.
     * @example
     * // Create one ApplicationProcedure
     * const ApplicationProcedure = await prisma.applicationProcedure.create({
     *   data: {
     *     // ... data to create a ApplicationProcedure
     *   }
     * })
     * 
    **/
    create<T extends ApplicationProcedureCreateArgs<ExtArgs>>(
      args: SelectSubset<T, ApplicationProcedureCreateArgs<ExtArgs>>
    ): Prisma__ApplicationProcedureClient<$Result.GetResult<Prisma.$ApplicationProcedurePayload<ExtArgs>, T, 'create'>, never, ExtArgs>

    /**
     * Create many ApplicationProcedures.
     *     @param {ApplicationProcedureCreateManyArgs} args - Arguments to create many ApplicationProcedures.
     *     @example
     *     // Create many ApplicationProcedures
     *     const applicationProcedure = await prisma.applicationProcedure.createMany({
     *       data: {
     *         // ... provide data here
     *       }
     *     })
     *     
    **/
    createMany<T extends ApplicationProcedureCreateManyArgs<ExtArgs>>(
      args?: SelectSubset<T, ApplicationProcedureCreateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a ApplicationProcedure.
     * @param {ApplicationProcedureDeleteArgs} args - Arguments to delete one ApplicationProcedure.
     * @example
     * // Delete one ApplicationProcedure
     * const ApplicationProcedure = await prisma.applicationProcedure.delete({
     *   where: {
     *     // ... filter to delete one ApplicationProcedure
     *   }
     * })
     * 
    **/
    delete<T extends ApplicationProcedureDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, ApplicationProcedureDeleteArgs<ExtArgs>>
    ): Prisma__ApplicationProcedureClient<$Result.GetResult<Prisma.$ApplicationProcedurePayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one ApplicationProcedure.
     * @param {ApplicationProcedureUpdateArgs} args - Arguments to update one ApplicationProcedure.
     * @example
     * // Update one ApplicationProcedure
     * const applicationProcedure = await prisma.applicationProcedure.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends ApplicationProcedureUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, ApplicationProcedureUpdateArgs<ExtArgs>>
    ): Prisma__ApplicationProcedureClient<$Result.GetResult<Prisma.$ApplicationProcedurePayload<ExtArgs>, T, 'update'>, never, ExtArgs>

    /**
     * Delete zero or more ApplicationProcedures.
     * @param {ApplicationProcedureDeleteManyArgs} args - Arguments to filter ApplicationProcedures to delete.
     * @example
     * // Delete a few ApplicationProcedures
     * const { count } = await prisma.applicationProcedure.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends ApplicationProcedureDeleteManyArgs<ExtArgs>>(
      args?: SelectSubset<T, ApplicationProcedureDeleteManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more ApplicationProcedures.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ApplicationProcedureUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many ApplicationProcedures
     * const applicationProcedure = await prisma.applicationProcedure.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends ApplicationProcedureUpdateManyArgs<ExtArgs>>(
      args: SelectSubset<T, ApplicationProcedureUpdateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one ApplicationProcedure.
     * @param {ApplicationProcedureUpsertArgs} args - Arguments to update or create a ApplicationProcedure.
     * @example
     * // Update or create a ApplicationProcedure
     * const applicationProcedure = await prisma.applicationProcedure.upsert({
     *   create: {
     *     // ... data to create a ApplicationProcedure
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the ApplicationProcedure we want to update
     *   }
     * })
    **/
    upsert<T extends ApplicationProcedureUpsertArgs<ExtArgs>>(
      args: SelectSubset<T, ApplicationProcedureUpsertArgs<ExtArgs>>
    ): Prisma__ApplicationProcedureClient<$Result.GetResult<Prisma.$ApplicationProcedurePayload<ExtArgs>, T, 'upsert'>, never, ExtArgs>

    /**
     * Count the number of ApplicationProcedures.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ApplicationProcedureCountArgs} args - Arguments to filter ApplicationProcedures to count.
     * @example
     * // Count the number of ApplicationProcedures
     * const count = await prisma.applicationProcedure.count({
     *   where: {
     *     // ... the filter for the ApplicationProcedures we want to count
     *   }
     * })
    **/
    count<T extends ApplicationProcedureCountArgs>(
      args?: Subset<T, ApplicationProcedureCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], ApplicationProcedureCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a ApplicationProcedure.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ApplicationProcedureAggregateArgs} 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 ApplicationProcedureAggregateArgs>(args: Subset<T, ApplicationProcedureAggregateArgs>): Prisma.PrismaPromise<GetApplicationProcedureAggregateType<T>>

    /**
     * Group by ApplicationProcedure.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ApplicationProcedureGroupByArgs} 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 ApplicationProcedureGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: ApplicationProcedureGroupByArgs['orderBy'] }
        : { orderBy?: ApplicationProcedureGroupByArgs['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, ApplicationProcedureGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetApplicationProcedureGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the ApplicationProcedure model
   */
  readonly fields: ApplicationProcedureFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for ApplicationProcedure.
   * 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__ApplicationProcedureClient<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 ApplicationProcedure model
   */ 
  interface ApplicationProcedureFieldRefs {
    readonly id: FieldRef<"ApplicationProcedure", 'Int'>
    readonly text: FieldRef<"ApplicationProcedure", 'String'>
  }
    

  // Custom InputTypes

  /**
   * ApplicationProcedure findUnique
   */
  export type ApplicationProcedureFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApplicationProcedure
     */
    select?: ApplicationProcedureSelect<ExtArgs> | null
    /**
     * Filter, which ApplicationProcedure to fetch.
     */
    where: ApplicationProcedureWhereUniqueInput
  }


  /**
   * ApplicationProcedure findUniqueOrThrow
   */
  export type ApplicationProcedureFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApplicationProcedure
     */
    select?: ApplicationProcedureSelect<ExtArgs> | null
    /**
     * Filter, which ApplicationProcedure to fetch.
     */
    where: ApplicationProcedureWhereUniqueInput
  }


  /**
   * ApplicationProcedure findFirst
   */
  export type ApplicationProcedureFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApplicationProcedure
     */
    select?: ApplicationProcedureSelect<ExtArgs> | null
    /**
     * Filter, which ApplicationProcedure to fetch.
     */
    where?: ApplicationProcedureWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ApplicationProcedures to fetch.
     */
    orderBy?: ApplicationProcedureOrderByWithRelationInput | ApplicationProcedureOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for ApplicationProcedures.
     */
    cursor?: ApplicationProcedureWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ApplicationProcedures from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` ApplicationProcedures.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of ApplicationProcedures.
     */
    distinct?: ApplicationProcedureScalarFieldEnum | ApplicationProcedureScalarFieldEnum[]
  }


  /**
   * ApplicationProcedure findFirstOrThrow
   */
  export type ApplicationProcedureFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApplicationProcedure
     */
    select?: ApplicationProcedureSelect<ExtArgs> | null
    /**
     * Filter, which ApplicationProcedure to fetch.
     */
    where?: ApplicationProcedureWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ApplicationProcedures to fetch.
     */
    orderBy?: ApplicationProcedureOrderByWithRelationInput | ApplicationProcedureOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for ApplicationProcedures.
     */
    cursor?: ApplicationProcedureWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ApplicationProcedures from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` ApplicationProcedures.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of ApplicationProcedures.
     */
    distinct?: ApplicationProcedureScalarFieldEnum | ApplicationProcedureScalarFieldEnum[]
  }


  /**
   * ApplicationProcedure findMany
   */
  export type ApplicationProcedureFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApplicationProcedure
     */
    select?: ApplicationProcedureSelect<ExtArgs> | null
    /**
     * Filter, which ApplicationProcedures to fetch.
     */
    where?: ApplicationProcedureWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ApplicationProcedures to fetch.
     */
    orderBy?: ApplicationProcedureOrderByWithRelationInput | ApplicationProcedureOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing ApplicationProcedures.
     */
    cursor?: ApplicationProcedureWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ApplicationProcedures from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` ApplicationProcedures.
     */
    skip?: number
    distinct?: ApplicationProcedureScalarFieldEnum | ApplicationProcedureScalarFieldEnum[]
  }


  /**
   * ApplicationProcedure create
   */
  export type ApplicationProcedureCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApplicationProcedure
     */
    select?: ApplicationProcedureSelect<ExtArgs> | null
    /**
     * The data needed to create a ApplicationProcedure.
     */
    data: XOR<ApplicationProcedureCreateInput, ApplicationProcedureUncheckedCreateInput>
  }


  /**
   * ApplicationProcedure createMany
   */
  export type ApplicationProcedureCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many ApplicationProcedures.
     */
    data: ApplicationProcedureCreateManyInput | ApplicationProcedureCreateManyInput[]
    skipDuplicates?: boolean
  }


  /**
   * ApplicationProcedure update
   */
  export type ApplicationProcedureUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApplicationProcedure
     */
    select?: ApplicationProcedureSelect<ExtArgs> | null
    /**
     * The data needed to update a ApplicationProcedure.
     */
    data: XOR<ApplicationProcedureUpdateInput, ApplicationProcedureUncheckedUpdateInput>
    /**
     * Choose, which ApplicationProcedure to update.
     */
    where: ApplicationProcedureWhereUniqueInput
  }


  /**
   * ApplicationProcedure updateMany
   */
  export type ApplicationProcedureUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ApplicationProcedures.
     */
    data: XOR<ApplicationProcedureUpdateManyMutationInput, ApplicationProcedureUncheckedUpdateManyInput>
    /**
     * Filter which ApplicationProcedures to update
     */
    where?: ApplicationProcedureWhereInput
  }


  /**
   * ApplicationProcedure upsert
   */
  export type ApplicationProcedureUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApplicationProcedure
     */
    select?: ApplicationProcedureSelect<ExtArgs> | null
    /**
     * The filter to search for the ApplicationProcedure to update in case it exists.
     */
    where: ApplicationProcedureWhereUniqueInput
    /**
     * In case the ApplicationProcedure found by the `where` argument doesn't exist, create a new ApplicationProcedure with this data.
     */
    create: XOR<ApplicationProcedureCreateInput, ApplicationProcedureUncheckedCreateInput>
    /**
     * In case the ApplicationProcedure was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ApplicationProcedureUpdateInput, ApplicationProcedureUncheckedUpdateInput>
  }


  /**
   * ApplicationProcedure delete
   */
  export type ApplicationProcedureDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApplicationProcedure
     */
    select?: ApplicationProcedureSelect<ExtArgs> | null
    /**
     * Filter which ApplicationProcedure to delete.
     */
    where: ApplicationProcedureWhereUniqueInput
  }


  /**
   * ApplicationProcedure deleteMany
   */
  export type ApplicationProcedureDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ApplicationProcedures to delete
     */
    where?: ApplicationProcedureWhereInput
  }


  /**
   * ApplicationProcedure without action
   */
  export type ApplicationProcedureDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ApplicationProcedure
     */
    select?: ApplicationProcedureSelect<ExtArgs> | null
  }



  /**
   * Model Benefits
   */

  export type AggregateBenefits = {
    _count: BenefitsCountAggregateOutputType | null
    _avg: BenefitsAvgAggregateOutputType | null
    _sum: BenefitsSumAggregateOutputType | null
    _min: BenefitsMinAggregateOutputType | null
    _max: BenefitsMaxAggregateOutputType | null
  }

  export type BenefitsAvgAggregateOutputType = {
    id: number | null
  }

  export type BenefitsSumAggregateOutputType = {
    id: number | null
  }

  export type BenefitsMinAggregateOutputType = {
    id: number | null
    benefits: string | null
    advantages: string | null
  }

  export type BenefitsMaxAggregateOutputType = {
    id: number | null
    benefits: string | null
    advantages: string | null
  }

  export type BenefitsCountAggregateOutputType = {
    id: number
    benefits: number
    advantages: number
    _all: number
  }


  export type BenefitsAvgAggregateInputType = {
    id?: true
  }

  export type BenefitsSumAggregateInputType = {
    id?: true
  }

  export type BenefitsMinAggregateInputType = {
    id?: true
    benefits?: true
    advantages?: true
  }

  export type BenefitsMaxAggregateInputType = {
    id?: true
    benefits?: true
    advantages?: true
  }

  export type BenefitsCountAggregateInputType = {
    id?: true
    benefits?: true
    advantages?: true
    _all?: true
  }

  export type BenefitsAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Benefits to aggregate.
     */
    where?: BenefitsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Benefits to fetch.
     */
    orderBy?: BenefitsOrderByWithRelationInput | BenefitsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: BenefitsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Benefits from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Benefits.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Benefits
    **/
    _count?: true | BenefitsCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: BenefitsAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: BenefitsSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: BenefitsMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: BenefitsMaxAggregateInputType
  }

  export type GetBenefitsAggregateType<T extends BenefitsAggregateArgs> = {
        [P in keyof T & keyof AggregateBenefits]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateBenefits[P]>
      : GetScalarType<T[P], AggregateBenefits[P]>
  }




  export type BenefitsGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: BenefitsWhereInput
    orderBy?: BenefitsOrderByWithAggregationInput | BenefitsOrderByWithAggregationInput[]
    by: BenefitsScalarFieldEnum[] | BenefitsScalarFieldEnum
    having?: BenefitsScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: BenefitsCountAggregateInputType | true
    _avg?: BenefitsAvgAggregateInputType
    _sum?: BenefitsSumAggregateInputType
    _min?: BenefitsMinAggregateInputType
    _max?: BenefitsMaxAggregateInputType
  }

  export type BenefitsGroupByOutputType = {
    id: number
    benefits: string
    advantages: string
    _count: BenefitsCountAggregateOutputType | null
    _avg: BenefitsAvgAggregateOutputType | null
    _sum: BenefitsSumAggregateOutputType | null
    _min: BenefitsMinAggregateOutputType | null
    _max: BenefitsMaxAggregateOutputType | null
  }

  type GetBenefitsGroupByPayload<T extends BenefitsGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<BenefitsGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof BenefitsGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], BenefitsGroupByOutputType[P]>
            : GetScalarType<T[P], BenefitsGroupByOutputType[P]>
        }
      >
    >


  export type BenefitsSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    benefits?: boolean
    advantages?: boolean
  }, ExtArgs["result"]["benefits"]>

  export type BenefitsSelectScalar = {
    id?: boolean
    benefits?: boolean
    advantages?: boolean
  }


  export type $BenefitsPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Benefits"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      benefits: string
      advantages: string
    }, ExtArgs["result"]["benefits"]>
    composites: {}
  }


  type BenefitsGetPayload<S extends boolean | null | undefined | BenefitsDefaultArgs> = $Result.GetResult<Prisma.$BenefitsPayload, S>

  type BenefitsCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<BenefitsFindManyArgs, 'select' | 'include'> & {
      select?: BenefitsCountAggregateInputType | true
    }

  export interface BenefitsDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Benefits'], meta: { name: 'Benefits' } }
    /**
     * Find zero or one Benefits that matches the filter.
     * @param {BenefitsFindUniqueArgs} args - Arguments to find a Benefits
     * @example
     * // Get one Benefits
     * const benefits = await prisma.benefits.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends BenefitsFindUniqueArgs<ExtArgs>>(
      args: SelectSubset<T, BenefitsFindUniqueArgs<ExtArgs>>
    ): Prisma__BenefitsClient<$Result.GetResult<Prisma.$BenefitsPayload<ExtArgs>, T, 'findUnique'> | null, null, ExtArgs>

    /**
     * Find one Benefits that matches the filter or throw an error  with `error.code='P2025'` 
     *     if no matches were found.
     * @param {BenefitsFindUniqueOrThrowArgs} args - Arguments to find a Benefits
     * @example
     * // Get one Benefits
     * const benefits = await prisma.benefits.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUniqueOrThrow<T extends BenefitsFindUniqueOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, BenefitsFindUniqueOrThrowArgs<ExtArgs>>
    ): Prisma__BenefitsClient<$Result.GetResult<Prisma.$BenefitsPayload<ExtArgs>, T, 'findUniqueOrThrow'>, never, ExtArgs>

    /**
     * Find the first Benefits 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 {BenefitsFindFirstArgs} args - Arguments to find a Benefits
     * @example
     * // Get one Benefits
     * const benefits = await prisma.benefits.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends BenefitsFindFirstArgs<ExtArgs>>(
      args?: SelectSubset<T, BenefitsFindFirstArgs<ExtArgs>>
    ): Prisma__BenefitsClient<$Result.GetResult<Prisma.$BenefitsPayload<ExtArgs>, T, 'findFirst'> | null, null, ExtArgs>

    /**
     * Find the first Benefits 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 {BenefitsFindFirstOrThrowArgs} args - Arguments to find a Benefits
     * @example
     * // Get one Benefits
     * const benefits = await prisma.benefits.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirstOrThrow<T extends BenefitsFindFirstOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, BenefitsFindFirstOrThrowArgs<ExtArgs>>
    ): Prisma__BenefitsClient<$Result.GetResult<Prisma.$BenefitsPayload<ExtArgs>, T, 'findFirstOrThrow'>, never, ExtArgs>

    /**
     * Find zero or more Benefits 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 {BenefitsFindManyArgs=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Benefits
     * const benefits = await prisma.benefits.findMany()
     * 
     * // Get first 10 Benefits
     * const benefits = await prisma.benefits.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const benefitsWithIdOnly = await prisma.benefits.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends BenefitsFindManyArgs<ExtArgs>>(
      args?: SelectSubset<T, BenefitsFindManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<$Result.GetResult<Prisma.$BenefitsPayload<ExtArgs>, T, 'findMany'>>

    /**
     * Create a Benefits.
     * @param {BenefitsCreateArgs} args - Arguments to create a Benefits.
     * @example
     * // Create one Benefits
     * const Benefits = await prisma.benefits.create({
     *   data: {
     *     // ... data to create a Benefits
     *   }
     * })
     * 
    **/
    create<T extends BenefitsCreateArgs<ExtArgs>>(
      args: SelectSubset<T, BenefitsCreateArgs<ExtArgs>>
    ): Prisma__BenefitsClient<$Result.GetResult<Prisma.$BenefitsPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

    /**
     * Create many Benefits.
     *     @param {BenefitsCreateManyArgs} args - Arguments to create many Benefits.
     *     @example
     *     // Create many Benefits
     *     const benefits = await prisma.benefits.createMany({
     *       data: {
     *         // ... provide data here
     *       }
     *     })
     *     
    **/
    createMany<T extends BenefitsCreateManyArgs<ExtArgs>>(
      args?: SelectSubset<T, BenefitsCreateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Benefits.
     * @param {BenefitsDeleteArgs} args - Arguments to delete one Benefits.
     * @example
     * // Delete one Benefits
     * const Benefits = await prisma.benefits.delete({
     *   where: {
     *     // ... filter to delete one Benefits
     *   }
     * })
     * 
    **/
    delete<T extends BenefitsDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, BenefitsDeleteArgs<ExtArgs>>
    ): Prisma__BenefitsClient<$Result.GetResult<Prisma.$BenefitsPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one Benefits.
     * @param {BenefitsUpdateArgs} args - Arguments to update one Benefits.
     * @example
     * // Update one Benefits
     * const benefits = await prisma.benefits.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends BenefitsUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, BenefitsUpdateArgs<ExtArgs>>
    ): Prisma__BenefitsClient<$Result.GetResult<Prisma.$BenefitsPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

    /**
     * Delete zero or more Benefits.
     * @param {BenefitsDeleteManyArgs} args - Arguments to filter Benefits to delete.
     * @example
     * // Delete a few Benefits
     * const { count } = await prisma.benefits.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends BenefitsDeleteManyArgs<ExtArgs>>(
      args?: SelectSubset<T, BenefitsDeleteManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Benefits.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {BenefitsUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Benefits
     * const benefits = await prisma.benefits.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends BenefitsUpdateManyArgs<ExtArgs>>(
      args: SelectSubset<T, BenefitsUpdateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Benefits.
     * @param {BenefitsUpsertArgs} args - Arguments to update or create a Benefits.
     * @example
     * // Update or create a Benefits
     * const benefits = await prisma.benefits.upsert({
     *   create: {
     *     // ... data to create a Benefits
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Benefits we want to update
     *   }
     * })
    **/
    upsert<T extends BenefitsUpsertArgs<ExtArgs>>(
      args: SelectSubset<T, BenefitsUpsertArgs<ExtArgs>>
    ): Prisma__BenefitsClient<$Result.GetResult<Prisma.$BenefitsPayload<ExtArgs>, T, 'upsert'>, never, ExtArgs>

    /**
     * Count the number of Benefits.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {BenefitsCountArgs} args - Arguments to filter Benefits to count.
     * @example
     * // Count the number of Benefits
     * const count = await prisma.benefits.count({
     *   where: {
     *     // ... the filter for the Benefits we want to count
     *   }
     * })
    **/
    count<T extends BenefitsCountArgs>(
      args?: Subset<T, BenefitsCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], BenefitsCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Benefits.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {BenefitsAggregateArgs} 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 BenefitsAggregateArgs>(args: Subset<T, BenefitsAggregateArgs>): Prisma.PrismaPromise<GetBenefitsAggregateType<T>>

    /**
     * Group by Benefits.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {BenefitsGroupByArgs} 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 BenefitsGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: BenefitsGroupByArgs['orderBy'] }
        : { orderBy?: BenefitsGroupByArgs['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, BenefitsGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetBenefitsGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Benefits model
   */
  readonly fields: BenefitsFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Benefits.
   * 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__BenefitsClient<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 Benefits model
   */ 
  interface BenefitsFieldRefs {
    readonly id: FieldRef<"Benefits", 'Int'>
    readonly benefits: FieldRef<"Benefits", 'String'>
    readonly advantages: FieldRef<"Benefits", 'String'>
  }
    

  // Custom InputTypes

  /**
   * Benefits findUnique
   */
  export type BenefitsFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Benefits
     */
    select?: BenefitsSelect<ExtArgs> | null
    /**
     * Filter, which Benefits to fetch.
     */
    where: BenefitsWhereUniqueInput
  }


  /**
   * Benefits findUniqueOrThrow
   */
  export type BenefitsFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Benefits
     */
    select?: BenefitsSelect<ExtArgs> | null
    /**
     * Filter, which Benefits to fetch.
     */
    where: BenefitsWhereUniqueInput
  }


  /**
   * Benefits findFirst
   */
  export type BenefitsFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Benefits
     */
    select?: BenefitsSelect<ExtArgs> | null
    /**
     * Filter, which Benefits to fetch.
     */
    where?: BenefitsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Benefits to fetch.
     */
    orderBy?: BenefitsOrderByWithRelationInput | BenefitsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Benefits.
     */
    cursor?: BenefitsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Benefits from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Benefits.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Benefits.
     */
    distinct?: BenefitsScalarFieldEnum | BenefitsScalarFieldEnum[]
  }


  /**
   * Benefits findFirstOrThrow
   */
  export type BenefitsFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Benefits
     */
    select?: BenefitsSelect<ExtArgs> | null
    /**
     * Filter, which Benefits to fetch.
     */
    where?: BenefitsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Benefits to fetch.
     */
    orderBy?: BenefitsOrderByWithRelationInput | BenefitsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Benefits.
     */
    cursor?: BenefitsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Benefits from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Benefits.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Benefits.
     */
    distinct?: BenefitsScalarFieldEnum | BenefitsScalarFieldEnum[]
  }


  /**
   * Benefits findMany
   */
  export type BenefitsFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Benefits
     */
    select?: BenefitsSelect<ExtArgs> | null
    /**
     * Filter, which Benefits to fetch.
     */
    where?: BenefitsWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Benefits to fetch.
     */
    orderBy?: BenefitsOrderByWithRelationInput | BenefitsOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Benefits.
     */
    cursor?: BenefitsWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Benefits from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Benefits.
     */
    skip?: number
    distinct?: BenefitsScalarFieldEnum | BenefitsScalarFieldEnum[]
  }


  /**
   * Benefits create
   */
  export type BenefitsCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Benefits
     */
    select?: BenefitsSelect<ExtArgs> | null
    /**
     * The data needed to create a Benefits.
     */
    data: XOR<BenefitsCreateInput, BenefitsUncheckedCreateInput>
  }


  /**
   * Benefits createMany
   */
  export type BenefitsCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Benefits.
     */
    data: BenefitsCreateManyInput | BenefitsCreateManyInput[]
    skipDuplicates?: boolean
  }


  /**
   * Benefits update
   */
  export type BenefitsUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Benefits
     */
    select?: BenefitsSelect<ExtArgs> | null
    /**
     * The data needed to update a Benefits.
     */
    data: XOR<BenefitsUpdateInput, BenefitsUncheckedUpdateInput>
    /**
     * Choose, which Benefits to update.
     */
    where: BenefitsWhereUniqueInput
  }


  /**
   * Benefits updateMany
   */
  export type BenefitsUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Benefits.
     */
    data: XOR<BenefitsUpdateManyMutationInput, BenefitsUncheckedUpdateManyInput>
    /**
     * Filter which Benefits to update
     */
    where?: BenefitsWhereInput
  }


  /**
   * Benefits upsert
   */
  export type BenefitsUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Benefits
     */
    select?: BenefitsSelect<ExtArgs> | null
    /**
     * The filter to search for the Benefits to update in case it exists.
     */
    where: BenefitsWhereUniqueInput
    /**
     * In case the Benefits found by the `where` argument doesn't exist, create a new Benefits with this data.
     */
    create: XOR<BenefitsCreateInput, BenefitsUncheckedCreateInput>
    /**
     * In case the Benefits was found with the provided `where` argument, update it with this data.
     */
    update: XOR<BenefitsUpdateInput, BenefitsUncheckedUpdateInput>
  }


  /**
   * Benefits delete
   */
  export type BenefitsDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Benefits
     */
    select?: BenefitsSelect<ExtArgs> | null
    /**
     * Filter which Benefits to delete.
     */
    where: BenefitsWhereUniqueInput
  }


  /**
   * Benefits deleteMany
   */
  export type BenefitsDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Benefits to delete
     */
    where?: BenefitsWhereInput
  }


  /**
   * Benefits without action
   */
  export type BenefitsDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Benefits
     */
    select?: BenefitsSelect<ExtArgs> | null
  }



  /**
   * Model PhotoAlbum
   */

  export type AggregatePhotoAlbum = {
    _count: PhotoAlbumCountAggregateOutputType | null
    _avg: PhotoAlbumAvgAggregateOutputType | null
    _sum: PhotoAlbumSumAggregateOutputType | null
    _min: PhotoAlbumMinAggregateOutputType | null
    _max: PhotoAlbumMaxAggregateOutputType | null
  }

  export type PhotoAlbumAvgAggregateOutputType = {
    id: number | null
  }

  export type PhotoAlbumSumAggregateOutputType = {
    id: number | null
  }

  export type PhotoAlbumMinAggregateOutputType = {
    id: number | null
    title: string | null
  }

  export type PhotoAlbumMaxAggregateOutputType = {
    id: number | null
    title: string | null
  }

  export type PhotoAlbumCountAggregateOutputType = {
    id: number
    title: number
    _all: number
  }


  export type PhotoAlbumAvgAggregateInputType = {
    id?: true
  }

  export type PhotoAlbumSumAggregateInputType = {
    id?: true
  }

  export type PhotoAlbumMinAggregateInputType = {
    id?: true
    title?: true
  }

  export type PhotoAlbumMaxAggregateInputType = {
    id?: true
    title?: true
  }

  export type PhotoAlbumCountAggregateInputType = {
    id?: true
    title?: true
    _all?: true
  }

  export type PhotoAlbumAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which PhotoAlbum to aggregate.
     */
    where?: PhotoAlbumWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PhotoAlbums to fetch.
     */
    orderBy?: PhotoAlbumOrderByWithRelationInput | PhotoAlbumOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: PhotoAlbumWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PhotoAlbums from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` PhotoAlbums.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned PhotoAlbums
    **/
    _count?: true | PhotoAlbumCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: PhotoAlbumAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: PhotoAlbumSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: PhotoAlbumMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: PhotoAlbumMaxAggregateInputType
  }

  export type GetPhotoAlbumAggregateType<T extends PhotoAlbumAggregateArgs> = {
        [P in keyof T & keyof AggregatePhotoAlbum]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregatePhotoAlbum[P]>
      : GetScalarType<T[P], AggregatePhotoAlbum[P]>
  }




  export type PhotoAlbumGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PhotoAlbumWhereInput
    orderBy?: PhotoAlbumOrderByWithAggregationInput | PhotoAlbumOrderByWithAggregationInput[]
    by: PhotoAlbumScalarFieldEnum[] | PhotoAlbumScalarFieldEnum
    having?: PhotoAlbumScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: PhotoAlbumCountAggregateInputType | true
    _avg?: PhotoAlbumAvgAggregateInputType
    _sum?: PhotoAlbumSumAggregateInputType
    _min?: PhotoAlbumMinAggregateInputType
    _max?: PhotoAlbumMaxAggregateInputType
  }

  export type PhotoAlbumGroupByOutputType = {
    id: number
    title: string
    _count: PhotoAlbumCountAggregateOutputType | null
    _avg: PhotoAlbumAvgAggregateOutputType | null
    _sum: PhotoAlbumSumAggregateOutputType | null
    _min: PhotoAlbumMinAggregateOutputType | null
    _max: PhotoAlbumMaxAggregateOutputType | null
  }

  type GetPhotoAlbumGroupByPayload<T extends PhotoAlbumGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<PhotoAlbumGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof PhotoAlbumGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], PhotoAlbumGroupByOutputType[P]>
            : GetScalarType<T[P], PhotoAlbumGroupByOutputType[P]>
        }
      >
    >


  export type PhotoAlbumSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    photos?: boolean | PhotoAlbum$photosArgs<ExtArgs>
    _count?: boolean | PhotoAlbumCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["photoAlbum"]>

  export type PhotoAlbumSelectScalar = {
    id?: boolean
    title?: boolean
  }

  export type PhotoAlbumInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    photos?: boolean | PhotoAlbum$photosArgs<ExtArgs>
    _count?: boolean | PhotoAlbumCountOutputTypeDefaultArgs<ExtArgs>
  }


  export type $PhotoAlbumPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "PhotoAlbum"
    objects: {
      photos: Prisma.$GalleryPhotoPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      title: string
    }, ExtArgs["result"]["photoAlbum"]>
    composites: {}
  }


  type PhotoAlbumGetPayload<S extends boolean | null | undefined | PhotoAlbumDefaultArgs> = $Result.GetResult<Prisma.$PhotoAlbumPayload, S>

  type PhotoAlbumCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<PhotoAlbumFindManyArgs, 'select' | 'include'> & {
      select?: PhotoAlbumCountAggregateInputType | true
    }

  export interface PhotoAlbumDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['PhotoAlbum'], meta: { name: 'PhotoAlbum' } }
    /**
     * Find zero or one PhotoAlbum that matches the filter.
     * @param {PhotoAlbumFindUniqueArgs} args - Arguments to find a PhotoAlbum
     * @example
     * // Get one PhotoAlbum
     * const photoAlbum = await prisma.photoAlbum.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends PhotoAlbumFindUniqueArgs<ExtArgs>>(
      args: SelectSubset<T, PhotoAlbumFindUniqueArgs<ExtArgs>>
    ): Prisma__PhotoAlbumClient<$Result.GetResult<Prisma.$PhotoAlbumPayload<ExtArgs>, T, 'findUnique'> | null, null, ExtArgs>

    /**
     * Find one PhotoAlbum that matches the filter or throw an error  with `error.code='P2025'` 
     *     if no matches were found.
     * @param {PhotoAlbumFindUniqueOrThrowArgs} args - Arguments to find a PhotoAlbum
     * @example
     * // Get one PhotoAlbum
     * const photoAlbum = await prisma.photoAlbum.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUniqueOrThrow<T extends PhotoAlbumFindUniqueOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, PhotoAlbumFindUniqueOrThrowArgs<ExtArgs>>
    ): Prisma__PhotoAlbumClient<$Result.GetResult<Prisma.$PhotoAlbumPayload<ExtArgs>, T, 'findUniqueOrThrow'>, never, ExtArgs>

    /**
     * Find the first PhotoAlbum 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 {PhotoAlbumFindFirstArgs} args - Arguments to find a PhotoAlbum
     * @example
     * // Get one PhotoAlbum
     * const photoAlbum = await prisma.photoAlbum.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends PhotoAlbumFindFirstArgs<ExtArgs>>(
      args?: SelectSubset<T, PhotoAlbumFindFirstArgs<ExtArgs>>
    ): Prisma__PhotoAlbumClient<$Result.GetResult<Prisma.$PhotoAlbumPayload<ExtArgs>, T, 'findFirst'> | null, null, ExtArgs>

    /**
     * Find the first PhotoAlbum 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 {PhotoAlbumFindFirstOrThrowArgs} args - Arguments to find a PhotoAlbum
     * @example
     * // Get one PhotoAlbum
     * const photoAlbum = await prisma.photoAlbum.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirstOrThrow<T extends PhotoAlbumFindFirstOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, PhotoAlbumFindFirstOrThrowArgs<ExtArgs>>
    ): Prisma__PhotoAlbumClient<$Result.GetResult<Prisma.$PhotoAlbumPayload<ExtArgs>, T, 'findFirstOrThrow'>, never, ExtArgs>

    /**
     * Find zero or more PhotoAlbums 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 {PhotoAlbumFindManyArgs=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all PhotoAlbums
     * const photoAlbums = await prisma.photoAlbum.findMany()
     * 
     * // Get first 10 PhotoAlbums
     * const photoAlbums = await prisma.photoAlbum.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const photoAlbumWithIdOnly = await prisma.photoAlbum.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends PhotoAlbumFindManyArgs<ExtArgs>>(
      args?: SelectSubset<T, PhotoAlbumFindManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PhotoAlbumPayload<ExtArgs>, T, 'findMany'>>

    /**
     * Create a PhotoAlbum.
     * @param {PhotoAlbumCreateArgs} args - Arguments to create a PhotoAlbum.
     * @example
     * // Create one PhotoAlbum
     * const PhotoAlbum = await prisma.photoAlbum.create({
     *   data: {
     *     // ... data to create a PhotoAlbum
     *   }
     * })
     * 
    **/
    create<T extends PhotoAlbumCreateArgs<ExtArgs>>(
      args: SelectSubset<T, PhotoAlbumCreateArgs<ExtArgs>>
    ): Prisma__PhotoAlbumClient<$Result.GetResult<Prisma.$PhotoAlbumPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

    /**
     * Create many PhotoAlbums.
     *     @param {PhotoAlbumCreateManyArgs} args - Arguments to create many PhotoAlbums.
     *     @example
     *     // Create many PhotoAlbums
     *     const photoAlbum = await prisma.photoAlbum.createMany({
     *       data: {
     *         // ... provide data here
     *       }
     *     })
     *     
    **/
    createMany<T extends PhotoAlbumCreateManyArgs<ExtArgs>>(
      args?: SelectSubset<T, PhotoAlbumCreateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a PhotoAlbum.
     * @param {PhotoAlbumDeleteArgs} args - Arguments to delete one PhotoAlbum.
     * @example
     * // Delete one PhotoAlbum
     * const PhotoAlbum = await prisma.photoAlbum.delete({
     *   where: {
     *     // ... filter to delete one PhotoAlbum
     *   }
     * })
     * 
    **/
    delete<T extends PhotoAlbumDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, PhotoAlbumDeleteArgs<ExtArgs>>
    ): Prisma__PhotoAlbumClient<$Result.GetResult<Prisma.$PhotoAlbumPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one PhotoAlbum.
     * @param {PhotoAlbumUpdateArgs} args - Arguments to update one PhotoAlbum.
     * @example
     * // Update one PhotoAlbum
     * const photoAlbum = await prisma.photoAlbum.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends PhotoAlbumUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, PhotoAlbumUpdateArgs<ExtArgs>>
    ): Prisma__PhotoAlbumClient<$Result.GetResult<Prisma.$PhotoAlbumPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

    /**
     * Delete zero or more PhotoAlbums.
     * @param {PhotoAlbumDeleteManyArgs} args - Arguments to filter PhotoAlbums to delete.
     * @example
     * // Delete a few PhotoAlbums
     * const { count } = await prisma.photoAlbum.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends PhotoAlbumDeleteManyArgs<ExtArgs>>(
      args?: SelectSubset<T, PhotoAlbumDeleteManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more PhotoAlbums.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PhotoAlbumUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many PhotoAlbums
     * const photoAlbum = await prisma.photoAlbum.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends PhotoAlbumUpdateManyArgs<ExtArgs>>(
      args: SelectSubset<T, PhotoAlbumUpdateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one PhotoAlbum.
     * @param {PhotoAlbumUpsertArgs} args - Arguments to update or create a PhotoAlbum.
     * @example
     * // Update or create a PhotoAlbum
     * const photoAlbum = await prisma.photoAlbum.upsert({
     *   create: {
     *     // ... data to create a PhotoAlbum
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the PhotoAlbum we want to update
     *   }
     * })
    **/
    upsert<T extends PhotoAlbumUpsertArgs<ExtArgs>>(
      args: SelectSubset<T, PhotoAlbumUpsertArgs<ExtArgs>>
    ): Prisma__PhotoAlbumClient<$Result.GetResult<Prisma.$PhotoAlbumPayload<ExtArgs>, T, 'upsert'>, never, ExtArgs>

    /**
     * Count the number of PhotoAlbums.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PhotoAlbumCountArgs} args - Arguments to filter PhotoAlbums to count.
     * @example
     * // Count the number of PhotoAlbums
     * const count = await prisma.photoAlbum.count({
     *   where: {
     *     // ... the filter for the PhotoAlbums we want to count
     *   }
     * })
    **/
    count<T extends PhotoAlbumCountArgs>(
      args?: Subset<T, PhotoAlbumCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], PhotoAlbumCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a PhotoAlbum.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PhotoAlbumAggregateArgs} 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 PhotoAlbumAggregateArgs>(args: Subset<T, PhotoAlbumAggregateArgs>): Prisma.PrismaPromise<GetPhotoAlbumAggregateType<T>>

    /**
     * Group by PhotoAlbum.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {PhotoAlbumGroupByArgs} 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 PhotoAlbumGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: PhotoAlbumGroupByArgs['orderBy'] }
        : { orderBy?: PhotoAlbumGroupByArgs['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, PhotoAlbumGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetPhotoAlbumGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the PhotoAlbum model
   */
  readonly fields: PhotoAlbumFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for PhotoAlbum.
   * 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__PhotoAlbumClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: 'PrismaPromise';

    photos<T extends PhotoAlbum$photosArgs<ExtArgs> = {}>(args?: Subset<T, PhotoAlbum$photosArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$GalleryPhotoPayload<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 PhotoAlbum model
   */ 
  interface PhotoAlbumFieldRefs {
    readonly id: FieldRef<"PhotoAlbum", 'Int'>
    readonly title: FieldRef<"PhotoAlbum", 'String'>
  }
    

  // Custom InputTypes

  /**
   * PhotoAlbum findUnique
   */
  export type PhotoAlbumFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PhotoAlbum
     */
    select?: PhotoAlbumSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: PhotoAlbumInclude<ExtArgs> | null
    /**
     * Filter, which PhotoAlbum to fetch.
     */
    where: PhotoAlbumWhereUniqueInput
  }


  /**
   * PhotoAlbum findUniqueOrThrow
   */
  export type PhotoAlbumFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PhotoAlbum
     */
    select?: PhotoAlbumSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: PhotoAlbumInclude<ExtArgs> | null
    /**
     * Filter, which PhotoAlbum to fetch.
     */
    where: PhotoAlbumWhereUniqueInput
  }


  /**
   * PhotoAlbum findFirst
   */
  export type PhotoAlbumFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PhotoAlbum
     */
    select?: PhotoAlbumSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: PhotoAlbumInclude<ExtArgs> | null
    /**
     * Filter, which PhotoAlbum to fetch.
     */
    where?: PhotoAlbumWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PhotoAlbums to fetch.
     */
    orderBy?: PhotoAlbumOrderByWithRelationInput | PhotoAlbumOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for PhotoAlbums.
     */
    cursor?: PhotoAlbumWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PhotoAlbums from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` PhotoAlbums.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of PhotoAlbums.
     */
    distinct?: PhotoAlbumScalarFieldEnum | PhotoAlbumScalarFieldEnum[]
  }


  /**
   * PhotoAlbum findFirstOrThrow
   */
  export type PhotoAlbumFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PhotoAlbum
     */
    select?: PhotoAlbumSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: PhotoAlbumInclude<ExtArgs> | null
    /**
     * Filter, which PhotoAlbum to fetch.
     */
    where?: PhotoAlbumWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PhotoAlbums to fetch.
     */
    orderBy?: PhotoAlbumOrderByWithRelationInput | PhotoAlbumOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for PhotoAlbums.
     */
    cursor?: PhotoAlbumWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PhotoAlbums from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` PhotoAlbums.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of PhotoAlbums.
     */
    distinct?: PhotoAlbumScalarFieldEnum | PhotoAlbumScalarFieldEnum[]
  }


  /**
   * PhotoAlbum findMany
   */
  export type PhotoAlbumFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PhotoAlbum
     */
    select?: PhotoAlbumSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: PhotoAlbumInclude<ExtArgs> | null
    /**
     * Filter, which PhotoAlbums to fetch.
     */
    where?: PhotoAlbumWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PhotoAlbums to fetch.
     */
    orderBy?: PhotoAlbumOrderByWithRelationInput | PhotoAlbumOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing PhotoAlbums.
     */
    cursor?: PhotoAlbumWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PhotoAlbums from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` PhotoAlbums.
     */
    skip?: number
    distinct?: PhotoAlbumScalarFieldEnum | PhotoAlbumScalarFieldEnum[]
  }


  /**
   * PhotoAlbum create
   */
  export type PhotoAlbumCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PhotoAlbum
     */
    select?: PhotoAlbumSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: PhotoAlbumInclude<ExtArgs> | null
    /**
     * The data needed to create a PhotoAlbum.
     */
    data: XOR<PhotoAlbumCreateInput, PhotoAlbumUncheckedCreateInput>
  }


  /**
   * PhotoAlbum createMany
   */
  export type PhotoAlbumCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many PhotoAlbums.
     */
    data: PhotoAlbumCreateManyInput | PhotoAlbumCreateManyInput[]
    skipDuplicates?: boolean
  }


  /**
   * PhotoAlbum update
   */
  export type PhotoAlbumUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PhotoAlbum
     */
    select?: PhotoAlbumSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: PhotoAlbumInclude<ExtArgs> | null
    /**
     * The data needed to update a PhotoAlbum.
     */
    data: XOR<PhotoAlbumUpdateInput, PhotoAlbumUncheckedUpdateInput>
    /**
     * Choose, which PhotoAlbum to update.
     */
    where: PhotoAlbumWhereUniqueInput
  }


  /**
   * PhotoAlbum updateMany
   */
  export type PhotoAlbumUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update PhotoAlbums.
     */
    data: XOR<PhotoAlbumUpdateManyMutationInput, PhotoAlbumUncheckedUpdateManyInput>
    /**
     * Filter which PhotoAlbums to update
     */
    where?: PhotoAlbumWhereInput
  }


  /**
   * PhotoAlbum upsert
   */
  export type PhotoAlbumUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PhotoAlbum
     */
    select?: PhotoAlbumSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: PhotoAlbumInclude<ExtArgs> | null
    /**
     * The filter to search for the PhotoAlbum to update in case it exists.
     */
    where: PhotoAlbumWhereUniqueInput
    /**
     * In case the PhotoAlbum found by the `where` argument doesn't exist, create a new PhotoAlbum with this data.
     */
    create: XOR<PhotoAlbumCreateInput, PhotoAlbumUncheckedCreateInput>
    /**
     * In case the PhotoAlbum was found with the provided `where` argument, update it with this data.
     */
    update: XOR<PhotoAlbumUpdateInput, PhotoAlbumUncheckedUpdateInput>
  }


  /**
   * PhotoAlbum delete
   */
  export type PhotoAlbumDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PhotoAlbum
     */
    select?: PhotoAlbumSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: PhotoAlbumInclude<ExtArgs> | null
    /**
     * Filter which PhotoAlbum to delete.
     */
    where: PhotoAlbumWhereUniqueInput
  }


  /**
   * PhotoAlbum deleteMany
   */
  export type PhotoAlbumDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which PhotoAlbums to delete
     */
    where?: PhotoAlbumWhereInput
  }


  /**
   * PhotoAlbum.photos
   */
  export type PhotoAlbum$photosArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GalleryPhoto
     */
    select?: GalleryPhotoSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: GalleryPhotoInclude<ExtArgs> | null
    where?: GalleryPhotoWhereInput
    orderBy?: GalleryPhotoOrderByWithRelationInput | GalleryPhotoOrderByWithRelationInput[]
    cursor?: GalleryPhotoWhereUniqueInput
    take?: number
    skip?: number
    distinct?: GalleryPhotoScalarFieldEnum | GalleryPhotoScalarFieldEnum[]
  }


  /**
   * PhotoAlbum without action
   */
  export type PhotoAlbumDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PhotoAlbum
     */
    select?: PhotoAlbumSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: PhotoAlbumInclude<ExtArgs> | null
  }



  /**
   * Model GalleryPhoto
   */

  export type AggregateGalleryPhoto = {
    _count: GalleryPhotoCountAggregateOutputType | null
    _avg: GalleryPhotoAvgAggregateOutputType | null
    _sum: GalleryPhotoSumAggregateOutputType | null
    _min: GalleryPhotoMinAggregateOutputType | null
    _max: GalleryPhotoMaxAggregateOutputType | null
  }

  export type GalleryPhotoAvgAggregateOutputType = {
    id: number | null
    PhotoAlbumId: number | null
  }

  export type GalleryPhotoSumAggregateOutputType = {
    id: number | null
    PhotoAlbumId: number | null
  }

  export type GalleryPhotoMinAggregateOutputType = {
    id: number | null
    image: string | null
    PhotoAlbumId: number | null
  }

  export type GalleryPhotoMaxAggregateOutputType = {
    id: number | null
    image: string | null
    PhotoAlbumId: number | null
  }

  export type GalleryPhotoCountAggregateOutputType = {
    id: number
    image: number
    PhotoAlbumId: number
    _all: number
  }


  export type GalleryPhotoAvgAggregateInputType = {
    id?: true
    PhotoAlbumId?: true
  }

  export type GalleryPhotoSumAggregateInputType = {
    id?: true
    PhotoAlbumId?: true
  }

  export type GalleryPhotoMinAggregateInputType = {
    id?: true
    image?: true
    PhotoAlbumId?: true
  }

  export type GalleryPhotoMaxAggregateInputType = {
    id?: true
    image?: true
    PhotoAlbumId?: true
  }

  export type GalleryPhotoCountAggregateInputType = {
    id?: true
    image?: true
    PhotoAlbumId?: true
    _all?: true
  }

  export type GalleryPhotoAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which GalleryPhoto to aggregate.
     */
    where?: GalleryPhotoWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of GalleryPhotos to fetch.
     */
    orderBy?: GalleryPhotoOrderByWithRelationInput | GalleryPhotoOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: GalleryPhotoWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` GalleryPhotos from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` GalleryPhotos.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned GalleryPhotos
    **/
    _count?: true | GalleryPhotoCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: GalleryPhotoAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: GalleryPhotoSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: GalleryPhotoMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: GalleryPhotoMaxAggregateInputType
  }

  export type GetGalleryPhotoAggregateType<T extends GalleryPhotoAggregateArgs> = {
        [P in keyof T & keyof AggregateGalleryPhoto]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateGalleryPhoto[P]>
      : GetScalarType<T[P], AggregateGalleryPhoto[P]>
  }




  export type GalleryPhotoGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: GalleryPhotoWhereInput
    orderBy?: GalleryPhotoOrderByWithAggregationInput | GalleryPhotoOrderByWithAggregationInput[]
    by: GalleryPhotoScalarFieldEnum[] | GalleryPhotoScalarFieldEnum
    having?: GalleryPhotoScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: GalleryPhotoCountAggregateInputType | true
    _avg?: GalleryPhotoAvgAggregateInputType
    _sum?: GalleryPhotoSumAggregateInputType
    _min?: GalleryPhotoMinAggregateInputType
    _max?: GalleryPhotoMaxAggregateInputType
  }

  export type GalleryPhotoGroupByOutputType = {
    id: number
    image: string
    PhotoAlbumId: number | null
    _count: GalleryPhotoCountAggregateOutputType | null
    _avg: GalleryPhotoAvgAggregateOutputType | null
    _sum: GalleryPhotoSumAggregateOutputType | null
    _min: GalleryPhotoMinAggregateOutputType | null
    _max: GalleryPhotoMaxAggregateOutputType | null
  }

  type GetGalleryPhotoGroupByPayload<T extends GalleryPhotoGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<GalleryPhotoGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof GalleryPhotoGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], GalleryPhotoGroupByOutputType[P]>
            : GetScalarType<T[P], GalleryPhotoGroupByOutputType[P]>
        }
      >
    >


  export type GalleryPhotoSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    image?: boolean
    PhotoAlbumId?: boolean
    album?: boolean | GalleryPhoto$albumArgs<ExtArgs>
  }, ExtArgs["result"]["galleryPhoto"]>

  export type GalleryPhotoSelectScalar = {
    id?: boolean
    image?: boolean
    PhotoAlbumId?: boolean
  }

  export type GalleryPhotoInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    album?: boolean | GalleryPhoto$albumArgs<ExtArgs>
  }


  export type $GalleryPhotoPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "GalleryPhoto"
    objects: {
      album: Prisma.$PhotoAlbumPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: number
      image: string
      PhotoAlbumId: number | null
    }, ExtArgs["result"]["galleryPhoto"]>
    composites: {}
  }


  type GalleryPhotoGetPayload<S extends boolean | null | undefined | GalleryPhotoDefaultArgs> = $Result.GetResult<Prisma.$GalleryPhotoPayload, S>

  type GalleryPhotoCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<GalleryPhotoFindManyArgs, 'select' | 'include'> & {
      select?: GalleryPhotoCountAggregateInputType | true
    }

  export interface GalleryPhotoDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['GalleryPhoto'], meta: { name: 'GalleryPhoto' } }
    /**
     * Find zero or one GalleryPhoto that matches the filter.
     * @param {GalleryPhotoFindUniqueArgs} args - Arguments to find a GalleryPhoto
     * @example
     * // Get one GalleryPhoto
     * const galleryPhoto = await prisma.galleryPhoto.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends GalleryPhotoFindUniqueArgs<ExtArgs>>(
      args: SelectSubset<T, GalleryPhotoFindUniqueArgs<ExtArgs>>
    ): Prisma__GalleryPhotoClient<$Result.GetResult<Prisma.$GalleryPhotoPayload<ExtArgs>, T, 'findUnique'> | null, null, ExtArgs>

    /**
     * Find one GalleryPhoto that matches the filter or throw an error  with `error.code='P2025'` 
     *     if no matches were found.
     * @param {GalleryPhotoFindUniqueOrThrowArgs} args - Arguments to find a GalleryPhoto
     * @example
     * // Get one GalleryPhoto
     * const galleryPhoto = await prisma.galleryPhoto.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUniqueOrThrow<T extends GalleryPhotoFindUniqueOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, GalleryPhotoFindUniqueOrThrowArgs<ExtArgs>>
    ): Prisma__GalleryPhotoClient<$Result.GetResult<Prisma.$GalleryPhotoPayload<ExtArgs>, T, 'findUniqueOrThrow'>, never, ExtArgs>

    /**
     * Find the first GalleryPhoto 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 {GalleryPhotoFindFirstArgs} args - Arguments to find a GalleryPhoto
     * @example
     * // Get one GalleryPhoto
     * const galleryPhoto = await prisma.galleryPhoto.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends GalleryPhotoFindFirstArgs<ExtArgs>>(
      args?: SelectSubset<T, GalleryPhotoFindFirstArgs<ExtArgs>>
    ): Prisma__GalleryPhotoClient<$Result.GetResult<Prisma.$GalleryPhotoPayload<ExtArgs>, T, 'findFirst'> | null, null, ExtArgs>

    /**
     * Find the first GalleryPhoto 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 {GalleryPhotoFindFirstOrThrowArgs} args - Arguments to find a GalleryPhoto
     * @example
     * // Get one GalleryPhoto
     * const galleryPhoto = await prisma.galleryPhoto.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirstOrThrow<T extends GalleryPhotoFindFirstOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, GalleryPhotoFindFirstOrThrowArgs<ExtArgs>>
    ): Prisma__GalleryPhotoClient<$Result.GetResult<Prisma.$GalleryPhotoPayload<ExtArgs>, T, 'findFirstOrThrow'>, never, ExtArgs>

    /**
     * Find zero or more GalleryPhotos 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 {GalleryPhotoFindManyArgs=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all GalleryPhotos
     * const galleryPhotos = await prisma.galleryPhoto.findMany()
     * 
     * // Get first 10 GalleryPhotos
     * const galleryPhotos = await prisma.galleryPhoto.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const galleryPhotoWithIdOnly = await prisma.galleryPhoto.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends GalleryPhotoFindManyArgs<ExtArgs>>(
      args?: SelectSubset<T, GalleryPhotoFindManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<$Result.GetResult<Prisma.$GalleryPhotoPayload<ExtArgs>, T, 'findMany'>>

    /**
     * Create a GalleryPhoto.
     * @param {GalleryPhotoCreateArgs} args - Arguments to create a GalleryPhoto.
     * @example
     * // Create one GalleryPhoto
     * const GalleryPhoto = await prisma.galleryPhoto.create({
     *   data: {
     *     // ... data to create a GalleryPhoto
     *   }
     * })
     * 
    **/
    create<T extends GalleryPhotoCreateArgs<ExtArgs>>(
      args: SelectSubset<T, GalleryPhotoCreateArgs<ExtArgs>>
    ): Prisma__GalleryPhotoClient<$Result.GetResult<Prisma.$GalleryPhotoPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

    /**
     * Create many GalleryPhotos.
     *     @param {GalleryPhotoCreateManyArgs} args - Arguments to create many GalleryPhotos.
     *     @example
     *     // Create many GalleryPhotos
     *     const galleryPhoto = await prisma.galleryPhoto.createMany({
     *       data: {
     *         // ... provide data here
     *       }
     *     })
     *     
    **/
    createMany<T extends GalleryPhotoCreateManyArgs<ExtArgs>>(
      args?: SelectSubset<T, GalleryPhotoCreateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a GalleryPhoto.
     * @param {GalleryPhotoDeleteArgs} args - Arguments to delete one GalleryPhoto.
     * @example
     * // Delete one GalleryPhoto
     * const GalleryPhoto = await prisma.galleryPhoto.delete({
     *   where: {
     *     // ... filter to delete one GalleryPhoto
     *   }
     * })
     * 
    **/
    delete<T extends GalleryPhotoDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, GalleryPhotoDeleteArgs<ExtArgs>>
    ): Prisma__GalleryPhotoClient<$Result.GetResult<Prisma.$GalleryPhotoPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one GalleryPhoto.
     * @param {GalleryPhotoUpdateArgs} args - Arguments to update one GalleryPhoto.
     * @example
     * // Update one GalleryPhoto
     * const galleryPhoto = await prisma.galleryPhoto.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends GalleryPhotoUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, GalleryPhotoUpdateArgs<ExtArgs>>
    ): Prisma__GalleryPhotoClient<$Result.GetResult<Prisma.$GalleryPhotoPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

    /**
     * Delete zero or more GalleryPhotos.
     * @param {GalleryPhotoDeleteManyArgs} args - Arguments to filter GalleryPhotos to delete.
     * @example
     * // Delete a few GalleryPhotos
     * const { count } = await prisma.galleryPhoto.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends GalleryPhotoDeleteManyArgs<ExtArgs>>(
      args?: SelectSubset<T, GalleryPhotoDeleteManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more GalleryPhotos.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GalleryPhotoUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many GalleryPhotos
     * const galleryPhoto = await prisma.galleryPhoto.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends GalleryPhotoUpdateManyArgs<ExtArgs>>(
      args: SelectSubset<T, GalleryPhotoUpdateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one GalleryPhoto.
     * @param {GalleryPhotoUpsertArgs} args - Arguments to update or create a GalleryPhoto.
     * @example
     * // Update or create a GalleryPhoto
     * const galleryPhoto = await prisma.galleryPhoto.upsert({
     *   create: {
     *     // ... data to create a GalleryPhoto
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the GalleryPhoto we want to update
     *   }
     * })
    **/
    upsert<T extends GalleryPhotoUpsertArgs<ExtArgs>>(
      args: SelectSubset<T, GalleryPhotoUpsertArgs<ExtArgs>>
    ): Prisma__GalleryPhotoClient<$Result.GetResult<Prisma.$GalleryPhotoPayload<ExtArgs>, T, 'upsert'>, never, ExtArgs>

    /**
     * Count the number of GalleryPhotos.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GalleryPhotoCountArgs} args - Arguments to filter GalleryPhotos to count.
     * @example
     * // Count the number of GalleryPhotos
     * const count = await prisma.galleryPhoto.count({
     *   where: {
     *     // ... the filter for the GalleryPhotos we want to count
     *   }
     * })
    **/
    count<T extends GalleryPhotoCountArgs>(
      args?: Subset<T, GalleryPhotoCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], GalleryPhotoCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a GalleryPhoto.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GalleryPhotoAggregateArgs} 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 GalleryPhotoAggregateArgs>(args: Subset<T, GalleryPhotoAggregateArgs>): Prisma.PrismaPromise<GetGalleryPhotoAggregateType<T>>

    /**
     * Group by GalleryPhoto.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GalleryPhotoGroupByArgs} 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 GalleryPhotoGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: GalleryPhotoGroupByArgs['orderBy'] }
        : { orderBy?: GalleryPhotoGroupByArgs['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, GalleryPhotoGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetGalleryPhotoGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the GalleryPhoto model
   */
  readonly fields: GalleryPhotoFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for GalleryPhoto.
   * 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__GalleryPhotoClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: 'PrismaPromise';

    album<T extends GalleryPhoto$albumArgs<ExtArgs> = {}>(args?: Subset<T, GalleryPhoto$albumArgs<ExtArgs>>): Prisma__PhotoAlbumClient<$Result.GetResult<Prisma.$PhotoAlbumPayload<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 GalleryPhoto model
   */ 
  interface GalleryPhotoFieldRefs {
    readonly id: FieldRef<"GalleryPhoto", 'Int'>
    readonly image: FieldRef<"GalleryPhoto", 'String'>
    readonly PhotoAlbumId: FieldRef<"GalleryPhoto", 'Int'>
  }
    

  // Custom InputTypes

  /**
   * GalleryPhoto findUnique
   */
  export type GalleryPhotoFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GalleryPhoto
     */
    select?: GalleryPhotoSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: GalleryPhotoInclude<ExtArgs> | null
    /**
     * Filter, which GalleryPhoto to fetch.
     */
    where: GalleryPhotoWhereUniqueInput
  }


  /**
   * GalleryPhoto findUniqueOrThrow
   */
  export type GalleryPhotoFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GalleryPhoto
     */
    select?: GalleryPhotoSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: GalleryPhotoInclude<ExtArgs> | null
    /**
     * Filter, which GalleryPhoto to fetch.
     */
    where: GalleryPhotoWhereUniqueInput
  }


  /**
   * GalleryPhoto findFirst
   */
  export type GalleryPhotoFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GalleryPhoto
     */
    select?: GalleryPhotoSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: GalleryPhotoInclude<ExtArgs> | null
    /**
     * Filter, which GalleryPhoto to fetch.
     */
    where?: GalleryPhotoWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of GalleryPhotos to fetch.
     */
    orderBy?: GalleryPhotoOrderByWithRelationInput | GalleryPhotoOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for GalleryPhotos.
     */
    cursor?: GalleryPhotoWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` GalleryPhotos from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` GalleryPhotos.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of GalleryPhotos.
     */
    distinct?: GalleryPhotoScalarFieldEnum | GalleryPhotoScalarFieldEnum[]
  }


  /**
   * GalleryPhoto findFirstOrThrow
   */
  export type GalleryPhotoFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GalleryPhoto
     */
    select?: GalleryPhotoSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: GalleryPhotoInclude<ExtArgs> | null
    /**
     * Filter, which GalleryPhoto to fetch.
     */
    where?: GalleryPhotoWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of GalleryPhotos to fetch.
     */
    orderBy?: GalleryPhotoOrderByWithRelationInput | GalleryPhotoOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for GalleryPhotos.
     */
    cursor?: GalleryPhotoWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` GalleryPhotos from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` GalleryPhotos.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of GalleryPhotos.
     */
    distinct?: GalleryPhotoScalarFieldEnum | GalleryPhotoScalarFieldEnum[]
  }


  /**
   * GalleryPhoto findMany
   */
  export type GalleryPhotoFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GalleryPhoto
     */
    select?: GalleryPhotoSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: GalleryPhotoInclude<ExtArgs> | null
    /**
     * Filter, which GalleryPhotos to fetch.
     */
    where?: GalleryPhotoWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of GalleryPhotos to fetch.
     */
    orderBy?: GalleryPhotoOrderByWithRelationInput | GalleryPhotoOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing GalleryPhotos.
     */
    cursor?: GalleryPhotoWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` GalleryPhotos from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` GalleryPhotos.
     */
    skip?: number
    distinct?: GalleryPhotoScalarFieldEnum | GalleryPhotoScalarFieldEnum[]
  }


  /**
   * GalleryPhoto create
   */
  export type GalleryPhotoCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GalleryPhoto
     */
    select?: GalleryPhotoSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: GalleryPhotoInclude<ExtArgs> | null
    /**
     * The data needed to create a GalleryPhoto.
     */
    data: XOR<GalleryPhotoCreateInput, GalleryPhotoUncheckedCreateInput>
  }


  /**
   * GalleryPhoto createMany
   */
  export type GalleryPhotoCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many GalleryPhotos.
     */
    data: GalleryPhotoCreateManyInput | GalleryPhotoCreateManyInput[]
    skipDuplicates?: boolean
  }


  /**
   * GalleryPhoto update
   */
  export type GalleryPhotoUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GalleryPhoto
     */
    select?: GalleryPhotoSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: GalleryPhotoInclude<ExtArgs> | null
    /**
     * The data needed to update a GalleryPhoto.
     */
    data: XOR<GalleryPhotoUpdateInput, GalleryPhotoUncheckedUpdateInput>
    /**
     * Choose, which GalleryPhoto to update.
     */
    where: GalleryPhotoWhereUniqueInput
  }


  /**
   * GalleryPhoto updateMany
   */
  export type GalleryPhotoUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update GalleryPhotos.
     */
    data: XOR<GalleryPhotoUpdateManyMutationInput, GalleryPhotoUncheckedUpdateManyInput>
    /**
     * Filter which GalleryPhotos to update
     */
    where?: GalleryPhotoWhereInput
  }


  /**
   * GalleryPhoto upsert
   */
  export type GalleryPhotoUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GalleryPhoto
     */
    select?: GalleryPhotoSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: GalleryPhotoInclude<ExtArgs> | null
    /**
     * The filter to search for the GalleryPhoto to update in case it exists.
     */
    where: GalleryPhotoWhereUniqueInput
    /**
     * In case the GalleryPhoto found by the `where` argument doesn't exist, create a new GalleryPhoto with this data.
     */
    create: XOR<GalleryPhotoCreateInput, GalleryPhotoUncheckedCreateInput>
    /**
     * In case the GalleryPhoto was found with the provided `where` argument, update it with this data.
     */
    update: XOR<GalleryPhotoUpdateInput, GalleryPhotoUncheckedUpdateInput>
  }


  /**
   * GalleryPhoto delete
   */
  export type GalleryPhotoDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GalleryPhoto
     */
    select?: GalleryPhotoSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: GalleryPhotoInclude<ExtArgs> | null
    /**
     * Filter which GalleryPhoto to delete.
     */
    where: GalleryPhotoWhereUniqueInput
  }


  /**
   * GalleryPhoto deleteMany
   */
  export type GalleryPhotoDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which GalleryPhotos to delete
     */
    where?: GalleryPhotoWhereInput
  }


  /**
   * GalleryPhoto.album
   */
  export type GalleryPhoto$albumArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PhotoAlbum
     */
    select?: PhotoAlbumSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: PhotoAlbumInclude<ExtArgs> | null
    where?: PhotoAlbumWhereInput
  }


  /**
   * GalleryPhoto without action
   */
  export type GalleryPhotoDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GalleryPhoto
     */
    select?: GalleryPhotoSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well.
     */
    include?: GalleryPhotoInclude<ExtArgs> | null
  }



  /**
   * Model GalleryVideo
   */

  export type AggregateGalleryVideo = {
    _count: GalleryVideoCountAggregateOutputType | null
    _avg: GalleryVideoAvgAggregateOutputType | null
    _sum: GalleryVideoSumAggregateOutputType | null
    _min: GalleryVideoMinAggregateOutputType | null
    _max: GalleryVideoMaxAggregateOutputType | null
  }

  export type GalleryVideoAvgAggregateOutputType = {
    id: number | null
  }

  export type GalleryVideoSumAggregateOutputType = {
    id: number | null
  }

  export type GalleryVideoMinAggregateOutputType = {
    id: number | null
    title: string | null
    link: string | null
  }

  export type GalleryVideoMaxAggregateOutputType = {
    id: number | null
    title: string | null
    link: string | null
  }

  export type GalleryVideoCountAggregateOutputType = {
    id: number
    title: number
    link: number
    _all: number
  }


  export type GalleryVideoAvgAggregateInputType = {
    id?: true
  }

  export type GalleryVideoSumAggregateInputType = {
    id?: true
  }

  export type GalleryVideoMinAggregateInputType = {
    id?: true
    title?: true
    link?: true
  }

  export type GalleryVideoMaxAggregateInputType = {
    id?: true
    title?: true
    link?: true
  }

  export type GalleryVideoCountAggregateInputType = {
    id?: true
    title?: true
    link?: true
    _all?: true
  }

  export type GalleryVideoAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which GalleryVideo to aggregate.
     */
    where?: GalleryVideoWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of GalleryVideos to fetch.
     */
    orderBy?: GalleryVideoOrderByWithRelationInput | GalleryVideoOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: GalleryVideoWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` GalleryVideos from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` GalleryVideos.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned GalleryVideos
    **/
    _count?: true | GalleryVideoCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: GalleryVideoAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: GalleryVideoSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: GalleryVideoMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: GalleryVideoMaxAggregateInputType
  }

  export type GetGalleryVideoAggregateType<T extends GalleryVideoAggregateArgs> = {
        [P in keyof T & keyof AggregateGalleryVideo]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateGalleryVideo[P]>
      : GetScalarType<T[P], AggregateGalleryVideo[P]>
  }




  export type GalleryVideoGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: GalleryVideoWhereInput
    orderBy?: GalleryVideoOrderByWithAggregationInput | GalleryVideoOrderByWithAggregationInput[]
    by: GalleryVideoScalarFieldEnum[] | GalleryVideoScalarFieldEnum
    having?: GalleryVideoScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: GalleryVideoCountAggregateInputType | true
    _avg?: GalleryVideoAvgAggregateInputType
    _sum?: GalleryVideoSumAggregateInputType
    _min?: GalleryVideoMinAggregateInputType
    _max?: GalleryVideoMaxAggregateInputType
  }

  export type GalleryVideoGroupByOutputType = {
    id: number
    title: string
    link: string
    _count: GalleryVideoCountAggregateOutputType | null
    _avg: GalleryVideoAvgAggregateOutputType | null
    _sum: GalleryVideoSumAggregateOutputType | null
    _min: GalleryVideoMinAggregateOutputType | null
    _max: GalleryVideoMaxAggregateOutputType | null
  }

  type GetGalleryVideoGroupByPayload<T extends GalleryVideoGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<GalleryVideoGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof GalleryVideoGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], GalleryVideoGroupByOutputType[P]>
            : GetScalarType<T[P], GalleryVideoGroupByOutputType[P]>
        }
      >
    >


  export type GalleryVideoSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    link?: boolean
  }, ExtArgs["result"]["galleryVideo"]>

  export type GalleryVideoSelectScalar = {
    id?: boolean
    title?: boolean
    link?: boolean
  }


  export type $GalleryVideoPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "GalleryVideo"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      title: string
      link: string
    }, ExtArgs["result"]["galleryVideo"]>
    composites: {}
  }


  type GalleryVideoGetPayload<S extends boolean | null | undefined | GalleryVideoDefaultArgs> = $Result.GetResult<Prisma.$GalleryVideoPayload, S>

  type GalleryVideoCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<GalleryVideoFindManyArgs, 'select' | 'include'> & {
      select?: GalleryVideoCountAggregateInputType | true
    }

  export interface GalleryVideoDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['GalleryVideo'], meta: { name: 'GalleryVideo' } }
    /**
     * Find zero or one GalleryVideo that matches the filter.
     * @param {GalleryVideoFindUniqueArgs} args - Arguments to find a GalleryVideo
     * @example
     * // Get one GalleryVideo
     * const galleryVideo = await prisma.galleryVideo.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends GalleryVideoFindUniqueArgs<ExtArgs>>(
      args: SelectSubset<T, GalleryVideoFindUniqueArgs<ExtArgs>>
    ): Prisma__GalleryVideoClient<$Result.GetResult<Prisma.$GalleryVideoPayload<ExtArgs>, T, 'findUnique'> | null, null, ExtArgs>

    /**
     * Find one GalleryVideo that matches the filter or throw an error  with `error.code='P2025'` 
     *     if no matches were found.
     * @param {GalleryVideoFindUniqueOrThrowArgs} args - Arguments to find a GalleryVideo
     * @example
     * // Get one GalleryVideo
     * const galleryVideo = await prisma.galleryVideo.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUniqueOrThrow<T extends GalleryVideoFindUniqueOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, GalleryVideoFindUniqueOrThrowArgs<ExtArgs>>
    ): Prisma__GalleryVideoClient<$Result.GetResult<Prisma.$GalleryVideoPayload<ExtArgs>, T, 'findUniqueOrThrow'>, never, ExtArgs>

    /**
     * Find the first GalleryVideo 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 {GalleryVideoFindFirstArgs} args - Arguments to find a GalleryVideo
     * @example
     * // Get one GalleryVideo
     * const galleryVideo = await prisma.galleryVideo.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends GalleryVideoFindFirstArgs<ExtArgs>>(
      args?: SelectSubset<T, GalleryVideoFindFirstArgs<ExtArgs>>
    ): Prisma__GalleryVideoClient<$Result.GetResult<Prisma.$GalleryVideoPayload<ExtArgs>, T, 'findFirst'> | null, null, ExtArgs>

    /**
     * Find the first GalleryVideo 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 {GalleryVideoFindFirstOrThrowArgs} args - Arguments to find a GalleryVideo
     * @example
     * // Get one GalleryVideo
     * const galleryVideo = await prisma.galleryVideo.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirstOrThrow<T extends GalleryVideoFindFirstOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, GalleryVideoFindFirstOrThrowArgs<ExtArgs>>
    ): Prisma__GalleryVideoClient<$Result.GetResult<Prisma.$GalleryVideoPayload<ExtArgs>, T, 'findFirstOrThrow'>, never, ExtArgs>

    /**
     * Find zero or more GalleryVideos 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 {GalleryVideoFindManyArgs=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all GalleryVideos
     * const galleryVideos = await prisma.galleryVideo.findMany()
     * 
     * // Get first 10 GalleryVideos
     * const galleryVideos = await prisma.galleryVideo.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const galleryVideoWithIdOnly = await prisma.galleryVideo.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends GalleryVideoFindManyArgs<ExtArgs>>(
      args?: SelectSubset<T, GalleryVideoFindManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<$Result.GetResult<Prisma.$GalleryVideoPayload<ExtArgs>, T, 'findMany'>>

    /**
     * Create a GalleryVideo.
     * @param {GalleryVideoCreateArgs} args - Arguments to create a GalleryVideo.
     * @example
     * // Create one GalleryVideo
     * const GalleryVideo = await prisma.galleryVideo.create({
     *   data: {
     *     // ... data to create a GalleryVideo
     *   }
     * })
     * 
    **/
    create<T extends GalleryVideoCreateArgs<ExtArgs>>(
      args: SelectSubset<T, GalleryVideoCreateArgs<ExtArgs>>
    ): Prisma__GalleryVideoClient<$Result.GetResult<Prisma.$GalleryVideoPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

    /**
     * Create many GalleryVideos.
     *     @param {GalleryVideoCreateManyArgs} args - Arguments to create many GalleryVideos.
     *     @example
     *     // Create many GalleryVideos
     *     const galleryVideo = await prisma.galleryVideo.createMany({
     *       data: {
     *         // ... provide data here
     *       }
     *     })
     *     
    **/
    createMany<T extends GalleryVideoCreateManyArgs<ExtArgs>>(
      args?: SelectSubset<T, GalleryVideoCreateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a GalleryVideo.
     * @param {GalleryVideoDeleteArgs} args - Arguments to delete one GalleryVideo.
     * @example
     * // Delete one GalleryVideo
     * const GalleryVideo = await prisma.galleryVideo.delete({
     *   where: {
     *     // ... filter to delete one GalleryVideo
     *   }
     * })
     * 
    **/
    delete<T extends GalleryVideoDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, GalleryVideoDeleteArgs<ExtArgs>>
    ): Prisma__GalleryVideoClient<$Result.GetResult<Prisma.$GalleryVideoPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one GalleryVideo.
     * @param {GalleryVideoUpdateArgs} args - Arguments to update one GalleryVideo.
     * @example
     * // Update one GalleryVideo
     * const galleryVideo = await prisma.galleryVideo.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends GalleryVideoUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, GalleryVideoUpdateArgs<ExtArgs>>
    ): Prisma__GalleryVideoClient<$Result.GetResult<Prisma.$GalleryVideoPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

    /**
     * Delete zero or more GalleryVideos.
     * @param {GalleryVideoDeleteManyArgs} args - Arguments to filter GalleryVideos to delete.
     * @example
     * // Delete a few GalleryVideos
     * const { count } = await prisma.galleryVideo.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends GalleryVideoDeleteManyArgs<ExtArgs>>(
      args?: SelectSubset<T, GalleryVideoDeleteManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more GalleryVideos.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GalleryVideoUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many GalleryVideos
     * const galleryVideo = await prisma.galleryVideo.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends GalleryVideoUpdateManyArgs<ExtArgs>>(
      args: SelectSubset<T, GalleryVideoUpdateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one GalleryVideo.
     * @param {GalleryVideoUpsertArgs} args - Arguments to update or create a GalleryVideo.
     * @example
     * // Update or create a GalleryVideo
     * const galleryVideo = await prisma.galleryVideo.upsert({
     *   create: {
     *     // ... data to create a GalleryVideo
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the GalleryVideo we want to update
     *   }
     * })
    **/
    upsert<T extends GalleryVideoUpsertArgs<ExtArgs>>(
      args: SelectSubset<T, GalleryVideoUpsertArgs<ExtArgs>>
    ): Prisma__GalleryVideoClient<$Result.GetResult<Prisma.$GalleryVideoPayload<ExtArgs>, T, 'upsert'>, never, ExtArgs>

    /**
     * Count the number of GalleryVideos.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GalleryVideoCountArgs} args - Arguments to filter GalleryVideos to count.
     * @example
     * // Count the number of GalleryVideos
     * const count = await prisma.galleryVideo.count({
     *   where: {
     *     // ... the filter for the GalleryVideos we want to count
     *   }
     * })
    **/
    count<T extends GalleryVideoCountArgs>(
      args?: Subset<T, GalleryVideoCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], GalleryVideoCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a GalleryVideo.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GalleryVideoAggregateArgs} 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 GalleryVideoAggregateArgs>(args: Subset<T, GalleryVideoAggregateArgs>): Prisma.PrismaPromise<GetGalleryVideoAggregateType<T>>

    /**
     * Group by GalleryVideo.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {GalleryVideoGroupByArgs} 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 GalleryVideoGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: GalleryVideoGroupByArgs['orderBy'] }
        : { orderBy?: GalleryVideoGroupByArgs['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, GalleryVideoGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetGalleryVideoGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the GalleryVideo model
   */
  readonly fields: GalleryVideoFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for GalleryVideo.
   * 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__GalleryVideoClient<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 GalleryVideo model
   */ 
  interface GalleryVideoFieldRefs {
    readonly id: FieldRef<"GalleryVideo", 'Int'>
    readonly title: FieldRef<"GalleryVideo", 'String'>
    readonly link: FieldRef<"GalleryVideo", 'String'>
  }
    

  // Custom InputTypes

  /**
   * GalleryVideo findUnique
   */
  export type GalleryVideoFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GalleryVideo
     */
    select?: GalleryVideoSelect<ExtArgs> | null
    /**
     * Filter, which GalleryVideo to fetch.
     */
    where: GalleryVideoWhereUniqueInput
  }


  /**
   * GalleryVideo findUniqueOrThrow
   */
  export type GalleryVideoFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GalleryVideo
     */
    select?: GalleryVideoSelect<ExtArgs> | null
    /**
     * Filter, which GalleryVideo to fetch.
     */
    where: GalleryVideoWhereUniqueInput
  }


  /**
   * GalleryVideo findFirst
   */
  export type GalleryVideoFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GalleryVideo
     */
    select?: GalleryVideoSelect<ExtArgs> | null
    /**
     * Filter, which GalleryVideo to fetch.
     */
    where?: GalleryVideoWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of GalleryVideos to fetch.
     */
    orderBy?: GalleryVideoOrderByWithRelationInput | GalleryVideoOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for GalleryVideos.
     */
    cursor?: GalleryVideoWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` GalleryVideos from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` GalleryVideos.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of GalleryVideos.
     */
    distinct?: GalleryVideoScalarFieldEnum | GalleryVideoScalarFieldEnum[]
  }


  /**
   * GalleryVideo findFirstOrThrow
   */
  export type GalleryVideoFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GalleryVideo
     */
    select?: GalleryVideoSelect<ExtArgs> | null
    /**
     * Filter, which GalleryVideo to fetch.
     */
    where?: GalleryVideoWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of GalleryVideos to fetch.
     */
    orderBy?: GalleryVideoOrderByWithRelationInput | GalleryVideoOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for GalleryVideos.
     */
    cursor?: GalleryVideoWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` GalleryVideos from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` GalleryVideos.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of GalleryVideos.
     */
    distinct?: GalleryVideoScalarFieldEnum | GalleryVideoScalarFieldEnum[]
  }


  /**
   * GalleryVideo findMany
   */
  export type GalleryVideoFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GalleryVideo
     */
    select?: GalleryVideoSelect<ExtArgs> | null
    /**
     * Filter, which GalleryVideos to fetch.
     */
    where?: GalleryVideoWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of GalleryVideos to fetch.
     */
    orderBy?: GalleryVideoOrderByWithRelationInput | GalleryVideoOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing GalleryVideos.
     */
    cursor?: GalleryVideoWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` GalleryVideos from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` GalleryVideos.
     */
    skip?: number
    distinct?: GalleryVideoScalarFieldEnum | GalleryVideoScalarFieldEnum[]
  }


  /**
   * GalleryVideo create
   */
  export type GalleryVideoCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GalleryVideo
     */
    select?: GalleryVideoSelect<ExtArgs> | null
    /**
     * The data needed to create a GalleryVideo.
     */
    data: XOR<GalleryVideoCreateInput, GalleryVideoUncheckedCreateInput>
  }


  /**
   * GalleryVideo createMany
   */
  export type GalleryVideoCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many GalleryVideos.
     */
    data: GalleryVideoCreateManyInput | GalleryVideoCreateManyInput[]
    skipDuplicates?: boolean
  }


  /**
   * GalleryVideo update
   */
  export type GalleryVideoUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GalleryVideo
     */
    select?: GalleryVideoSelect<ExtArgs> | null
    /**
     * The data needed to update a GalleryVideo.
     */
    data: XOR<GalleryVideoUpdateInput, GalleryVideoUncheckedUpdateInput>
    /**
     * Choose, which GalleryVideo to update.
     */
    where: GalleryVideoWhereUniqueInput
  }


  /**
   * GalleryVideo updateMany
   */
  export type GalleryVideoUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update GalleryVideos.
     */
    data: XOR<GalleryVideoUpdateManyMutationInput, GalleryVideoUncheckedUpdateManyInput>
    /**
     * Filter which GalleryVideos to update
     */
    where?: GalleryVideoWhereInput
  }


  /**
   * GalleryVideo upsert
   */
  export type GalleryVideoUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GalleryVideo
     */
    select?: GalleryVideoSelect<ExtArgs> | null
    /**
     * The filter to search for the GalleryVideo to update in case it exists.
     */
    where: GalleryVideoWhereUniqueInput
    /**
     * In case the GalleryVideo found by the `where` argument doesn't exist, create a new GalleryVideo with this data.
     */
    create: XOR<GalleryVideoCreateInput, GalleryVideoUncheckedCreateInput>
    /**
     * In case the GalleryVideo was found with the provided `where` argument, update it with this data.
     */
    update: XOR<GalleryVideoUpdateInput, GalleryVideoUncheckedUpdateInput>
  }


  /**
   * GalleryVideo delete
   */
  export type GalleryVideoDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GalleryVideo
     */
    select?: GalleryVideoSelect<ExtArgs> | null
    /**
     * Filter which GalleryVideo to delete.
     */
    where: GalleryVideoWhereUniqueInput
  }


  /**
   * GalleryVideo deleteMany
   */
  export type GalleryVideoDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which GalleryVideos to delete
     */
    where?: GalleryVideoWhereInput
  }


  /**
   * GalleryVideo without action
   */
  export type GalleryVideoDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GalleryVideo
     */
    select?: GalleryVideoSelect<ExtArgs> | null
  }



  /**
   * Model Condolence
   */

  export type AggregateCondolence = {
    _count: CondolenceCountAggregateOutputType | null
    _avg: CondolenceAvgAggregateOutputType | null
    _sum: CondolenceSumAggregateOutputType | null
    _min: CondolenceMinAggregateOutputType | null
    _max: CondolenceMaxAggregateOutputType | null
  }

  export type CondolenceAvgAggregateOutputType = {
    id: number | null
  }

  export type CondolenceSumAggregateOutputType = {
    id: number | null
  }

  export type CondolenceMinAggregateOutputType = {
    id: number | null
    name: string | null
    position: string | null
    period: string | null
    featured: boolean | null
    image: string | null
    text: string | null
  }

  export type CondolenceMaxAggregateOutputType = {
    id: number | null
    name: string | null
    position: string | null
    period: string | null
    featured: boolean | null
    image: string | null
    text: string | null
  }

  export type CondolenceCountAggregateOutputType = {
    id: number
    name: number
    position: number
    period: number
    featured: number
    image: number
    text: number
    _all: number
  }


  export type CondolenceAvgAggregateInputType = {
    id?: true
  }

  export type CondolenceSumAggregateInputType = {
    id?: true
  }

  export type CondolenceMinAggregateInputType = {
    id?: true
    name?: true
    position?: true
    period?: true
    featured?: true
    image?: true
    text?: true
  }

  export type CondolenceMaxAggregateInputType = {
    id?: true
    name?: true
    position?: true
    period?: true
    featured?: true
    image?: true
    text?: true
  }

  export type CondolenceCountAggregateInputType = {
    id?: true
    name?: true
    position?: true
    period?: true
    featured?: true
    image?: true
    text?: true
    _all?: true
  }

  export type CondolenceAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Condolence to aggregate.
     */
    where?: CondolenceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Condolences to fetch.
     */
    orderBy?: CondolenceOrderByWithRelationInput | CondolenceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: CondolenceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Condolences from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Condolences.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Condolences
    **/
    _count?: true | CondolenceCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: CondolenceAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: CondolenceSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: CondolenceMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: CondolenceMaxAggregateInputType
  }

  export type GetCondolenceAggregateType<T extends CondolenceAggregateArgs> = {
        [P in keyof T & keyof AggregateCondolence]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateCondolence[P]>
      : GetScalarType<T[P], AggregateCondolence[P]>
  }




  export type CondolenceGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CondolenceWhereInput
    orderBy?: CondolenceOrderByWithAggregationInput | CondolenceOrderByWithAggregationInput[]
    by: CondolenceScalarFieldEnum[] | CondolenceScalarFieldEnum
    having?: CondolenceScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CondolenceCountAggregateInputType | true
    _avg?: CondolenceAvgAggregateInputType
    _sum?: CondolenceSumAggregateInputType
    _min?: CondolenceMinAggregateInputType
    _max?: CondolenceMaxAggregateInputType
  }

  export type CondolenceGroupByOutputType = {
    id: number
    name: string
    position: string
    period: string
    featured: boolean
    image: string
    text: string | null
    _count: CondolenceCountAggregateOutputType | null
    _avg: CondolenceAvgAggregateOutputType | null
    _sum: CondolenceSumAggregateOutputType | null
    _min: CondolenceMinAggregateOutputType | null
    _max: CondolenceMaxAggregateOutputType | null
  }

  type GetCondolenceGroupByPayload<T extends CondolenceGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<CondolenceGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof CondolenceGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], CondolenceGroupByOutputType[P]>
            : GetScalarType<T[P], CondolenceGroupByOutputType[P]>
        }
      >
    >


  export type CondolenceSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    position?: boolean
    period?: boolean
    featured?: boolean
    image?: boolean
    text?: boolean
  }, ExtArgs["result"]["condolence"]>

  export type CondolenceSelectScalar = {
    id?: boolean
    name?: boolean
    position?: boolean
    period?: boolean
    featured?: boolean
    image?: boolean
    text?: boolean
  }


  export type $CondolencePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Condolence"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      name: string
      position: string
      period: string
      featured: boolean
      image: string
      text: string | null
    }, ExtArgs["result"]["condolence"]>
    composites: {}
  }


  type CondolenceGetPayload<S extends boolean | null | undefined | CondolenceDefaultArgs> = $Result.GetResult<Prisma.$CondolencePayload, S>

  type CondolenceCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<CondolenceFindManyArgs, 'select' | 'include'> & {
      select?: CondolenceCountAggregateInputType | true
    }

  export interface CondolenceDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Condolence'], meta: { name: 'Condolence' } }
    /**
     * Find zero or one Condolence that matches the filter.
     * @param {CondolenceFindUniqueArgs} args - Arguments to find a Condolence
     * @example
     * // Get one Condolence
     * const condolence = await prisma.condolence.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends CondolenceFindUniqueArgs<ExtArgs>>(
      args: SelectSubset<T, CondolenceFindUniqueArgs<ExtArgs>>
    ): Prisma__CondolenceClient<$Result.GetResult<Prisma.$CondolencePayload<ExtArgs>, T, 'findUnique'> | null, null, ExtArgs>

    /**
     * Find one Condolence that matches the filter or throw an error  with `error.code='P2025'` 
     *     if no matches were found.
     * @param {CondolenceFindUniqueOrThrowArgs} args - Arguments to find a Condolence
     * @example
     * // Get one Condolence
     * const condolence = await prisma.condolence.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUniqueOrThrow<T extends CondolenceFindUniqueOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, CondolenceFindUniqueOrThrowArgs<ExtArgs>>
    ): Prisma__CondolenceClient<$Result.GetResult<Prisma.$CondolencePayload<ExtArgs>, T, 'findUniqueOrThrow'>, never, ExtArgs>

    /**
     * Find the first Condolence 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 {CondolenceFindFirstArgs} args - Arguments to find a Condolence
     * @example
     * // Get one Condolence
     * const condolence = await prisma.condolence.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends CondolenceFindFirstArgs<ExtArgs>>(
      args?: SelectSubset<T, CondolenceFindFirstArgs<ExtArgs>>
    ): Prisma__CondolenceClient<$Result.GetResult<Prisma.$CondolencePayload<ExtArgs>, T, 'findFirst'> | null, null, ExtArgs>

    /**
     * Find the first Condolence 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 {CondolenceFindFirstOrThrowArgs} args - Arguments to find a Condolence
     * @example
     * // Get one Condolence
     * const condolence = await prisma.condolence.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirstOrThrow<T extends CondolenceFindFirstOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, CondolenceFindFirstOrThrowArgs<ExtArgs>>
    ): Prisma__CondolenceClient<$Result.GetResult<Prisma.$CondolencePayload<ExtArgs>, T, 'findFirstOrThrow'>, never, ExtArgs>

    /**
     * Find zero or more Condolences 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 {CondolenceFindManyArgs=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Condolences
     * const condolences = await prisma.condolence.findMany()
     * 
     * // Get first 10 Condolences
     * const condolences = await prisma.condolence.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const condolenceWithIdOnly = await prisma.condolence.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends CondolenceFindManyArgs<ExtArgs>>(
      args?: SelectSubset<T, CondolenceFindManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CondolencePayload<ExtArgs>, T, 'findMany'>>

    /**
     * Create a Condolence.
     * @param {CondolenceCreateArgs} args - Arguments to create a Condolence.
     * @example
     * // Create one Condolence
     * const Condolence = await prisma.condolence.create({
     *   data: {
     *     // ... data to create a Condolence
     *   }
     * })
     * 
    **/
    create<T extends CondolenceCreateArgs<ExtArgs>>(
      args: SelectSubset<T, CondolenceCreateArgs<ExtArgs>>
    ): Prisma__CondolenceClient<$Result.GetResult<Prisma.$CondolencePayload<ExtArgs>, T, 'create'>, never, ExtArgs>

    /**
     * Create many Condolences.
     *     @param {CondolenceCreateManyArgs} args - Arguments to create many Condolences.
     *     @example
     *     // Create many Condolences
     *     const condolence = await prisma.condolence.createMany({
     *       data: {
     *         // ... provide data here
     *       }
     *     })
     *     
    **/
    createMany<T extends CondolenceCreateManyArgs<ExtArgs>>(
      args?: SelectSubset<T, CondolenceCreateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Condolence.
     * @param {CondolenceDeleteArgs} args - Arguments to delete one Condolence.
     * @example
     * // Delete one Condolence
     * const Condolence = await prisma.condolence.delete({
     *   where: {
     *     // ... filter to delete one Condolence
     *   }
     * })
     * 
    **/
    delete<T extends CondolenceDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, CondolenceDeleteArgs<ExtArgs>>
    ): Prisma__CondolenceClient<$Result.GetResult<Prisma.$CondolencePayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one Condolence.
     * @param {CondolenceUpdateArgs} args - Arguments to update one Condolence.
     * @example
     * // Update one Condolence
     * const condolence = await prisma.condolence.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends CondolenceUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, CondolenceUpdateArgs<ExtArgs>>
    ): Prisma__CondolenceClient<$Result.GetResult<Prisma.$CondolencePayload<ExtArgs>, T, 'update'>, never, ExtArgs>

    /**
     * Delete zero or more Condolences.
     * @param {CondolenceDeleteManyArgs} args - Arguments to filter Condolences to delete.
     * @example
     * // Delete a few Condolences
     * const { count } = await prisma.condolence.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends CondolenceDeleteManyArgs<ExtArgs>>(
      args?: SelectSubset<T, CondolenceDeleteManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Condolences.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {CondolenceUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Condolences
     * const condolence = await prisma.condolence.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends CondolenceUpdateManyArgs<ExtArgs>>(
      args: SelectSubset<T, CondolenceUpdateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Condolence.
     * @param {CondolenceUpsertArgs} args - Arguments to update or create a Condolence.
     * @example
     * // Update or create a Condolence
     * const condolence = await prisma.condolence.upsert({
     *   create: {
     *     // ... data to create a Condolence
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Condolence we want to update
     *   }
     * })
    **/
    upsert<T extends CondolenceUpsertArgs<ExtArgs>>(
      args: SelectSubset<T, CondolenceUpsertArgs<ExtArgs>>
    ): Prisma__CondolenceClient<$Result.GetResult<Prisma.$CondolencePayload<ExtArgs>, T, 'upsert'>, never, ExtArgs>

    /**
     * Count the number of Condolences.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {CondolenceCountArgs} args - Arguments to filter Condolences to count.
     * @example
     * // Count the number of Condolences
     * const count = await prisma.condolence.count({
     *   where: {
     *     // ... the filter for the Condolences we want to count
     *   }
     * })
    **/
    count<T extends CondolenceCountArgs>(
      args?: Subset<T, CondolenceCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], CondolenceCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Condolence.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {CondolenceAggregateArgs} 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 CondolenceAggregateArgs>(args: Subset<T, CondolenceAggregateArgs>): Prisma.PrismaPromise<GetCondolenceAggregateType<T>>

    /**
     * Group by Condolence.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {CondolenceGroupByArgs} 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 CondolenceGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: CondolenceGroupByArgs['orderBy'] }
        : { orderBy?: CondolenceGroupByArgs['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, CondolenceGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetCondolenceGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Condolence model
   */
  readonly fields: CondolenceFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Condolence.
   * 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__CondolenceClient<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 Condolence model
   */ 
  interface CondolenceFieldRefs {
    readonly id: FieldRef<"Condolence", 'Int'>
    readonly name: FieldRef<"Condolence", 'String'>
    readonly position: FieldRef<"Condolence", 'String'>
    readonly period: FieldRef<"Condolence", 'String'>
    readonly featured: FieldRef<"Condolence", 'Boolean'>
    readonly image: FieldRef<"Condolence", 'String'>
    readonly text: FieldRef<"Condolence", 'String'>
  }
    

  // Custom InputTypes

  /**
   * Condolence findUnique
   */
  export type CondolenceFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Condolence
     */
    select?: CondolenceSelect<ExtArgs> | null
    /**
     * Filter, which Condolence to fetch.
     */
    where: CondolenceWhereUniqueInput
  }


  /**
   * Condolence findUniqueOrThrow
   */
  export type CondolenceFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Condolence
     */
    select?: CondolenceSelect<ExtArgs> | null
    /**
     * Filter, which Condolence to fetch.
     */
    where: CondolenceWhereUniqueInput
  }


  /**
   * Condolence findFirst
   */
  export type CondolenceFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Condolence
     */
    select?: CondolenceSelect<ExtArgs> | null
    /**
     * Filter, which Condolence to fetch.
     */
    where?: CondolenceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Condolences to fetch.
     */
    orderBy?: CondolenceOrderByWithRelationInput | CondolenceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Condolences.
     */
    cursor?: CondolenceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Condolences from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Condolences.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Condolences.
     */
    distinct?: CondolenceScalarFieldEnum | CondolenceScalarFieldEnum[]
  }


  /**
   * Condolence findFirstOrThrow
   */
  export type CondolenceFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Condolence
     */
    select?: CondolenceSelect<ExtArgs> | null
    /**
     * Filter, which Condolence to fetch.
     */
    where?: CondolenceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Condolences to fetch.
     */
    orderBy?: CondolenceOrderByWithRelationInput | CondolenceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Condolences.
     */
    cursor?: CondolenceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Condolences from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Condolences.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Condolences.
     */
    distinct?: CondolenceScalarFieldEnum | CondolenceScalarFieldEnum[]
  }


  /**
   * Condolence findMany
   */
  export type CondolenceFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Condolence
     */
    select?: CondolenceSelect<ExtArgs> | null
    /**
     * Filter, which Condolences to fetch.
     */
    where?: CondolenceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Condolences to fetch.
     */
    orderBy?: CondolenceOrderByWithRelationInput | CondolenceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Condolences.
     */
    cursor?: CondolenceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Condolences from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Condolences.
     */
    skip?: number
    distinct?: CondolenceScalarFieldEnum | CondolenceScalarFieldEnum[]
  }


  /**
   * Condolence create
   */
  export type CondolenceCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Condolence
     */
    select?: CondolenceSelect<ExtArgs> | null
    /**
     * The data needed to create a Condolence.
     */
    data: XOR<CondolenceCreateInput, CondolenceUncheckedCreateInput>
  }


  /**
   * Condolence createMany
   */
  export type CondolenceCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Condolences.
     */
    data: CondolenceCreateManyInput | CondolenceCreateManyInput[]
    skipDuplicates?: boolean
  }


  /**
   * Condolence update
   */
  export type CondolenceUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Condolence
     */
    select?: CondolenceSelect<ExtArgs> | null
    /**
     * The data needed to update a Condolence.
     */
    data: XOR<CondolenceUpdateInput, CondolenceUncheckedUpdateInput>
    /**
     * Choose, which Condolence to update.
     */
    where: CondolenceWhereUniqueInput
  }


  /**
   * Condolence updateMany
   */
  export type CondolenceUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Condolences.
     */
    data: XOR<CondolenceUpdateManyMutationInput, CondolenceUncheckedUpdateManyInput>
    /**
     * Filter which Condolences to update
     */
    where?: CondolenceWhereInput
  }


  /**
   * Condolence upsert
   */
  export type CondolenceUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Condolence
     */
    select?: CondolenceSelect<ExtArgs> | null
    /**
     * The filter to search for the Condolence to update in case it exists.
     */
    where: CondolenceWhereUniqueInput
    /**
     * In case the Condolence found by the `where` argument doesn't exist, create a new Condolence with this data.
     */
    create: XOR<CondolenceCreateInput, CondolenceUncheckedCreateInput>
    /**
     * In case the Condolence was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CondolenceUpdateInput, CondolenceUncheckedUpdateInput>
  }


  /**
   * Condolence delete
   */
  export type CondolenceDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Condolence
     */
    select?: CondolenceSelect<ExtArgs> | null
    /**
     * Filter which Condolence to delete.
     */
    where: CondolenceWhereUniqueInput
  }


  /**
   * Condolence deleteMany
   */
  export type CondolenceDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Condolences to delete
     */
    where?: CondolenceWhereInput
  }


  /**
   * Condolence without action
   */
  export type CondolenceDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Condolence
     */
    select?: CondolenceSelect<ExtArgs> | null
  }



  /**
   * Model Affiliates
   */

  export type AggregateAffiliates = {
    _count: AffiliatesCountAggregateOutputType | null
    _avg: AffiliatesAvgAggregateOutputType | null
    _sum: AffiliatesSumAggregateOutputType | null
    _min: AffiliatesMinAggregateOutputType | null
    _max: AffiliatesMaxAggregateOutputType | null
  }

  export type AffiliatesAvgAggregateOutputType = {
    id: number | null
  }

  export type AffiliatesSumAggregateOutputType = {
    id: number | null
  }

  export type AffiliatesMinAggregateOutputType = {
    id: number | null
    logo: string | null
  }

  export type AffiliatesMaxAggregateOutputType = {
    id: number | null
    logo: string | null
  }

  export type AffiliatesCountAggregateOutputType = {
    id: number
    logo: number
    _all: number
  }


  export type AffiliatesAvgAggregateInputType = {
    id?: true
  }

  export type AffiliatesSumAggregateInputType = {
    id?: true
  }

  export type AffiliatesMinAggregateInputType = {
    id?: true
    logo?: true
  }

  export type AffiliatesMaxAggregateInputType = {
    id?: true
    logo?: true
  }

  export type AffiliatesCountAggregateInputType = {
    id?: true
    logo?: true
    _all?: true
  }

  export type AffiliatesAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Affiliates to aggregate.
     */
    where?: AffiliatesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Affiliates to fetch.
     */
    orderBy?: AffiliatesOrderByWithRelationInput | AffiliatesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: AffiliatesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Affiliates from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Affiliates.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Affiliates
    **/
    _count?: true | AffiliatesCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: AffiliatesAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: AffiliatesSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: AffiliatesMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: AffiliatesMaxAggregateInputType
  }

  export type GetAffiliatesAggregateType<T extends AffiliatesAggregateArgs> = {
        [P in keyof T & keyof AggregateAffiliates]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateAffiliates[P]>
      : GetScalarType<T[P], AggregateAffiliates[P]>
  }




  export type AffiliatesGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AffiliatesWhereInput
    orderBy?: AffiliatesOrderByWithAggregationInput | AffiliatesOrderByWithAggregationInput[]
    by: AffiliatesScalarFieldEnum[] | AffiliatesScalarFieldEnum
    having?: AffiliatesScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AffiliatesCountAggregateInputType | true
    _avg?: AffiliatesAvgAggregateInputType
    _sum?: AffiliatesSumAggregateInputType
    _min?: AffiliatesMinAggregateInputType
    _max?: AffiliatesMaxAggregateInputType
  }

  export type AffiliatesGroupByOutputType = {
    id: number
    logo: string
    _count: AffiliatesCountAggregateOutputType | null
    _avg: AffiliatesAvgAggregateOutputType | null
    _sum: AffiliatesSumAggregateOutputType | null
    _min: AffiliatesMinAggregateOutputType | null
    _max: AffiliatesMaxAggregateOutputType | null
  }

  type GetAffiliatesGroupByPayload<T extends AffiliatesGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<AffiliatesGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof AffiliatesGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], AffiliatesGroupByOutputType[P]>
            : GetScalarType<T[P], AffiliatesGroupByOutputType[P]>
        }
      >
    >


  export type AffiliatesSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    logo?: boolean
  }, ExtArgs["result"]["affiliates"]>

  export type AffiliatesSelectScalar = {
    id?: boolean
    logo?: boolean
  }


  export type $AffiliatesPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Affiliates"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      logo: string
    }, ExtArgs["result"]["affiliates"]>
    composites: {}
  }


  type AffiliatesGetPayload<S extends boolean | null | undefined | AffiliatesDefaultArgs> = $Result.GetResult<Prisma.$AffiliatesPayload, S>

  type AffiliatesCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<AffiliatesFindManyArgs, 'select' | 'include'> & {
      select?: AffiliatesCountAggregateInputType | true
    }

  export interface AffiliatesDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Affiliates'], meta: { name: 'Affiliates' } }
    /**
     * Find zero or one Affiliates that matches the filter.
     * @param {AffiliatesFindUniqueArgs} args - Arguments to find a Affiliates
     * @example
     * // Get one Affiliates
     * const affiliates = await prisma.affiliates.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends AffiliatesFindUniqueArgs<ExtArgs>>(
      args: SelectSubset<T, AffiliatesFindUniqueArgs<ExtArgs>>
    ): Prisma__AffiliatesClient<$Result.GetResult<Prisma.$AffiliatesPayload<ExtArgs>, T, 'findUnique'> | null, null, ExtArgs>

    /**
     * Find one Affiliates that matches the filter or throw an error  with `error.code='P2025'` 
     *     if no matches were found.
     * @param {AffiliatesFindUniqueOrThrowArgs} args - Arguments to find a Affiliates
     * @example
     * // Get one Affiliates
     * const affiliates = await prisma.affiliates.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUniqueOrThrow<T extends AffiliatesFindUniqueOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, AffiliatesFindUniqueOrThrowArgs<ExtArgs>>
    ): Prisma__AffiliatesClient<$Result.GetResult<Prisma.$AffiliatesPayload<ExtArgs>, T, 'findUniqueOrThrow'>, never, ExtArgs>

    /**
     * Find the first Affiliates 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 {AffiliatesFindFirstArgs} args - Arguments to find a Affiliates
     * @example
     * // Get one Affiliates
     * const affiliates = await prisma.affiliates.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends AffiliatesFindFirstArgs<ExtArgs>>(
      args?: SelectSubset<T, AffiliatesFindFirstArgs<ExtArgs>>
    ): Prisma__AffiliatesClient<$Result.GetResult<Prisma.$AffiliatesPayload<ExtArgs>, T, 'findFirst'> | null, null, ExtArgs>

    /**
     * Find the first Affiliates 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 {AffiliatesFindFirstOrThrowArgs} args - Arguments to find a Affiliates
     * @example
     * // Get one Affiliates
     * const affiliates = await prisma.affiliates.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirstOrThrow<T extends AffiliatesFindFirstOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, AffiliatesFindFirstOrThrowArgs<ExtArgs>>
    ): Prisma__AffiliatesClient<$Result.GetResult<Prisma.$AffiliatesPayload<ExtArgs>, T, 'findFirstOrThrow'>, never, ExtArgs>

    /**
     * Find zero or more Affiliates 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 {AffiliatesFindManyArgs=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Affiliates
     * const affiliates = await prisma.affiliates.findMany()
     * 
     * // Get first 10 Affiliates
     * const affiliates = await prisma.affiliates.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const affiliatesWithIdOnly = await prisma.affiliates.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends AffiliatesFindManyArgs<ExtArgs>>(
      args?: SelectSubset<T, AffiliatesFindManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AffiliatesPayload<ExtArgs>, T, 'findMany'>>

    /**
     * Create a Affiliates.
     * @param {AffiliatesCreateArgs} args - Arguments to create a Affiliates.
     * @example
     * // Create one Affiliates
     * const Affiliates = await prisma.affiliates.create({
     *   data: {
     *     // ... data to create a Affiliates
     *   }
     * })
     * 
    **/
    create<T extends AffiliatesCreateArgs<ExtArgs>>(
      args: SelectSubset<T, AffiliatesCreateArgs<ExtArgs>>
    ): Prisma__AffiliatesClient<$Result.GetResult<Prisma.$AffiliatesPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

    /**
     * Create many Affiliates.
     *     @param {AffiliatesCreateManyArgs} args - Arguments to create many Affiliates.
     *     @example
     *     // Create many Affiliates
     *     const affiliates = await prisma.affiliates.createMany({
     *       data: {
     *         // ... provide data here
     *       }
     *     })
     *     
    **/
    createMany<T extends AffiliatesCreateManyArgs<ExtArgs>>(
      args?: SelectSubset<T, AffiliatesCreateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Affiliates.
     * @param {AffiliatesDeleteArgs} args - Arguments to delete one Affiliates.
     * @example
     * // Delete one Affiliates
     * const Affiliates = await prisma.affiliates.delete({
     *   where: {
     *     // ... filter to delete one Affiliates
     *   }
     * })
     * 
    **/
    delete<T extends AffiliatesDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, AffiliatesDeleteArgs<ExtArgs>>
    ): Prisma__AffiliatesClient<$Result.GetResult<Prisma.$AffiliatesPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one Affiliates.
     * @param {AffiliatesUpdateArgs} args - Arguments to update one Affiliates.
     * @example
     * // Update one Affiliates
     * const affiliates = await prisma.affiliates.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends AffiliatesUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, AffiliatesUpdateArgs<ExtArgs>>
    ): Prisma__AffiliatesClient<$Result.GetResult<Prisma.$AffiliatesPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

    /**
     * Delete zero or more Affiliates.
     * @param {AffiliatesDeleteManyArgs} args - Arguments to filter Affiliates to delete.
     * @example
     * // Delete a few Affiliates
     * const { count } = await prisma.affiliates.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends AffiliatesDeleteManyArgs<ExtArgs>>(
      args?: SelectSubset<T, AffiliatesDeleteManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Affiliates.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AffiliatesUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Affiliates
     * const affiliates = await prisma.affiliates.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends AffiliatesUpdateManyArgs<ExtArgs>>(
      args: SelectSubset<T, AffiliatesUpdateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Affiliates.
     * @param {AffiliatesUpsertArgs} args - Arguments to update or create a Affiliates.
     * @example
     * // Update or create a Affiliates
     * const affiliates = await prisma.affiliates.upsert({
     *   create: {
     *     // ... data to create a Affiliates
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Affiliates we want to update
     *   }
     * })
    **/
    upsert<T extends AffiliatesUpsertArgs<ExtArgs>>(
      args: SelectSubset<T, AffiliatesUpsertArgs<ExtArgs>>
    ): Prisma__AffiliatesClient<$Result.GetResult<Prisma.$AffiliatesPayload<ExtArgs>, T, 'upsert'>, never, ExtArgs>

    /**
     * Count the number of Affiliates.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AffiliatesCountArgs} args - Arguments to filter Affiliates to count.
     * @example
     * // Count the number of Affiliates
     * const count = await prisma.affiliates.count({
     *   where: {
     *     // ... the filter for the Affiliates we want to count
     *   }
     * })
    **/
    count<T extends AffiliatesCountArgs>(
      args?: Subset<T, AffiliatesCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], AffiliatesCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Affiliates.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AffiliatesAggregateArgs} 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 AffiliatesAggregateArgs>(args: Subset<T, AffiliatesAggregateArgs>): Prisma.PrismaPromise<GetAffiliatesAggregateType<T>>

    /**
     * Group by Affiliates.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {AffiliatesGroupByArgs} 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 AffiliatesGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: AffiliatesGroupByArgs['orderBy'] }
        : { orderBy?: AffiliatesGroupByArgs['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, AffiliatesGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetAffiliatesGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Affiliates model
   */
  readonly fields: AffiliatesFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Affiliates.
   * 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__AffiliatesClient<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 Affiliates model
   */ 
  interface AffiliatesFieldRefs {
    readonly id: FieldRef<"Affiliates", 'Int'>
    readonly logo: FieldRef<"Affiliates", 'String'>
  }
    

  // Custom InputTypes

  /**
   * Affiliates findUnique
   */
  export type AffiliatesFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Affiliates
     */
    select?: AffiliatesSelect<ExtArgs> | null
    /**
     * Filter, which Affiliates to fetch.
     */
    where: AffiliatesWhereUniqueInput
  }


  /**
   * Affiliates findUniqueOrThrow
   */
  export type AffiliatesFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Affiliates
     */
    select?: AffiliatesSelect<ExtArgs> | null
    /**
     * Filter, which Affiliates to fetch.
     */
    where: AffiliatesWhereUniqueInput
  }


  /**
   * Affiliates findFirst
   */
  export type AffiliatesFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Affiliates
     */
    select?: AffiliatesSelect<ExtArgs> | null
    /**
     * Filter, which Affiliates to fetch.
     */
    where?: AffiliatesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Affiliates to fetch.
     */
    orderBy?: AffiliatesOrderByWithRelationInput | AffiliatesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Affiliates.
     */
    cursor?: AffiliatesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Affiliates from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Affiliates.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Affiliates.
     */
    distinct?: AffiliatesScalarFieldEnum | AffiliatesScalarFieldEnum[]
  }


  /**
   * Affiliates findFirstOrThrow
   */
  export type AffiliatesFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Affiliates
     */
    select?: AffiliatesSelect<ExtArgs> | null
    /**
     * Filter, which Affiliates to fetch.
     */
    where?: AffiliatesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Affiliates to fetch.
     */
    orderBy?: AffiliatesOrderByWithRelationInput | AffiliatesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Affiliates.
     */
    cursor?: AffiliatesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Affiliates from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Affiliates.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Affiliates.
     */
    distinct?: AffiliatesScalarFieldEnum | AffiliatesScalarFieldEnum[]
  }


  /**
   * Affiliates findMany
   */
  export type AffiliatesFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Affiliates
     */
    select?: AffiliatesSelect<ExtArgs> | null
    /**
     * Filter, which Affiliates to fetch.
     */
    where?: AffiliatesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Affiliates to fetch.
     */
    orderBy?: AffiliatesOrderByWithRelationInput | AffiliatesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Affiliates.
     */
    cursor?: AffiliatesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Affiliates from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Affiliates.
     */
    skip?: number
    distinct?: AffiliatesScalarFieldEnum | AffiliatesScalarFieldEnum[]
  }


  /**
   * Affiliates create
   */
  export type AffiliatesCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Affiliates
     */
    select?: AffiliatesSelect<ExtArgs> | null
    /**
     * The data needed to create a Affiliates.
     */
    data: XOR<AffiliatesCreateInput, AffiliatesUncheckedCreateInput>
  }


  /**
   * Affiliates createMany
   */
  export type AffiliatesCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Affiliates.
     */
    data: AffiliatesCreateManyInput | AffiliatesCreateManyInput[]
    skipDuplicates?: boolean
  }


  /**
   * Affiliates update
   */
  export type AffiliatesUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Affiliates
     */
    select?: AffiliatesSelect<ExtArgs> | null
    /**
     * The data needed to update a Affiliates.
     */
    data: XOR<AffiliatesUpdateInput, AffiliatesUncheckedUpdateInput>
    /**
     * Choose, which Affiliates to update.
     */
    where: AffiliatesWhereUniqueInput
  }


  /**
   * Affiliates updateMany
   */
  export type AffiliatesUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Affiliates.
     */
    data: XOR<AffiliatesUpdateManyMutationInput, AffiliatesUncheckedUpdateManyInput>
    /**
     * Filter which Affiliates to update
     */
    where?: AffiliatesWhereInput
  }


  /**
   * Affiliates upsert
   */
  export type AffiliatesUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Affiliates
     */
    select?: AffiliatesSelect<ExtArgs> | null
    /**
     * The filter to search for the Affiliates to update in case it exists.
     */
    where: AffiliatesWhereUniqueInput
    /**
     * In case the Affiliates found by the `where` argument doesn't exist, create a new Affiliates with this data.
     */
    create: XOR<AffiliatesCreateInput, AffiliatesUncheckedCreateInput>
    /**
     * In case the Affiliates was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AffiliatesUpdateInput, AffiliatesUncheckedUpdateInput>
  }


  /**
   * Affiliates delete
   */
  export type AffiliatesDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Affiliates
     */
    select?: AffiliatesSelect<ExtArgs> | null
    /**
     * Filter which Affiliates to delete.
     */
    where: AffiliatesWhereUniqueInput
  }


  /**
   * Affiliates deleteMany
   */
  export type AffiliatesDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Affiliates to delete
     */
    where?: AffiliatesWhereInput
  }


  /**
   * Affiliates without action
   */
  export type AffiliatesDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Affiliates
     */
    select?: AffiliatesSelect<ExtArgs> | null
  }



  /**
   * Model Subscribers
   */

  export type AggregateSubscribers = {
    _count: SubscribersCountAggregateOutputType | null
    _avg: SubscribersAvgAggregateOutputType | null
    _sum: SubscribersSumAggregateOutputType | null
    _min: SubscribersMinAggregateOutputType | null
    _max: SubscribersMaxAggregateOutputType | null
  }

  export type SubscribersAvgAggregateOutputType = {
    id: number | null
  }

  export type SubscribersSumAggregateOutputType = {
    id: number | null
  }

  export type SubscribersMinAggregateOutputType = {
    id: number | null
    email: string | null
    date: Date | null
  }

  export type SubscribersMaxAggregateOutputType = {
    id: number | null
    email: string | null
    date: Date | null
  }

  export type SubscribersCountAggregateOutputType = {
    id: number
    email: number
    date: number
    _all: number
  }


  export type SubscribersAvgAggregateInputType = {
    id?: true
  }

  export type SubscribersSumAggregateInputType = {
    id?: true
  }

  export type SubscribersMinAggregateInputType = {
    id?: true
    email?: true
    date?: true
  }

  export type SubscribersMaxAggregateInputType = {
    id?: true
    email?: true
    date?: true
  }

  export type SubscribersCountAggregateInputType = {
    id?: true
    email?: true
    date?: true
    _all?: true
  }

  export type SubscribersAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Subscribers to aggregate.
     */
    where?: SubscribersWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Subscribers to fetch.
     */
    orderBy?: SubscribersOrderByWithRelationInput | SubscribersOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: SubscribersWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Subscribers from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Subscribers.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Subscribers
    **/
    _count?: true | SubscribersCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: SubscribersAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: SubscribersSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: SubscribersMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: SubscribersMaxAggregateInputType
  }

  export type GetSubscribersAggregateType<T extends SubscribersAggregateArgs> = {
        [P in keyof T & keyof AggregateSubscribers]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateSubscribers[P]>
      : GetScalarType<T[P], AggregateSubscribers[P]>
  }




  export type SubscribersGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SubscribersWhereInput
    orderBy?: SubscribersOrderByWithAggregationInput | SubscribersOrderByWithAggregationInput[]
    by: SubscribersScalarFieldEnum[] | SubscribersScalarFieldEnum
    having?: SubscribersScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: SubscribersCountAggregateInputType | true
    _avg?: SubscribersAvgAggregateInputType
    _sum?: SubscribersSumAggregateInputType
    _min?: SubscribersMinAggregateInputType
    _max?: SubscribersMaxAggregateInputType
  }

  export type SubscribersGroupByOutputType = {
    id: number
    email: string
    date: Date
    _count: SubscribersCountAggregateOutputType | null
    _avg: SubscribersAvgAggregateOutputType | null
    _sum: SubscribersSumAggregateOutputType | null
    _min: SubscribersMinAggregateOutputType | null
    _max: SubscribersMaxAggregateOutputType | null
  }

  type GetSubscribersGroupByPayload<T extends SubscribersGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<SubscribersGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof SubscribersGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], SubscribersGroupByOutputType[P]>
            : GetScalarType<T[P], SubscribersGroupByOutputType[P]>
        }
      >
    >


  export type SubscribersSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    email?: boolean
    date?: boolean
  }, ExtArgs["result"]["subscribers"]>

  export type SubscribersSelectScalar = {
    id?: boolean
    email?: boolean
    date?: boolean
  }


  export type $SubscribersPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Subscribers"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      email: string
      date: Date
    }, ExtArgs["result"]["subscribers"]>
    composites: {}
  }


  type SubscribersGetPayload<S extends boolean | null | undefined | SubscribersDefaultArgs> = $Result.GetResult<Prisma.$SubscribersPayload, S>

  type SubscribersCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<SubscribersFindManyArgs, 'select' | 'include'> & {
      select?: SubscribersCountAggregateInputType | true
    }

  export interface SubscribersDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Subscribers'], meta: { name: 'Subscribers' } }
    /**
     * Find zero or one Subscribers that matches the filter.
     * @param {SubscribersFindUniqueArgs} args - Arguments to find a Subscribers
     * @example
     * // Get one Subscribers
     * const subscribers = await prisma.subscribers.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends SubscribersFindUniqueArgs<ExtArgs>>(
      args: SelectSubset<T, SubscribersFindUniqueArgs<ExtArgs>>
    ): Prisma__SubscribersClient<$Result.GetResult<Prisma.$SubscribersPayload<ExtArgs>, T, 'findUnique'> | null, null, ExtArgs>

    /**
     * Find one Subscribers that matches the filter or throw an error  with `error.code='P2025'` 
     *     if no matches were found.
     * @param {SubscribersFindUniqueOrThrowArgs} args - Arguments to find a Subscribers
     * @example
     * // Get one Subscribers
     * const subscribers = await prisma.subscribers.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUniqueOrThrow<T extends SubscribersFindUniqueOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, SubscribersFindUniqueOrThrowArgs<ExtArgs>>
    ): Prisma__SubscribersClient<$Result.GetResult<Prisma.$SubscribersPayload<ExtArgs>, T, 'findUniqueOrThrow'>, never, ExtArgs>

    /**
     * Find the first Subscribers 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 {SubscribersFindFirstArgs} args - Arguments to find a Subscribers
     * @example
     * // Get one Subscribers
     * const subscribers = await prisma.subscribers.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends SubscribersFindFirstArgs<ExtArgs>>(
      args?: SelectSubset<T, SubscribersFindFirstArgs<ExtArgs>>
    ): Prisma__SubscribersClient<$Result.GetResult<Prisma.$SubscribersPayload<ExtArgs>, T, 'findFirst'> | null, null, ExtArgs>

    /**
     * Find the first Subscribers 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 {SubscribersFindFirstOrThrowArgs} args - Arguments to find a Subscribers
     * @example
     * // Get one Subscribers
     * const subscribers = await prisma.subscribers.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirstOrThrow<T extends SubscribersFindFirstOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, SubscribersFindFirstOrThrowArgs<ExtArgs>>
    ): Prisma__SubscribersClient<$Result.GetResult<Prisma.$SubscribersPayload<ExtArgs>, T, 'findFirstOrThrow'>, never, ExtArgs>

    /**
     * Find zero or more Subscribers 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 {SubscribersFindManyArgs=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Subscribers
     * const subscribers = await prisma.subscribers.findMany()
     * 
     * // Get first 10 Subscribers
     * const subscribers = await prisma.subscribers.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const subscribersWithIdOnly = await prisma.subscribers.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends SubscribersFindManyArgs<ExtArgs>>(
      args?: SelectSubset<T, SubscribersFindManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SubscribersPayload<ExtArgs>, T, 'findMany'>>

    /**
     * Create a Subscribers.
     * @param {SubscribersCreateArgs} args - Arguments to create a Subscribers.
     * @example
     * // Create one Subscribers
     * const Subscribers = await prisma.subscribers.create({
     *   data: {
     *     // ... data to create a Subscribers
     *   }
     * })
     * 
    **/
    create<T extends SubscribersCreateArgs<ExtArgs>>(
      args: SelectSubset<T, SubscribersCreateArgs<ExtArgs>>
    ): Prisma__SubscribersClient<$Result.GetResult<Prisma.$SubscribersPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

    /**
     * Create many Subscribers.
     *     @param {SubscribersCreateManyArgs} args - Arguments to create many Subscribers.
     *     @example
     *     // Create many Subscribers
     *     const subscribers = await prisma.subscribers.createMany({
     *       data: {
     *         // ... provide data here
     *       }
     *     })
     *     
    **/
    createMany<T extends SubscribersCreateManyArgs<ExtArgs>>(
      args?: SelectSubset<T, SubscribersCreateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Subscribers.
     * @param {SubscribersDeleteArgs} args - Arguments to delete one Subscribers.
     * @example
     * // Delete one Subscribers
     * const Subscribers = await prisma.subscribers.delete({
     *   where: {
     *     // ... filter to delete one Subscribers
     *   }
     * })
     * 
    **/
    delete<T extends SubscribersDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, SubscribersDeleteArgs<ExtArgs>>
    ): Prisma__SubscribersClient<$Result.GetResult<Prisma.$SubscribersPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one Subscribers.
     * @param {SubscribersUpdateArgs} args - Arguments to update one Subscribers.
     * @example
     * // Update one Subscribers
     * const subscribers = await prisma.subscribers.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends SubscribersUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, SubscribersUpdateArgs<ExtArgs>>
    ): Prisma__SubscribersClient<$Result.GetResult<Prisma.$SubscribersPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

    /**
     * Delete zero or more Subscribers.
     * @param {SubscribersDeleteManyArgs} args - Arguments to filter Subscribers to delete.
     * @example
     * // Delete a few Subscribers
     * const { count } = await prisma.subscribers.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends SubscribersDeleteManyArgs<ExtArgs>>(
      args?: SelectSubset<T, SubscribersDeleteManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Subscribers.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SubscribersUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Subscribers
     * const subscribers = await prisma.subscribers.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends SubscribersUpdateManyArgs<ExtArgs>>(
      args: SelectSubset<T, SubscribersUpdateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Subscribers.
     * @param {SubscribersUpsertArgs} args - Arguments to update or create a Subscribers.
     * @example
     * // Update or create a Subscribers
     * const subscribers = await prisma.subscribers.upsert({
     *   create: {
     *     // ... data to create a Subscribers
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Subscribers we want to update
     *   }
     * })
    **/
    upsert<T extends SubscribersUpsertArgs<ExtArgs>>(
      args: SelectSubset<T, SubscribersUpsertArgs<ExtArgs>>
    ): Prisma__SubscribersClient<$Result.GetResult<Prisma.$SubscribersPayload<ExtArgs>, T, 'upsert'>, never, ExtArgs>

    /**
     * Count the number of Subscribers.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SubscribersCountArgs} args - Arguments to filter Subscribers to count.
     * @example
     * // Count the number of Subscribers
     * const count = await prisma.subscribers.count({
     *   where: {
     *     // ... the filter for the Subscribers we want to count
     *   }
     * })
    **/
    count<T extends SubscribersCountArgs>(
      args?: Subset<T, SubscribersCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], SubscribersCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Subscribers.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SubscribersAggregateArgs} 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 SubscribersAggregateArgs>(args: Subset<T, SubscribersAggregateArgs>): Prisma.PrismaPromise<GetSubscribersAggregateType<T>>

    /**
     * Group by Subscribers.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SubscribersGroupByArgs} 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 SubscribersGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: SubscribersGroupByArgs['orderBy'] }
        : { orderBy?: SubscribersGroupByArgs['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, SubscribersGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetSubscribersGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Subscribers model
   */
  readonly fields: SubscribersFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Subscribers.
   * 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__SubscribersClient<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 Subscribers model
   */ 
  interface SubscribersFieldRefs {
    readonly id: FieldRef<"Subscribers", 'Int'>
    readonly email: FieldRef<"Subscribers", 'String'>
    readonly date: FieldRef<"Subscribers", 'DateTime'>
  }
    

  // Custom InputTypes

  /**
   * Subscribers findUnique
   */
  export type SubscribersFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscribers
     */
    select?: SubscribersSelect<ExtArgs> | null
    /**
     * Filter, which Subscribers to fetch.
     */
    where: SubscribersWhereUniqueInput
  }


  /**
   * Subscribers findUniqueOrThrow
   */
  export type SubscribersFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscribers
     */
    select?: SubscribersSelect<ExtArgs> | null
    /**
     * Filter, which Subscribers to fetch.
     */
    where: SubscribersWhereUniqueInput
  }


  /**
   * Subscribers findFirst
   */
  export type SubscribersFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscribers
     */
    select?: SubscribersSelect<ExtArgs> | null
    /**
     * Filter, which Subscribers to fetch.
     */
    where?: SubscribersWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Subscribers to fetch.
     */
    orderBy?: SubscribersOrderByWithRelationInput | SubscribersOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Subscribers.
     */
    cursor?: SubscribersWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Subscribers from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Subscribers.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Subscribers.
     */
    distinct?: SubscribersScalarFieldEnum | SubscribersScalarFieldEnum[]
  }


  /**
   * Subscribers findFirstOrThrow
   */
  export type SubscribersFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscribers
     */
    select?: SubscribersSelect<ExtArgs> | null
    /**
     * Filter, which Subscribers to fetch.
     */
    where?: SubscribersWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Subscribers to fetch.
     */
    orderBy?: SubscribersOrderByWithRelationInput | SubscribersOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Subscribers.
     */
    cursor?: SubscribersWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Subscribers from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Subscribers.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Subscribers.
     */
    distinct?: SubscribersScalarFieldEnum | SubscribersScalarFieldEnum[]
  }


  /**
   * Subscribers findMany
   */
  export type SubscribersFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscribers
     */
    select?: SubscribersSelect<ExtArgs> | null
    /**
     * Filter, which Subscribers to fetch.
     */
    where?: SubscribersWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Subscribers to fetch.
     */
    orderBy?: SubscribersOrderByWithRelationInput | SubscribersOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Subscribers.
     */
    cursor?: SubscribersWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Subscribers from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Subscribers.
     */
    skip?: number
    distinct?: SubscribersScalarFieldEnum | SubscribersScalarFieldEnum[]
  }


  /**
   * Subscribers create
   */
  export type SubscribersCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscribers
     */
    select?: SubscribersSelect<ExtArgs> | null
    /**
     * The data needed to create a Subscribers.
     */
    data: XOR<SubscribersCreateInput, SubscribersUncheckedCreateInput>
  }


  /**
   * Subscribers createMany
   */
  export type SubscribersCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Subscribers.
     */
    data: SubscribersCreateManyInput | SubscribersCreateManyInput[]
    skipDuplicates?: boolean
  }


  /**
   * Subscribers update
   */
  export type SubscribersUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscribers
     */
    select?: SubscribersSelect<ExtArgs> | null
    /**
     * The data needed to update a Subscribers.
     */
    data: XOR<SubscribersUpdateInput, SubscribersUncheckedUpdateInput>
    /**
     * Choose, which Subscribers to update.
     */
    where: SubscribersWhereUniqueInput
  }


  /**
   * Subscribers updateMany
   */
  export type SubscribersUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Subscribers.
     */
    data: XOR<SubscribersUpdateManyMutationInput, SubscribersUncheckedUpdateManyInput>
    /**
     * Filter which Subscribers to update
     */
    where?: SubscribersWhereInput
  }


  /**
   * Subscribers upsert
   */
  export type SubscribersUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscribers
     */
    select?: SubscribersSelect<ExtArgs> | null
    /**
     * The filter to search for the Subscribers to update in case it exists.
     */
    where: SubscribersWhereUniqueInput
    /**
     * In case the Subscribers found by the `where` argument doesn't exist, create a new Subscribers with this data.
     */
    create: XOR<SubscribersCreateInput, SubscribersUncheckedCreateInput>
    /**
     * In case the Subscribers was found with the provided `where` argument, update it with this data.
     */
    update: XOR<SubscribersUpdateInput, SubscribersUncheckedUpdateInput>
  }


  /**
   * Subscribers delete
   */
  export type SubscribersDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscribers
     */
    select?: SubscribersSelect<ExtArgs> | null
    /**
     * Filter which Subscribers to delete.
     */
    where: SubscribersWhereUniqueInput
  }


  /**
   * Subscribers deleteMany
   */
  export type SubscribersDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Subscribers to delete
     */
    where?: SubscribersWhereInput
  }


  /**
   * Subscribers without action
   */
  export type SubscribersDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Subscribers
     */
    select?: SubscribersSelect<ExtArgs> | null
  }



  /**
   * Model Messages
   */

  export type AggregateMessages = {
    _count: MessagesCountAggregateOutputType | null
    _avg: MessagesAvgAggregateOutputType | null
    _sum: MessagesSumAggregateOutputType | null
    _min: MessagesMinAggregateOutputType | null
    _max: MessagesMaxAggregateOutputType | null
  }

  export type MessagesAvgAggregateOutputType = {
    id: number | null
  }

  export type MessagesSumAggregateOutputType = {
    id: number | null
  }

  export type MessagesMinAggregateOutputType = {
    id: number | null
    email: string | null
    name: string | null
    phone: string | null
    message: string | null
    date: Date | null
  }

  export type MessagesMaxAggregateOutputType = {
    id: number | null
    email: string | null
    name: string | null
    phone: string | null
    message: string | null
    date: Date | null
  }

  export type MessagesCountAggregateOutputType = {
    id: number
    email: number
    name: number
    phone: number
    message: number
    date: number
    _all: number
  }


  export type MessagesAvgAggregateInputType = {
    id?: true
  }

  export type MessagesSumAggregateInputType = {
    id?: true
  }

  export type MessagesMinAggregateInputType = {
    id?: true
    email?: true
    name?: true
    phone?: true
    message?: true
    date?: true
  }

  export type MessagesMaxAggregateInputType = {
    id?: true
    email?: true
    name?: true
    phone?: true
    message?: true
    date?: true
  }

  export type MessagesCountAggregateInputType = {
    id?: true
    email?: true
    name?: true
    phone?: true
    message?: true
    date?: true
    _all?: true
  }

  export type MessagesAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Messages to aggregate.
     */
    where?: MessagesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Messages to fetch.
     */
    orderBy?: MessagesOrderByWithRelationInput | MessagesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: MessagesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Messages from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Messages.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Messages
    **/
    _count?: true | MessagesCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: MessagesAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: MessagesSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: MessagesMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: MessagesMaxAggregateInputType
  }

  export type GetMessagesAggregateType<T extends MessagesAggregateArgs> = {
        [P in keyof T & keyof AggregateMessages]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateMessages[P]>
      : GetScalarType<T[P], AggregateMessages[P]>
  }




  export type MessagesGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MessagesWhereInput
    orderBy?: MessagesOrderByWithAggregationInput | MessagesOrderByWithAggregationInput[]
    by: MessagesScalarFieldEnum[] | MessagesScalarFieldEnum
    having?: MessagesScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: MessagesCountAggregateInputType | true
    _avg?: MessagesAvgAggregateInputType
    _sum?: MessagesSumAggregateInputType
    _min?: MessagesMinAggregateInputType
    _max?: MessagesMaxAggregateInputType
  }

  export type MessagesGroupByOutputType = {
    id: number
    email: string
    name: string
    phone: string
    message: string
    date: Date
    _count: MessagesCountAggregateOutputType | null
    _avg: MessagesAvgAggregateOutputType | null
    _sum: MessagesSumAggregateOutputType | null
    _min: MessagesMinAggregateOutputType | null
    _max: MessagesMaxAggregateOutputType | null
  }

  type GetMessagesGroupByPayload<T extends MessagesGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<MessagesGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof MessagesGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], MessagesGroupByOutputType[P]>
            : GetScalarType<T[P], MessagesGroupByOutputType[P]>
        }
      >
    >


  export type MessagesSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    email?: boolean
    name?: boolean
    phone?: boolean
    message?: boolean
    date?: boolean
  }, ExtArgs["result"]["messages"]>

  export type MessagesSelectScalar = {
    id?: boolean
    email?: boolean
    name?: boolean
    phone?: boolean
    message?: boolean
    date?: boolean
  }


  export type $MessagesPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Messages"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: number
      email: string
      name: string
      phone: string
      message: string
      date: Date
    }, ExtArgs["result"]["messages"]>
    composites: {}
  }


  type MessagesGetPayload<S extends boolean | null | undefined | MessagesDefaultArgs> = $Result.GetResult<Prisma.$MessagesPayload, S>

  type MessagesCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<MessagesFindManyArgs, 'select' | 'include'> & {
      select?: MessagesCountAggregateInputType | true
    }

  export interface MessagesDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Messages'], meta: { name: 'Messages' } }
    /**
     * Find zero or one Messages that matches the filter.
     * @param {MessagesFindUniqueArgs} args - Arguments to find a Messages
     * @example
     * // Get one Messages
     * const messages = await prisma.messages.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUnique<T extends MessagesFindUniqueArgs<ExtArgs>>(
      args: SelectSubset<T, MessagesFindUniqueArgs<ExtArgs>>
    ): Prisma__MessagesClient<$Result.GetResult<Prisma.$MessagesPayload<ExtArgs>, T, 'findUnique'> | null, null, ExtArgs>

    /**
     * Find one Messages that matches the filter or throw an error  with `error.code='P2025'` 
     *     if no matches were found.
     * @param {MessagesFindUniqueOrThrowArgs} args - Arguments to find a Messages
     * @example
     * // Get one Messages
     * const messages = await prisma.messages.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findUniqueOrThrow<T extends MessagesFindUniqueOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, MessagesFindUniqueOrThrowArgs<ExtArgs>>
    ): Prisma__MessagesClient<$Result.GetResult<Prisma.$MessagesPayload<ExtArgs>, T, 'findUniqueOrThrow'>, never, ExtArgs>

    /**
     * Find the first Messages that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MessagesFindFirstArgs} args - Arguments to find a Messages
     * @example
     * // Get one Messages
     * const messages = await prisma.messages.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirst<T extends MessagesFindFirstArgs<ExtArgs>>(
      args?: SelectSubset<T, MessagesFindFirstArgs<ExtArgs>>
    ): Prisma__MessagesClient<$Result.GetResult<Prisma.$MessagesPayload<ExtArgs>, T, 'findFirst'> | null, null, ExtArgs>

    /**
     * Find the first Messages that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MessagesFindFirstOrThrowArgs} args - Arguments to find a Messages
     * @example
     * // Get one Messages
     * const messages = await prisma.messages.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
    **/
    findFirstOrThrow<T extends MessagesFindFirstOrThrowArgs<ExtArgs>>(
      args?: SelectSubset<T, MessagesFindFirstOrThrowArgs<ExtArgs>>
    ): Prisma__MessagesClient<$Result.GetResult<Prisma.$MessagesPayload<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 {MessagesFindManyArgs=} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Messages
     * const messages = await prisma.messages.findMany()
     * 
     * // Get first 10 Messages
     * const messages = await prisma.messages.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const messagesWithIdOnly = await prisma.messages.findMany({ select: { id: true } })
     * 
    **/
    findMany<T extends MessagesFindManyArgs<ExtArgs>>(
      args?: SelectSubset<T, MessagesFindManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MessagesPayload<ExtArgs>, T, 'findMany'>>

    /**
     * Create a Messages.
     * @param {MessagesCreateArgs} args - Arguments to create a Messages.
     * @example
     * // Create one Messages
     * const Messages = await prisma.messages.create({
     *   data: {
     *     // ... data to create a Messages
     *   }
     * })
     * 
    **/
    create<T extends MessagesCreateArgs<ExtArgs>>(
      args: SelectSubset<T, MessagesCreateArgs<ExtArgs>>
    ): Prisma__MessagesClient<$Result.GetResult<Prisma.$MessagesPayload<ExtArgs>, T, 'create'>, never, ExtArgs>

    /**
     * Create many Messages.
     *     @param {MessagesCreateManyArgs} args - Arguments to create many Messages.
     *     @example
     *     // Create many Messages
     *     const messages = await prisma.messages.createMany({
     *       data: {
     *         // ... provide data here
     *       }
     *     })
     *     
    **/
    createMany<T extends MessagesCreateManyArgs<ExtArgs>>(
      args?: SelectSubset<T, MessagesCreateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Messages.
     * @param {MessagesDeleteArgs} args - Arguments to delete one Messages.
     * @example
     * // Delete one Messages
     * const Messages = await prisma.messages.delete({
     *   where: {
     *     // ... filter to delete one Messages
     *   }
     * })
     * 
    **/
    delete<T extends MessagesDeleteArgs<ExtArgs>>(
      args: SelectSubset<T, MessagesDeleteArgs<ExtArgs>>
    ): Prisma__MessagesClient<$Result.GetResult<Prisma.$MessagesPayload<ExtArgs>, T, 'delete'>, never, ExtArgs>

    /**
     * Update one Messages.
     * @param {MessagesUpdateArgs} args - Arguments to update one Messages.
     * @example
     * // Update one Messages
     * const messages = await prisma.messages.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    update<T extends MessagesUpdateArgs<ExtArgs>>(
      args: SelectSubset<T, MessagesUpdateArgs<ExtArgs>>
    ): Prisma__MessagesClient<$Result.GetResult<Prisma.$MessagesPayload<ExtArgs>, T, 'update'>, never, ExtArgs>

    /**
     * Delete zero or more Messages.
     * @param {MessagesDeleteManyArgs} args - Arguments to filter Messages to delete.
     * @example
     * // Delete a few Messages
     * const { count } = await prisma.messages.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
    **/
    deleteMany<T extends MessagesDeleteManyArgs<ExtArgs>>(
      args?: SelectSubset<T, MessagesDeleteManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Messages.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MessagesUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Messages
     * const messages = await prisma.messages.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
    **/
    updateMany<T extends MessagesUpdateManyArgs<ExtArgs>>(
      args: SelectSubset<T, MessagesUpdateManyArgs<ExtArgs>>
    ): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Messages.
     * @param {MessagesUpsertArgs} args - Arguments to update or create a Messages.
     * @example
     * // Update or create a Messages
     * const messages = await prisma.messages.upsert({
     *   create: {
     *     // ... data to create a Messages
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Messages we want to update
     *   }
     * })
    **/
    upsert<T extends MessagesUpsertArgs<ExtArgs>>(
      args: SelectSubset<T, MessagesUpsertArgs<ExtArgs>>
    ): Prisma__MessagesClient<$Result.GetResult<Prisma.$MessagesPayload<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 {MessagesCountArgs} args - Arguments to filter Messages to count.
     * @example
     * // Count the number of Messages
     * const count = await prisma.messages.count({
     *   where: {
     *     // ... the filter for the Messages we want to count
     *   }
     * })
    **/
    count<T extends MessagesCountArgs>(
      args?: Subset<T, MessagesCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], MessagesCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Messages.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MessagesAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
     * @example
     * // Ordered by age ascending
     * // Where email contains prisma.io
     * // Limited to the 10 users
     * const aggregations = await prisma.user.aggregate({
     *   _avg: {
     *     age: true,
     *   },
     *   where: {
     *     email: {
     *       contains: "prisma.io",
     *     },
     *   },
     *   orderBy: {
     *     age: "asc",
     *   },
     *   take: 10,
     * })
    **/
    aggregate<T extends MessagesAggregateArgs>(args: Subset<T, MessagesAggregateArgs>): Prisma.PrismaPromise<GetMessagesAggregateType<T>>

    /**
     * Group by Messages.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MessagesGroupByArgs} args - Group by arguments.
     * @example
     * // Group by city, order by createdAt, get count
     * const result = await prisma.user.groupBy({
     *   by: ['city', 'createdAt'],
     *   orderBy: {
     *     createdAt: true
     *   },
     *   _count: {
     *     _all: true
     *   },
     * })
     * 
    **/
    groupBy<
      T extends MessagesGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: MessagesGroupByArgs['orderBy'] }
        : { orderBy?: MessagesGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, MessagesGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetMessagesGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Messages model
   */
  readonly fields: MessagesFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Messages.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__MessagesClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> 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 Messages model
   */ 
  interface MessagesFieldRefs {
    readonly id: FieldRef<"Messages", 'Int'>
    readonly email: FieldRef<"Messages", 'String'>
    readonly name: FieldRef<"Messages", 'String'>
    readonly phone: FieldRef<"Messages", 'String'>
    readonly message: FieldRef<"Messages", 'String'>
    readonly date: FieldRef<"Messages", 'DateTime'>
  }
    

  // Custom InputTypes

  /**
   * Messages findUnique
   */
  export type MessagesFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Messages
     */
    select?: MessagesSelect<ExtArgs> | null
    /**
     * Filter, which Messages to fetch.
     */
    where: MessagesWhereUniqueInput
  }


  /**
   * Messages findUniqueOrThrow
   */
  export type MessagesFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Messages
     */
    select?: MessagesSelect<ExtArgs> | null
    /**
     * Filter, which Messages to fetch.
     */
    where: MessagesWhereUniqueInput
  }


  /**
   * Messages findFirst
   */
  export type MessagesFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Messages
     */
    select?: MessagesSelect<ExtArgs> | null
    /**
     * Filter, which Messages to fetch.
     */
    where?: MessagesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Messages to fetch.
     */
    orderBy?: MessagesOrderByWithRelationInput | MessagesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Messages.
     */
    cursor?: MessagesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Messages from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Messages.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Messages.
     */
    distinct?: MessagesScalarFieldEnum | MessagesScalarFieldEnum[]
  }


  /**
   * Messages findFirstOrThrow
   */
  export type MessagesFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Messages
     */
    select?: MessagesSelect<ExtArgs> | null
    /**
     * Filter, which Messages to fetch.
     */
    where?: MessagesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Messages to fetch.
     */
    orderBy?: MessagesOrderByWithRelationInput | MessagesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Messages.
     */
    cursor?: MessagesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Messages from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Messages.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Messages.
     */
    distinct?: MessagesScalarFieldEnum | MessagesScalarFieldEnum[]
  }


  /**
   * Messages findMany
   */
  export type MessagesFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Messages
     */
    select?: MessagesSelect<ExtArgs> | null
    /**
     * Filter, which Messages to fetch.
     */
    where?: MessagesWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Messages to fetch.
     */
    orderBy?: MessagesOrderByWithRelationInput | MessagesOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Messages.
     */
    cursor?: MessagesWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Messages from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Messages.
     */
    skip?: number
    distinct?: MessagesScalarFieldEnum | MessagesScalarFieldEnum[]
  }


  /**
   * Messages create
   */
  export type MessagesCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Messages
     */
    select?: MessagesSelect<ExtArgs> | null
    /**
     * The data needed to create a Messages.
     */
    data: XOR<MessagesCreateInput, MessagesUncheckedCreateInput>
  }


  /**
   * Messages createMany
   */
  export type MessagesCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Messages.
     */
    data: MessagesCreateManyInput | MessagesCreateManyInput[]
    skipDuplicates?: boolean
  }


  /**
   * Messages update
   */
  export type MessagesUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Messages
     */
    select?: MessagesSelect<ExtArgs> | null
    /**
     * The data needed to update a Messages.
     */
    data: XOR<MessagesUpdateInput, MessagesUncheckedUpdateInput>
    /**
     * Choose, which Messages to update.
     */
    where: MessagesWhereUniqueInput
  }


  /**
   * Messages updateMany
   */
  export type MessagesUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Messages.
     */
    data: XOR<MessagesUpdateManyMutationInput, MessagesUncheckedUpdateManyInput>
    /**
     * Filter which Messages to update
     */
    where?: MessagesWhereInput
  }


  /**
   * Messages upsert
   */
  export type MessagesUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Messages
     */
    select?: MessagesSelect<ExtArgs> | null
    /**
     * The filter to search for the Messages to update in case it exists.
     */
    where: MessagesWhereUniqueInput
    /**
     * In case the Messages found by the `where` argument doesn't exist, create a new Messages with this data.
     */
    create: XOR<MessagesCreateInput, MessagesUncheckedCreateInput>
    /**
     * In case the Messages was found with the provided `where` argument, update it with this data.
     */
    update: XOR<MessagesUpdateInput, MessagesUncheckedUpdateInput>
  }


  /**
   * Messages delete
   */
  export type MessagesDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Messages
     */
    select?: MessagesSelect<ExtArgs> | null
    /**
     * Filter which Messages to delete.
     */
    where: MessagesWhereUniqueInput
  }


  /**
   * Messages deleteMany
   */
  export type MessagesDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Messages to delete
     */
    where?: MessagesWhereInput
  }


  /**
   * Messages without action
   */
  export type MessagesDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Messages
     */
    select?: MessagesSelect<ExtArgs> | null
  }



  /**
   * Enums
   */

  export const TransactionIsolationLevel: {
    ReadUncommitted: 'ReadUncommitted',
    ReadCommitted: 'ReadCommitted',
    RepeatableRead: 'RepeatableRead',
    Serializable: 'Serializable'
  };

  export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel]


  export const LatestNewsScalarFieldEnum: {
    id: 'id',
    news: 'news'
  };

  export type LatestNewsScalarFieldEnum = (typeof LatestNewsScalarFieldEnum)[keyof typeof LatestNewsScalarFieldEnum]


  export const SliderImagesScalarFieldEnum: {
    id: 'id',
    image: 'image',
    caption: 'caption'
  };

  export type SliderImagesScalarFieldEnum = (typeof SliderImagesScalarFieldEnum)[keyof typeof SliderImagesScalarFieldEnum]


  export const MissionsScalarFieldEnum: {
    id: 'id',
    text: 'text',
    pdfName: 'pdfName'
  };

  export type MissionsScalarFieldEnum = (typeof MissionsScalarFieldEnum)[keyof typeof MissionsScalarFieldEnum]


  export const ObjectivesScalarFieldEnum: {
    id: 'id',
    text: 'text',
    bg: 'bg',
    missionsId: 'missionsId'
  };

  export type ObjectivesScalarFieldEnum = (typeof ObjectivesScalarFieldEnum)[keyof typeof ObjectivesScalarFieldEnum]


  export const HomeDataScalarFieldEnum: {
    id: 'id',
    title: 'title',
    text: 'text',
    image: 'image',
    pdf: 'pdf'
  };

  export type HomeDataScalarFieldEnum = (typeof HomeDataScalarFieldEnum)[keyof typeof HomeDataScalarFieldEnum]


  export const BriefDataScalarFieldEnum: {
    id: 'id',
    text: 'text',
    image: 'image'
  };

  export type BriefDataScalarFieldEnum = (typeof BriefDataScalarFieldEnum)[keyof typeof BriefDataScalarFieldEnum]


  export const ServiceDataScalarFieldEnum: {
    id: 'id',
    text: 'text',
    bg: 'bg',
    bg2: 'bg2'
  };

  export type ServiceDataScalarFieldEnum = (typeof ServiceDataScalarFieldEnum)[keyof typeof ServiceDataScalarFieldEnum]


  export const ActivitiesDataScalarFieldEnum: {
    id: 'id',
    text: 'text',
    bg: 'bg',
    bg2: 'bg2'
  };

  export type ActivitiesDataScalarFieldEnum = (typeof ActivitiesDataScalarFieldEnum)[keyof typeof ActivitiesDataScalarFieldEnum]


  export const FormerChairmanScalarFieldEnum: {
    id: 'id',
    name: 'name',
    position: 'position',
    period: 'period'
  };

  export type FormerChairmanScalarFieldEnum = (typeof FormerChairmanScalarFieldEnum)[keyof typeof FormerChairmanScalarFieldEnum]


  export const FormerSrViceChairmanScalarFieldEnum: {
    id: 'id',
    name: 'name',
    position: 'position',
    period: 'period'
  };

  export type FormerSrViceChairmanScalarFieldEnum = (typeof FormerSrViceChairmanScalarFieldEnum)[keyof typeof FormerSrViceChairmanScalarFieldEnum]


  export const FormerViceChairmanScalarFieldEnum: {
    id: 'id',
    name: 'name',
    position: 'position',
    period: 'period'
  };

  export type FormerViceChairmanScalarFieldEnum = (typeof FormerViceChairmanScalarFieldEnum)[keyof typeof FormerViceChairmanScalarFieldEnum]


  export const ChairmanProfileScalarFieldEnum: {
    id: 'id',
    image: 'image',
    name: 'name',
    academic: 'academic',
    profession: 'profession',
    business: 'business',
    presentPosition: 'presentPosition',
    foreignTravel: 'foreignTravel'
  };

  export type ChairmanProfileScalarFieldEnum = (typeof ChairmanProfileScalarFieldEnum)[keyof typeof ChairmanProfileScalarFieldEnum]


  export const ChairmanAssociationScalarFieldEnum: {
    id: 'id',
    name: 'name',
    text: 'text',
    ChairmanProfileId: 'ChairmanProfileId'
  };

  export type ChairmanAssociationScalarFieldEnum = (typeof ChairmanAssociationScalarFieldEnum)[keyof typeof ChairmanAssociationScalarFieldEnum]


  export const ChairmanClubsScalarFieldEnum: {
    id: 'id',
    name: 'name',
    text: 'text',
    ChairmanProfileId: 'ChairmanProfileId'
  };

  export type ChairmanClubsScalarFieldEnum = (typeof ChairmanClubsScalarFieldEnum)[keyof typeof ChairmanClubsScalarFieldEnum]


  export const ChairmanMessageScalarFieldEnum: {
    id: 'id',
    message: 'message'
  };

  export type ChairmanMessageScalarFieldEnum = (typeof ChairmanMessageScalarFieldEnum)[keyof typeof ChairmanMessageScalarFieldEnum]


  export const ChairmanSpeechScalarFieldEnum: {
    id: 'id',
    name: 'name',
    pdf: 'pdf',
    date: 'date'
  };

  export type ChairmanSpeechScalarFieldEnum = (typeof ChairmanSpeechScalarFieldEnum)[keyof typeof ChairmanSpeechScalarFieldEnum]


  export const ChairmanInterviewPrintScalarFieldEnum: {
    id: 'id',
    name: 'name',
    pdf: 'pdf',
    date: 'date'
  };

  export type ChairmanInterviewPrintScalarFieldEnum = (typeof ChairmanInterviewPrintScalarFieldEnum)[keyof typeof ChairmanInterviewPrintScalarFieldEnum]


  export const ChairmanInterviewElectronicScalarFieldEnum: {
    id: 'id',
    title: 'title',
    link: 'link'
  };

  export type ChairmanInterviewElectronicScalarFieldEnum = (typeof ChairmanInterviewElectronicScalarFieldEnum)[keyof typeof ChairmanInterviewElectronicScalarFieldEnum]


  export const ChairmanPresentationScalarFieldEnum: {
    id: 'id',
    name: 'name',
    pdf: 'pdf',
    date: 'date'
  };

  export type ChairmanPresentationScalarFieldEnum = (typeof ChairmanPresentationScalarFieldEnum)[keyof typeof ChairmanPresentationScalarFieldEnum]


  export const MemorandumScalarFieldEnum: {
    id: 'id',
    pdf: 'pdf'
  };

  export type MemorandumScalarFieldEnum = (typeof MemorandumScalarFieldEnum)[keyof typeof MemorandumScalarFieldEnum]


  export const BoardOfDirectorsScalarFieldEnum: {
    id: 'id',
    image: 'image',
    name: 'name',
    designation: 'designation'
  };

  export type BoardOfDirectorsScalarFieldEnum = (typeof BoardOfDirectorsScalarFieldEnum)[keyof typeof BoardOfDirectorsScalarFieldEnum]


  export const ShippersNewsScalarFieldEnum: {
    id: 'id',
    image: 'image',
    name: 'name',
    date: 'date',
    volume: 'volume',
    pdf: 'pdf'
  };

  export type ShippersNewsScalarFieldEnum = (typeof ShippersNewsScalarFieldEnum)[keyof typeof ShippersNewsScalarFieldEnum]


  export const AnnualReportScalarFieldEnum: {
    id: 'id',
    image: 'image',
    name: 'name',
    date: 'date',
    pdf: 'pdf'
  };

  export type AnnualReportScalarFieldEnum = (typeof AnnualReportScalarFieldEnum)[keyof typeof AnnualReportScalarFieldEnum]


  export const OtherPublicationsScalarFieldEnum: {
    id: 'id',
    image: 'image',
    name: 'name',
    date: 'date',
    pdf: 'pdf'
  };

  export type OtherPublicationsScalarFieldEnum = (typeof OtherPublicationsScalarFieldEnum)[keyof typeof OtherPublicationsScalarFieldEnum]


  export const SCBRecommendationsScalarFieldEnum: {
    id: 'id',
    type: 'type',
    name: 'name',
    date: 'date',
    pdf: 'pdf'
  };

  export type SCBRecommendationsScalarFieldEnum = (typeof SCBRecommendationsScalarFieldEnum)[keyof typeof SCBRecommendationsScalarFieldEnum]


  export const SCBSeminarScalarFieldEnum: {
    id: 'id',
    type: 'type',
    name: 'name',
    date: 'date',
    pdf: 'pdf'
  };

  export type SCBSeminarScalarFieldEnum = (typeof SCBSeminarScalarFieldEnum)[keyof typeof SCBSeminarScalarFieldEnum]


  export const EligibilityScalarFieldEnum: {
    id: 'id',
    type: 'type',
    text: 'text',
    admission: 'admission',
    subscription: 'subscription'
  };

  export type EligibilityScalarFieldEnum = (typeof EligibilityScalarFieldEnum)[keyof typeof EligibilityScalarFieldEnum]


  export const RelevantPapersScalarFieldEnum: {
    id: 'id',
    type: 'type',
    papers: 'papers'
  };

  export type RelevantPapersScalarFieldEnum = (typeof RelevantPapersScalarFieldEnum)[keyof typeof RelevantPapersScalarFieldEnum]


  export const MembersListScalarFieldEnum: {
    id: 'id',
    name: 'name',
    type: 'type',
    membershipId: 'membershipId'
  };

  export type MembersListScalarFieldEnum = (typeof MembersListScalarFieldEnum)[keyof typeof MembersListScalarFieldEnum]


  export const UsefulLinksScalarFieldEnum: {
    id: 'id',
    type: 'type',
    logo: 'logo',
    Name: 'Name',
    text: 'text'
  };

  export type UsefulLinksScalarFieldEnum = (typeof UsefulLinksScalarFieldEnum)[keyof typeof UsefulLinksScalarFieldEnum]


  export const ContactUsScalarFieldEnum: {
    id: 'id',
    address: 'address',
    telephone: 'telephone',
    email: 'email'
  };

  export type ContactUsScalarFieldEnum = (typeof ContactUsScalarFieldEnum)[keyof typeof ContactUsScalarFieldEnum]


  export const SecretariatScalarFieldEnum: {
    id: 'id',
    name: 'name',
    position: 'position'
  };

  export type SecretariatScalarFieldEnum = (typeof SecretariatScalarFieldEnum)[keyof typeof SecretariatScalarFieldEnum]


  export const PDFsScalarFieldEnum: {
    id: 'id',
    pdf: 'pdf',
    image: 'image',
    title: 'title',
    type: 'type'
  };

  export type PDFsScalarFieldEnum = (typeof PDFsScalarFieldEnum)[keyof typeof PDFsScalarFieldEnum]


  export const FormsScalarFieldEnum: {
    id: 'id',
    pdf: 'pdf',
    title: 'title',
    type: 'type'
  };

  export type FormsScalarFieldEnum = (typeof FormsScalarFieldEnum)[keyof typeof FormsScalarFieldEnum]


  export const MembershipTextScalarFieldEnum: {
    id: 'id',
    title: 'title',
    text: 'text'
  };

  export type MembershipTextScalarFieldEnum = (typeof MembershipTextScalarFieldEnum)[keyof typeof MembershipTextScalarFieldEnum]


  export const ApplicationProcedureScalarFieldEnum: {
    id: 'id',
    text: 'text'
  };

  export type ApplicationProcedureScalarFieldEnum = (typeof ApplicationProcedureScalarFieldEnum)[keyof typeof ApplicationProcedureScalarFieldEnum]


  export const BenefitsScalarFieldEnum: {
    id: 'id',
    benefits: 'benefits',
    advantages: 'advantages'
  };

  export type BenefitsScalarFieldEnum = (typeof BenefitsScalarFieldEnum)[keyof typeof BenefitsScalarFieldEnum]


  export const PhotoAlbumScalarFieldEnum: {
    id: 'id',
    title: 'title'
  };

  export type PhotoAlbumScalarFieldEnum = (typeof PhotoAlbumScalarFieldEnum)[keyof typeof PhotoAlbumScalarFieldEnum]


  export const GalleryPhotoScalarFieldEnum: {
    id: 'id',
    image: 'image',
    PhotoAlbumId: 'PhotoAlbumId'
  };

  export type GalleryPhotoScalarFieldEnum = (typeof GalleryPhotoScalarFieldEnum)[keyof typeof GalleryPhotoScalarFieldEnum]


  export const GalleryVideoScalarFieldEnum: {
    id: 'id',
    title: 'title',
    link: 'link'
  };

  export type GalleryVideoScalarFieldEnum = (typeof GalleryVideoScalarFieldEnum)[keyof typeof GalleryVideoScalarFieldEnum]


  export const CondolenceScalarFieldEnum: {
    id: 'id',
    name: 'name',
    position: 'position',
    period: 'period',
    featured: 'featured',
    image: 'image',
    text: 'text'
  };

  export type CondolenceScalarFieldEnum = (typeof CondolenceScalarFieldEnum)[keyof typeof CondolenceScalarFieldEnum]


  export const AffiliatesScalarFieldEnum: {
    id: 'id',
    logo: 'logo'
  };

  export type AffiliatesScalarFieldEnum = (typeof AffiliatesScalarFieldEnum)[keyof typeof AffiliatesScalarFieldEnum]


  export const SubscribersScalarFieldEnum: {
    id: 'id',
    email: 'email',
    date: 'date'
  };

  export type SubscribersScalarFieldEnum = (typeof SubscribersScalarFieldEnum)[keyof typeof SubscribersScalarFieldEnum]


  export const MessagesScalarFieldEnum: {
    id: 'id',
    email: 'email',
    name: 'name',
    phone: 'phone',
    message: 'message',
    date: 'date'
  };

  export type MessagesScalarFieldEnum = (typeof MessagesScalarFieldEnum)[keyof typeof MessagesScalarFieldEnum]


  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 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 'Int'
   */
  export type IntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int'>
    


  /**
   * Reference to a field of type 'String'
   */
  export type StringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String'>
    


  /**
   * Reference to a field of type 'Json'
   */
  export type JsonFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Json'>
    


  /**
   * Reference to a field of type 'Boolean'
   */
  export type BooleanFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Boolean'>
    


  /**
   * Reference to a field of type 'DateTime'
   */
  export type DateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime'>
    


  /**
   * Reference to a field of type 'Float'
   */
  export type FloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float'>
    
  /**
   * Deep Input Types
   */


  export type latestNewsWhereInput = {
    AND?: latestNewsWhereInput | latestNewsWhereInput[]
    OR?: latestNewsWhereInput[]
    NOT?: latestNewsWhereInput | latestNewsWhereInput[]
    id?: IntFilter<"latestNews"> | number
    news?: StringFilter<"latestNews"> | string
  }

  export type latestNewsOrderByWithRelationInput = {
    id?: SortOrder
    news?: SortOrder
  }

  export type latestNewsWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: latestNewsWhereInput | latestNewsWhereInput[]
    OR?: latestNewsWhereInput[]
    NOT?: latestNewsWhereInput | latestNewsWhereInput[]
    news?: StringFilter<"latestNews"> | string
  }, "id">

  export type latestNewsOrderByWithAggregationInput = {
    id?: SortOrder
    news?: SortOrder
    _count?: latestNewsCountOrderByAggregateInput
    _avg?: latestNewsAvgOrderByAggregateInput
    _max?: latestNewsMaxOrderByAggregateInput
    _min?: latestNewsMinOrderByAggregateInput
    _sum?: latestNewsSumOrderByAggregateInput
  }

  export type latestNewsScalarWhereWithAggregatesInput = {
    AND?: latestNewsScalarWhereWithAggregatesInput | latestNewsScalarWhereWithAggregatesInput[]
    OR?: latestNewsScalarWhereWithAggregatesInput[]
    NOT?: latestNewsScalarWhereWithAggregatesInput | latestNewsScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"latestNews"> | number
    news?: StringWithAggregatesFilter<"latestNews"> | string
  }

  export type sliderImagesWhereInput = {
    AND?: sliderImagesWhereInput | sliderImagesWhereInput[]
    OR?: sliderImagesWhereInput[]
    NOT?: sliderImagesWhereInput | sliderImagesWhereInput[]
    id?: IntFilter<"sliderImages"> | number
    image?: StringFilter<"sliderImages"> | string
    caption?: StringFilter<"sliderImages"> | string
  }

  export type sliderImagesOrderByWithRelationInput = {
    id?: SortOrder
    image?: SortOrder
    caption?: SortOrder
  }

  export type sliderImagesWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: sliderImagesWhereInput | sliderImagesWhereInput[]
    OR?: sliderImagesWhereInput[]
    NOT?: sliderImagesWhereInput | sliderImagesWhereInput[]
    image?: StringFilter<"sliderImages"> | string
    caption?: StringFilter<"sliderImages"> | string
  }, "id">

  export type sliderImagesOrderByWithAggregationInput = {
    id?: SortOrder
    image?: SortOrder
    caption?: SortOrder
    _count?: sliderImagesCountOrderByAggregateInput
    _avg?: sliderImagesAvgOrderByAggregateInput
    _max?: sliderImagesMaxOrderByAggregateInput
    _min?: sliderImagesMinOrderByAggregateInput
    _sum?: sliderImagesSumOrderByAggregateInput
  }

  export type sliderImagesScalarWhereWithAggregatesInput = {
    AND?: sliderImagesScalarWhereWithAggregatesInput | sliderImagesScalarWhereWithAggregatesInput[]
    OR?: sliderImagesScalarWhereWithAggregatesInput[]
    NOT?: sliderImagesScalarWhereWithAggregatesInput | sliderImagesScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"sliderImages"> | number
    image?: StringWithAggregatesFilter<"sliderImages"> | string
    caption?: StringWithAggregatesFilter<"sliderImages"> | string
  }

  export type missionsWhereInput = {
    AND?: missionsWhereInput | missionsWhereInput[]
    OR?: missionsWhereInput[]
    NOT?: missionsWhereInput | missionsWhereInput[]
    id?: IntFilter<"missions"> | number
    text?: StringFilter<"missions"> | string
    pdfName?: StringFilter<"missions"> | string
    objectiveList?: ObjectivesListRelationFilter
  }

  export type missionsOrderByWithRelationInput = {
    id?: SortOrder
    text?: SortOrder
    pdfName?: SortOrder
    objectiveList?: objectivesOrderByRelationAggregateInput
  }

  export type missionsWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: missionsWhereInput | missionsWhereInput[]
    OR?: missionsWhereInput[]
    NOT?: missionsWhereInput | missionsWhereInput[]
    text?: StringFilter<"missions"> | string
    pdfName?: StringFilter<"missions"> | string
    objectiveList?: ObjectivesListRelationFilter
  }, "id">

  export type missionsOrderByWithAggregationInput = {
    id?: SortOrder
    text?: SortOrder
    pdfName?: SortOrder
    _count?: missionsCountOrderByAggregateInput
    _avg?: missionsAvgOrderByAggregateInput
    _max?: missionsMaxOrderByAggregateInput
    _min?: missionsMinOrderByAggregateInput
    _sum?: missionsSumOrderByAggregateInput
  }

  export type missionsScalarWhereWithAggregatesInput = {
    AND?: missionsScalarWhereWithAggregatesInput | missionsScalarWhereWithAggregatesInput[]
    OR?: missionsScalarWhereWithAggregatesInput[]
    NOT?: missionsScalarWhereWithAggregatesInput | missionsScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"missions"> | number
    text?: StringWithAggregatesFilter<"missions"> | string
    pdfName?: StringWithAggregatesFilter<"missions"> | string
  }

  export type objectivesWhereInput = {
    AND?: objectivesWhereInput | objectivesWhereInput[]
    OR?: objectivesWhereInput[]
    NOT?: objectivesWhereInput | objectivesWhereInput[]
    id?: IntFilter<"objectives"> | number
    text?: StringFilter<"objectives"> | string
    bg?: StringFilter<"objectives"> | string
    missionsId?: IntNullableFilter<"objectives"> | number | null
    missions?: XOR<MissionsNullableRelationFilter, missionsWhereInput> | null
  }

  export type objectivesOrderByWithRelationInput = {
    id?: SortOrder
    text?: SortOrder
    bg?: SortOrder
    missionsId?: SortOrderInput | SortOrder
    missions?: missionsOrderByWithRelationInput
  }

  export type objectivesWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: objectivesWhereInput | objectivesWhereInput[]
    OR?: objectivesWhereInput[]
    NOT?: objectivesWhereInput | objectivesWhereInput[]
    text?: StringFilter<"objectives"> | string
    bg?: StringFilter<"objectives"> | string
    missionsId?: IntNullableFilter<"objectives"> | number | null
    missions?: XOR<MissionsNullableRelationFilter, missionsWhereInput> | null
  }, "id">

  export type objectivesOrderByWithAggregationInput = {
    id?: SortOrder
    text?: SortOrder
    bg?: SortOrder
    missionsId?: SortOrderInput | SortOrder
    _count?: objectivesCountOrderByAggregateInput
    _avg?: objectivesAvgOrderByAggregateInput
    _max?: objectivesMaxOrderByAggregateInput
    _min?: objectivesMinOrderByAggregateInput
    _sum?: objectivesSumOrderByAggregateInput
  }

  export type objectivesScalarWhereWithAggregatesInput = {
    AND?: objectivesScalarWhereWithAggregatesInput | objectivesScalarWhereWithAggregatesInput[]
    OR?: objectivesScalarWhereWithAggregatesInput[]
    NOT?: objectivesScalarWhereWithAggregatesInput | objectivesScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"objectives"> | number
    text?: StringWithAggregatesFilter<"objectives"> | string
    bg?: StringWithAggregatesFilter<"objectives"> | string
    missionsId?: IntNullableWithAggregatesFilter<"objectives"> | number | null
  }

  export type homeDataWhereInput = {
    AND?: homeDataWhereInput | homeDataWhereInput[]
    OR?: homeDataWhereInput[]
    NOT?: homeDataWhereInput | homeDataWhereInput[]
    id?: IntFilter<"homeData"> | number
    title?: StringFilter<"homeData"> | string
    text?: StringFilter<"homeData"> | string
    image?: JsonNullableFilter<"homeData">
    pdf?: StringNullableFilter<"homeData"> | string | null
  }

  export type homeDataOrderByWithRelationInput = {
    id?: SortOrder
    title?: SortOrder
    text?: SortOrder
    image?: SortOrderInput | SortOrder
    pdf?: SortOrderInput | SortOrder
  }

  export type homeDataWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: homeDataWhereInput | homeDataWhereInput[]
    OR?: homeDataWhereInput[]
    NOT?: homeDataWhereInput | homeDataWhereInput[]
    title?: StringFilter<"homeData"> | string
    text?: StringFilter<"homeData"> | string
    image?: JsonNullableFilter<"homeData">
    pdf?: StringNullableFilter<"homeData"> | string | null
  }, "id">

  export type homeDataOrderByWithAggregationInput = {
    id?: SortOrder
    title?: SortOrder
    text?: SortOrder
    image?: SortOrderInput | SortOrder
    pdf?: SortOrderInput | SortOrder
    _count?: homeDataCountOrderByAggregateInput
    _avg?: homeDataAvgOrderByAggregateInput
    _max?: homeDataMaxOrderByAggregateInput
    _min?: homeDataMinOrderByAggregateInput
    _sum?: homeDataSumOrderByAggregateInput
  }

  export type homeDataScalarWhereWithAggregatesInput = {
    AND?: homeDataScalarWhereWithAggregatesInput | homeDataScalarWhereWithAggregatesInput[]
    OR?: homeDataScalarWhereWithAggregatesInput[]
    NOT?: homeDataScalarWhereWithAggregatesInput | homeDataScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"homeData"> | number
    title?: StringWithAggregatesFilter<"homeData"> | string
    text?: StringWithAggregatesFilter<"homeData"> | string
    image?: JsonNullableWithAggregatesFilter<"homeData">
    pdf?: StringNullableWithAggregatesFilter<"homeData"> | string | null
  }

  export type briefDataWhereInput = {
    AND?: briefDataWhereInput | briefDataWhereInput[]
    OR?: briefDataWhereInput[]
    NOT?: briefDataWhereInput | briefDataWhereInput[]
    id?: IntFilter<"briefData"> | number
    text?: StringFilter<"briefData"> | string
    image?: JsonNullableFilter<"briefData">
  }

  export type briefDataOrderByWithRelationInput = {
    id?: SortOrder
    text?: SortOrder
    image?: SortOrderInput | SortOrder
  }

  export type briefDataWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: briefDataWhereInput | briefDataWhereInput[]
    OR?: briefDataWhereInput[]
    NOT?: briefDataWhereInput | briefDataWhereInput[]
    text?: StringFilter<"briefData"> | string
    image?: JsonNullableFilter<"briefData">
  }, "id">

  export type briefDataOrderByWithAggregationInput = {
    id?: SortOrder
    text?: SortOrder
    image?: SortOrderInput | SortOrder
    _count?: briefDataCountOrderByAggregateInput
    _avg?: briefDataAvgOrderByAggregateInput
    _max?: briefDataMaxOrderByAggregateInput
    _min?: briefDataMinOrderByAggregateInput
    _sum?: briefDataSumOrderByAggregateInput
  }

  export type briefDataScalarWhereWithAggregatesInput = {
    AND?: briefDataScalarWhereWithAggregatesInput | briefDataScalarWhereWithAggregatesInput[]
    OR?: briefDataScalarWhereWithAggregatesInput[]
    NOT?: briefDataScalarWhereWithAggregatesInput | briefDataScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"briefData"> | number
    text?: StringWithAggregatesFilter<"briefData"> | string
    image?: JsonNullableWithAggregatesFilter<"briefData">
  }

  export type serviceDataWhereInput = {
    AND?: serviceDataWhereInput | serviceDataWhereInput[]
    OR?: serviceDataWhereInput[]
    NOT?: serviceDataWhereInput | serviceDataWhereInput[]
    id?: IntFilter<"serviceData"> | number
    text?: StringFilter<"serviceData"> | string
    bg?: StringFilter<"serviceData"> | string
    bg2?: StringFilter<"serviceData"> | string
  }

  export type serviceDataOrderByWithRelationInput = {
    id?: SortOrder
    text?: SortOrder
    bg?: SortOrder
    bg2?: SortOrder
  }

  export type serviceDataWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: serviceDataWhereInput | serviceDataWhereInput[]
    OR?: serviceDataWhereInput[]
    NOT?: serviceDataWhereInput | serviceDataWhereInput[]
    text?: StringFilter<"serviceData"> | string
    bg?: StringFilter<"serviceData"> | string
    bg2?: StringFilter<"serviceData"> | string
  }, "id">

  export type serviceDataOrderByWithAggregationInput = {
    id?: SortOrder
    text?: SortOrder
    bg?: SortOrder
    bg2?: SortOrder
    _count?: serviceDataCountOrderByAggregateInput
    _avg?: serviceDataAvgOrderByAggregateInput
    _max?: serviceDataMaxOrderByAggregateInput
    _min?: serviceDataMinOrderByAggregateInput
    _sum?: serviceDataSumOrderByAggregateInput
  }

  export type serviceDataScalarWhereWithAggregatesInput = {
    AND?: serviceDataScalarWhereWithAggregatesInput | serviceDataScalarWhereWithAggregatesInput[]
    OR?: serviceDataScalarWhereWithAggregatesInput[]
    NOT?: serviceDataScalarWhereWithAggregatesInput | serviceDataScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"serviceData"> | number
    text?: StringWithAggregatesFilter<"serviceData"> | string
    bg?: StringWithAggregatesFilter<"serviceData"> | string
    bg2?: StringWithAggregatesFilter<"serviceData"> | string
  }

  export type activitiesDataWhereInput = {
    AND?: activitiesDataWhereInput | activitiesDataWhereInput[]
    OR?: activitiesDataWhereInput[]
    NOT?: activitiesDataWhereInput | activitiesDataWhereInput[]
    id?: IntFilter<"activitiesData"> | number
    text?: StringFilter<"activitiesData"> | string
    bg?: StringFilter<"activitiesData"> | string
    bg2?: StringFilter<"activitiesData"> | string
  }

  export type activitiesDataOrderByWithRelationInput = {
    id?: SortOrder
    text?: SortOrder
    bg?: SortOrder
    bg2?: SortOrder
  }

  export type activitiesDataWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: activitiesDataWhereInput | activitiesDataWhereInput[]
    OR?: activitiesDataWhereInput[]
    NOT?: activitiesDataWhereInput | activitiesDataWhereInput[]
    text?: StringFilter<"activitiesData"> | string
    bg?: StringFilter<"activitiesData"> | string
    bg2?: StringFilter<"activitiesData"> | string
  }, "id">

  export type activitiesDataOrderByWithAggregationInput = {
    id?: SortOrder
    text?: SortOrder
    bg?: SortOrder
    bg2?: SortOrder
    _count?: activitiesDataCountOrderByAggregateInput
    _avg?: activitiesDataAvgOrderByAggregateInput
    _max?: activitiesDataMaxOrderByAggregateInput
    _min?: activitiesDataMinOrderByAggregateInput
    _sum?: activitiesDataSumOrderByAggregateInput
  }

  export type activitiesDataScalarWhereWithAggregatesInput = {
    AND?: activitiesDataScalarWhereWithAggregatesInput | activitiesDataScalarWhereWithAggregatesInput[]
    OR?: activitiesDataScalarWhereWithAggregatesInput[]
    NOT?: activitiesDataScalarWhereWithAggregatesInput | activitiesDataScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"activitiesData"> | number
    text?: StringWithAggregatesFilter<"activitiesData"> | string
    bg?: StringWithAggregatesFilter<"activitiesData"> | string
    bg2?: StringWithAggregatesFilter<"activitiesData"> | string
  }

  export type formerChairmanWhereInput = {
    AND?: formerChairmanWhereInput | formerChairmanWhereInput[]
    OR?: formerChairmanWhereInput[]
    NOT?: formerChairmanWhereInput | formerChairmanWhereInput[]
    id?: IntFilter<"formerChairman"> | number
    name?: StringFilter<"formerChairman"> | string
    position?: StringFilter<"formerChairman"> | string
    period?: StringFilter<"formerChairman"> | string
  }

  export type formerChairmanOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    position?: SortOrder
    period?: SortOrder
  }

  export type formerChairmanWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: formerChairmanWhereInput | formerChairmanWhereInput[]
    OR?: formerChairmanWhereInput[]
    NOT?: formerChairmanWhereInput | formerChairmanWhereInput[]
    name?: StringFilter<"formerChairman"> | string
    position?: StringFilter<"formerChairman"> | string
    period?: StringFilter<"formerChairman"> | string
  }, "id">

  export type formerChairmanOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    position?: SortOrder
    period?: SortOrder
    _count?: formerChairmanCountOrderByAggregateInput
    _avg?: formerChairmanAvgOrderByAggregateInput
    _max?: formerChairmanMaxOrderByAggregateInput
    _min?: formerChairmanMinOrderByAggregateInput
    _sum?: formerChairmanSumOrderByAggregateInput
  }

  export type formerChairmanScalarWhereWithAggregatesInput = {
    AND?: formerChairmanScalarWhereWithAggregatesInput | formerChairmanScalarWhereWithAggregatesInput[]
    OR?: formerChairmanScalarWhereWithAggregatesInput[]
    NOT?: formerChairmanScalarWhereWithAggregatesInput | formerChairmanScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"formerChairman"> | number
    name?: StringWithAggregatesFilter<"formerChairman"> | string
    position?: StringWithAggregatesFilter<"formerChairman"> | string
    period?: StringWithAggregatesFilter<"formerChairman"> | string
  }

  export type formerSrViceChairmanWhereInput = {
    AND?: formerSrViceChairmanWhereInput | formerSrViceChairmanWhereInput[]
    OR?: formerSrViceChairmanWhereInput[]
    NOT?: formerSrViceChairmanWhereInput | formerSrViceChairmanWhereInput[]
    id?: IntFilter<"formerSrViceChairman"> | number
    name?: StringFilter<"formerSrViceChairman"> | string
    position?: StringFilter<"formerSrViceChairman"> | string
    period?: StringFilter<"formerSrViceChairman"> | string
  }

  export type formerSrViceChairmanOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    position?: SortOrder
    period?: SortOrder
  }

  export type formerSrViceChairmanWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: formerSrViceChairmanWhereInput | formerSrViceChairmanWhereInput[]
    OR?: formerSrViceChairmanWhereInput[]
    NOT?: formerSrViceChairmanWhereInput | formerSrViceChairmanWhereInput[]
    name?: StringFilter<"formerSrViceChairman"> | string
    position?: StringFilter<"formerSrViceChairman"> | string
    period?: StringFilter<"formerSrViceChairman"> | string
  }, "id">

  export type formerSrViceChairmanOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    position?: SortOrder
    period?: SortOrder
    _count?: formerSrViceChairmanCountOrderByAggregateInput
    _avg?: formerSrViceChairmanAvgOrderByAggregateInput
    _max?: formerSrViceChairmanMaxOrderByAggregateInput
    _min?: formerSrViceChairmanMinOrderByAggregateInput
    _sum?: formerSrViceChairmanSumOrderByAggregateInput
  }

  export type formerSrViceChairmanScalarWhereWithAggregatesInput = {
    AND?: formerSrViceChairmanScalarWhereWithAggregatesInput | formerSrViceChairmanScalarWhereWithAggregatesInput[]
    OR?: formerSrViceChairmanScalarWhereWithAggregatesInput[]
    NOT?: formerSrViceChairmanScalarWhereWithAggregatesInput | formerSrViceChairmanScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"formerSrViceChairman"> | number
    name?: StringWithAggregatesFilter<"formerSrViceChairman"> | string
    position?: StringWithAggregatesFilter<"formerSrViceChairman"> | string
    period?: StringWithAggregatesFilter<"formerSrViceChairman"> | string
  }

  export type formerViceChairmanWhereInput = {
    AND?: formerViceChairmanWhereInput | formerViceChairmanWhereInput[]
    OR?: formerViceChairmanWhereInput[]
    NOT?: formerViceChairmanWhereInput | formerViceChairmanWhereInput[]
    id?: IntFilter<"formerViceChairman"> | number
    name?: StringFilter<"formerViceChairman"> | string
    position?: StringFilter<"formerViceChairman"> | string
    period?: StringFilter<"formerViceChairman"> | string
  }

  export type formerViceChairmanOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    position?: SortOrder
    period?: SortOrder
  }

  export type formerViceChairmanWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: formerViceChairmanWhereInput | formerViceChairmanWhereInput[]
    OR?: formerViceChairmanWhereInput[]
    NOT?: formerViceChairmanWhereInput | formerViceChairmanWhereInput[]
    name?: StringFilter<"formerViceChairman"> | string
    position?: StringFilter<"formerViceChairman"> | string
    period?: StringFilter<"formerViceChairman"> | string
  }, "id">

  export type formerViceChairmanOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    position?: SortOrder
    period?: SortOrder
    _count?: formerViceChairmanCountOrderByAggregateInput
    _avg?: formerViceChairmanAvgOrderByAggregateInput
    _max?: formerViceChairmanMaxOrderByAggregateInput
    _min?: formerViceChairmanMinOrderByAggregateInput
    _sum?: formerViceChairmanSumOrderByAggregateInput
  }

  export type formerViceChairmanScalarWhereWithAggregatesInput = {
    AND?: formerViceChairmanScalarWhereWithAggregatesInput | formerViceChairmanScalarWhereWithAggregatesInput[]
    OR?: formerViceChairmanScalarWhereWithAggregatesInput[]
    NOT?: formerViceChairmanScalarWhereWithAggregatesInput | formerViceChairmanScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"formerViceChairman"> | number
    name?: StringWithAggregatesFilter<"formerViceChairman"> | string
    position?: StringWithAggregatesFilter<"formerViceChairman"> | string
    period?: StringWithAggregatesFilter<"formerViceChairman"> | string
  }

  export type ChairmanProfileWhereInput = {
    AND?: ChairmanProfileWhereInput | ChairmanProfileWhereInput[]
    OR?: ChairmanProfileWhereInput[]
    NOT?: ChairmanProfileWhereInput | ChairmanProfileWhereInput[]
    id?: IntFilter<"ChairmanProfile"> | number
    image?: StringFilter<"ChairmanProfile"> | string
    name?: StringFilter<"ChairmanProfile"> | string
    academic?: StringFilter<"ChairmanProfile"> | string
    profession?: StringFilter<"ChairmanProfile"> | string
    business?: StringNullableFilter<"ChairmanProfile"> | string | null
    presentPosition?: StringFilter<"ChairmanProfile"> | string
    foreignTravel?: StringNullableFilter<"ChairmanProfile"> | string | null
    associations?: ChairmanAssociationListRelationFilter
    clubs?: ChairmanClubsListRelationFilter
  }

  export type ChairmanProfileOrderByWithRelationInput = {
    id?: SortOrder
    image?: SortOrder
    name?: SortOrder
    academic?: SortOrder
    profession?: SortOrder
    business?: SortOrderInput | SortOrder
    presentPosition?: SortOrder
    foreignTravel?: SortOrderInput | SortOrder
    associations?: ChairmanAssociationOrderByRelationAggregateInput
    clubs?: ChairmanClubsOrderByRelationAggregateInput
  }

  export type ChairmanProfileWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: ChairmanProfileWhereInput | ChairmanProfileWhereInput[]
    OR?: ChairmanProfileWhereInput[]
    NOT?: ChairmanProfileWhereInput | ChairmanProfileWhereInput[]
    image?: StringFilter<"ChairmanProfile"> | string
    name?: StringFilter<"ChairmanProfile"> | string
    academic?: StringFilter<"ChairmanProfile"> | string
    profession?: StringFilter<"ChairmanProfile"> | string
    business?: StringNullableFilter<"ChairmanProfile"> | string | null
    presentPosition?: StringFilter<"ChairmanProfile"> | string
    foreignTravel?: StringNullableFilter<"ChairmanProfile"> | string | null
    associations?: ChairmanAssociationListRelationFilter
    clubs?: ChairmanClubsListRelationFilter
  }, "id">

  export type ChairmanProfileOrderByWithAggregationInput = {
    id?: SortOrder
    image?: SortOrder
    name?: SortOrder
    academic?: SortOrder
    profession?: SortOrder
    business?: SortOrderInput | SortOrder
    presentPosition?: SortOrder
    foreignTravel?: SortOrderInput | SortOrder
    _count?: ChairmanProfileCountOrderByAggregateInput
    _avg?: ChairmanProfileAvgOrderByAggregateInput
    _max?: ChairmanProfileMaxOrderByAggregateInput
    _min?: ChairmanProfileMinOrderByAggregateInput
    _sum?: ChairmanProfileSumOrderByAggregateInput
  }

  export type ChairmanProfileScalarWhereWithAggregatesInput = {
    AND?: ChairmanProfileScalarWhereWithAggregatesInput | ChairmanProfileScalarWhereWithAggregatesInput[]
    OR?: ChairmanProfileScalarWhereWithAggregatesInput[]
    NOT?: ChairmanProfileScalarWhereWithAggregatesInput | ChairmanProfileScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"ChairmanProfile"> | number
    image?: StringWithAggregatesFilter<"ChairmanProfile"> | string
    name?: StringWithAggregatesFilter<"ChairmanProfile"> | string
    academic?: StringWithAggregatesFilter<"ChairmanProfile"> | string
    profession?: StringWithAggregatesFilter<"ChairmanProfile"> | string
    business?: StringNullableWithAggregatesFilter<"ChairmanProfile"> | string | null
    presentPosition?: StringWithAggregatesFilter<"ChairmanProfile"> | string
    foreignTravel?: StringNullableWithAggregatesFilter<"ChairmanProfile"> | string | null
  }

  export type ChairmanAssociationWhereInput = {
    AND?: ChairmanAssociationWhereInput | ChairmanAssociationWhereInput[]
    OR?: ChairmanAssociationWhereInput[]
    NOT?: ChairmanAssociationWhereInput | ChairmanAssociationWhereInput[]
    id?: IntFilter<"ChairmanAssociation"> | number
    name?: StringFilter<"ChairmanAssociation"> | string
    text?: StringFilter<"ChairmanAssociation"> | string
    ChairmanProfileId?: IntNullableFilter<"ChairmanAssociation"> | number | null
    profile?: XOR<ChairmanProfileNullableRelationFilter, ChairmanProfileWhereInput> | null
  }

  export type ChairmanAssociationOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    text?: SortOrder
    ChairmanProfileId?: SortOrderInput | SortOrder
    profile?: ChairmanProfileOrderByWithRelationInput
  }

  export type ChairmanAssociationWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: ChairmanAssociationWhereInput | ChairmanAssociationWhereInput[]
    OR?: ChairmanAssociationWhereInput[]
    NOT?: ChairmanAssociationWhereInput | ChairmanAssociationWhereInput[]
    name?: StringFilter<"ChairmanAssociation"> | string
    text?: StringFilter<"ChairmanAssociation"> | string
    ChairmanProfileId?: IntNullableFilter<"ChairmanAssociation"> | number | null
    profile?: XOR<ChairmanProfileNullableRelationFilter, ChairmanProfileWhereInput> | null
  }, "id">

  export type ChairmanAssociationOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    text?: SortOrder
    ChairmanProfileId?: SortOrderInput | SortOrder
    _count?: ChairmanAssociationCountOrderByAggregateInput
    _avg?: ChairmanAssociationAvgOrderByAggregateInput
    _max?: ChairmanAssociationMaxOrderByAggregateInput
    _min?: ChairmanAssociationMinOrderByAggregateInput
    _sum?: ChairmanAssociationSumOrderByAggregateInput
  }

  export type ChairmanAssociationScalarWhereWithAggregatesInput = {
    AND?: ChairmanAssociationScalarWhereWithAggregatesInput | ChairmanAssociationScalarWhereWithAggregatesInput[]
    OR?: ChairmanAssociationScalarWhereWithAggregatesInput[]
    NOT?: ChairmanAssociationScalarWhereWithAggregatesInput | ChairmanAssociationScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"ChairmanAssociation"> | number
    name?: StringWithAggregatesFilter<"ChairmanAssociation"> | string
    text?: StringWithAggregatesFilter<"ChairmanAssociation"> | string
    ChairmanProfileId?: IntNullableWithAggregatesFilter<"ChairmanAssociation"> | number | null
  }

  export type ChairmanClubsWhereInput = {
    AND?: ChairmanClubsWhereInput | ChairmanClubsWhereInput[]
    OR?: ChairmanClubsWhereInput[]
    NOT?: ChairmanClubsWhereInput | ChairmanClubsWhereInput[]
    id?: IntFilter<"ChairmanClubs"> | number
    name?: StringFilter<"ChairmanClubs"> | string
    text?: StringFilter<"ChairmanClubs"> | string
    ChairmanProfileId?: IntNullableFilter<"ChairmanClubs"> | number | null
    profile?: XOR<ChairmanProfileNullableRelationFilter, ChairmanProfileWhereInput> | null
  }

  export type ChairmanClubsOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    text?: SortOrder
    ChairmanProfileId?: SortOrderInput | SortOrder
    profile?: ChairmanProfileOrderByWithRelationInput
  }

  export type ChairmanClubsWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: ChairmanClubsWhereInput | ChairmanClubsWhereInput[]
    OR?: ChairmanClubsWhereInput[]
    NOT?: ChairmanClubsWhereInput | ChairmanClubsWhereInput[]
    name?: StringFilter<"ChairmanClubs"> | string
    text?: StringFilter<"ChairmanClubs"> | string
    ChairmanProfileId?: IntNullableFilter<"ChairmanClubs"> | number | null
    profile?: XOR<ChairmanProfileNullableRelationFilter, ChairmanProfileWhereInput> | null
  }, "id">

  export type ChairmanClubsOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    text?: SortOrder
    ChairmanProfileId?: SortOrderInput | SortOrder
    _count?: ChairmanClubsCountOrderByAggregateInput
    _avg?: ChairmanClubsAvgOrderByAggregateInput
    _max?: ChairmanClubsMaxOrderByAggregateInput
    _min?: ChairmanClubsMinOrderByAggregateInput
    _sum?: ChairmanClubsSumOrderByAggregateInput
  }

  export type ChairmanClubsScalarWhereWithAggregatesInput = {
    AND?: ChairmanClubsScalarWhereWithAggregatesInput | ChairmanClubsScalarWhereWithAggregatesInput[]
    OR?: ChairmanClubsScalarWhereWithAggregatesInput[]
    NOT?: ChairmanClubsScalarWhereWithAggregatesInput | ChairmanClubsScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"ChairmanClubs"> | number
    name?: StringWithAggregatesFilter<"ChairmanClubs"> | string
    text?: StringWithAggregatesFilter<"ChairmanClubs"> | string
    ChairmanProfileId?: IntNullableWithAggregatesFilter<"ChairmanClubs"> | number | null
  }

  export type ChairmanMessageWhereInput = {
    AND?: ChairmanMessageWhereInput | ChairmanMessageWhereInput[]
    OR?: ChairmanMessageWhereInput[]
    NOT?: ChairmanMessageWhereInput | ChairmanMessageWhereInput[]
    id?: IntFilter<"ChairmanMessage"> | number
    message?: StringFilter<"ChairmanMessage"> | string
  }

  export type ChairmanMessageOrderByWithRelationInput = {
    id?: SortOrder
    message?: SortOrder
  }

  export type ChairmanMessageWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: ChairmanMessageWhereInput | ChairmanMessageWhereInput[]
    OR?: ChairmanMessageWhereInput[]
    NOT?: ChairmanMessageWhereInput | ChairmanMessageWhereInput[]
    message?: StringFilter<"ChairmanMessage"> | string
  }, "id">

  export type ChairmanMessageOrderByWithAggregationInput = {
    id?: SortOrder
    message?: SortOrder
    _count?: ChairmanMessageCountOrderByAggregateInput
    _avg?: ChairmanMessageAvgOrderByAggregateInput
    _max?: ChairmanMessageMaxOrderByAggregateInput
    _min?: ChairmanMessageMinOrderByAggregateInput
    _sum?: ChairmanMessageSumOrderByAggregateInput
  }

  export type ChairmanMessageScalarWhereWithAggregatesInput = {
    AND?: ChairmanMessageScalarWhereWithAggregatesInput | ChairmanMessageScalarWhereWithAggregatesInput[]
    OR?: ChairmanMessageScalarWhereWithAggregatesInput[]
    NOT?: ChairmanMessageScalarWhereWithAggregatesInput | ChairmanMessageScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"ChairmanMessage"> | number
    message?: StringWithAggregatesFilter<"ChairmanMessage"> | string
  }

  export type ChairmanSpeechWhereInput = {
    AND?: ChairmanSpeechWhereInput | ChairmanSpeechWhereInput[]
    OR?: ChairmanSpeechWhereInput[]
    NOT?: ChairmanSpeechWhereInput | ChairmanSpeechWhereInput[]
    id?: IntFilter<"ChairmanSpeech"> | number
    name?: StringFilter<"ChairmanSpeech"> | string
    pdf?: StringFilter<"ChairmanSpeech"> | string
    date?: StringFilter<"ChairmanSpeech"> | string
  }

  export type ChairmanSpeechOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    pdf?: SortOrder
    date?: SortOrder
  }

  export type ChairmanSpeechWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: ChairmanSpeechWhereInput | ChairmanSpeechWhereInput[]
    OR?: ChairmanSpeechWhereInput[]
    NOT?: ChairmanSpeechWhereInput | ChairmanSpeechWhereInput[]
    name?: StringFilter<"ChairmanSpeech"> | string
    pdf?: StringFilter<"ChairmanSpeech"> | string
    date?: StringFilter<"ChairmanSpeech"> | string
  }, "id">

  export type ChairmanSpeechOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    pdf?: SortOrder
    date?: SortOrder
    _count?: ChairmanSpeechCountOrderByAggregateInput
    _avg?: ChairmanSpeechAvgOrderByAggregateInput
    _max?: ChairmanSpeechMaxOrderByAggregateInput
    _min?: ChairmanSpeechMinOrderByAggregateInput
    _sum?: ChairmanSpeechSumOrderByAggregateInput
  }

  export type ChairmanSpeechScalarWhereWithAggregatesInput = {
    AND?: ChairmanSpeechScalarWhereWithAggregatesInput | ChairmanSpeechScalarWhereWithAggregatesInput[]
    OR?: ChairmanSpeechScalarWhereWithAggregatesInput[]
    NOT?: ChairmanSpeechScalarWhereWithAggregatesInput | ChairmanSpeechScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"ChairmanSpeech"> | number
    name?: StringWithAggregatesFilter<"ChairmanSpeech"> | string
    pdf?: StringWithAggregatesFilter<"ChairmanSpeech"> | string
    date?: StringWithAggregatesFilter<"ChairmanSpeech"> | string
  }

  export type ChairmanInterviewPrintWhereInput = {
    AND?: ChairmanInterviewPrintWhereInput | ChairmanInterviewPrintWhereInput[]
    OR?: ChairmanInterviewPrintWhereInput[]
    NOT?: ChairmanInterviewPrintWhereInput | ChairmanInterviewPrintWhereInput[]
    id?: IntFilter<"ChairmanInterviewPrint"> | number
    name?: StringFilter<"ChairmanInterviewPrint"> | string
    pdf?: StringFilter<"ChairmanInterviewPrint"> | string
    date?: StringFilter<"ChairmanInterviewPrint"> | string
  }

  export type ChairmanInterviewPrintOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    pdf?: SortOrder
    date?: SortOrder
  }

  export type ChairmanInterviewPrintWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: ChairmanInterviewPrintWhereInput | ChairmanInterviewPrintWhereInput[]
    OR?: ChairmanInterviewPrintWhereInput[]
    NOT?: ChairmanInterviewPrintWhereInput | ChairmanInterviewPrintWhereInput[]
    name?: StringFilter<"ChairmanInterviewPrint"> | string
    pdf?: StringFilter<"ChairmanInterviewPrint"> | string
    date?: StringFilter<"ChairmanInterviewPrint"> | string
  }, "id">

  export type ChairmanInterviewPrintOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    pdf?: SortOrder
    date?: SortOrder
    _count?: ChairmanInterviewPrintCountOrderByAggregateInput
    _avg?: ChairmanInterviewPrintAvgOrderByAggregateInput
    _max?: ChairmanInterviewPrintMaxOrderByAggregateInput
    _min?: ChairmanInterviewPrintMinOrderByAggregateInput
    _sum?: ChairmanInterviewPrintSumOrderByAggregateInput
  }

  export type ChairmanInterviewPrintScalarWhereWithAggregatesInput = {
    AND?: ChairmanInterviewPrintScalarWhereWithAggregatesInput | ChairmanInterviewPrintScalarWhereWithAggregatesInput[]
    OR?: ChairmanInterviewPrintScalarWhereWithAggregatesInput[]
    NOT?: ChairmanInterviewPrintScalarWhereWithAggregatesInput | ChairmanInterviewPrintScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"ChairmanInterviewPrint"> | number
    name?: StringWithAggregatesFilter<"ChairmanInterviewPrint"> | string
    pdf?: StringWithAggregatesFilter<"ChairmanInterviewPrint"> | string
    date?: StringWithAggregatesFilter<"ChairmanInterviewPrint"> | string
  }

  export type ChairmanInterviewElectronicWhereInput = {
    AND?: ChairmanInterviewElectronicWhereInput | ChairmanInterviewElectronicWhereInput[]
    OR?: ChairmanInterviewElectronicWhereInput[]
    NOT?: ChairmanInterviewElectronicWhereInput | ChairmanInterviewElectronicWhereInput[]
    id?: IntFilter<"ChairmanInterviewElectronic"> | number
    title?: StringFilter<"ChairmanInterviewElectronic"> | string
    link?: StringFilter<"ChairmanInterviewElectronic"> | string
  }

  export type ChairmanInterviewElectronicOrderByWithRelationInput = {
    id?: SortOrder
    title?: SortOrder
    link?: SortOrder
  }

  export type ChairmanInterviewElectronicWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: ChairmanInterviewElectronicWhereInput | ChairmanInterviewElectronicWhereInput[]
    OR?: ChairmanInterviewElectronicWhereInput[]
    NOT?: ChairmanInterviewElectronicWhereInput | ChairmanInterviewElectronicWhereInput[]
    title?: StringFilter<"ChairmanInterviewElectronic"> | string
    link?: StringFilter<"ChairmanInterviewElectronic"> | string
  }, "id">

  export type ChairmanInterviewElectronicOrderByWithAggregationInput = {
    id?: SortOrder
    title?: SortOrder
    link?: SortOrder
    _count?: ChairmanInterviewElectronicCountOrderByAggregateInput
    _avg?: ChairmanInterviewElectronicAvgOrderByAggregateInput
    _max?: ChairmanInterviewElectronicMaxOrderByAggregateInput
    _min?: ChairmanInterviewElectronicMinOrderByAggregateInput
    _sum?: ChairmanInterviewElectronicSumOrderByAggregateInput
  }

  export type ChairmanInterviewElectronicScalarWhereWithAggregatesInput = {
    AND?: ChairmanInterviewElectronicScalarWhereWithAggregatesInput | ChairmanInterviewElectronicScalarWhereWithAggregatesInput[]
    OR?: ChairmanInterviewElectronicScalarWhereWithAggregatesInput[]
    NOT?: ChairmanInterviewElectronicScalarWhereWithAggregatesInput | ChairmanInterviewElectronicScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"ChairmanInterviewElectronic"> | number
    title?: StringWithAggregatesFilter<"ChairmanInterviewElectronic"> | string
    link?: StringWithAggregatesFilter<"ChairmanInterviewElectronic"> | string
  }

  export type ChairmanPresentationWhereInput = {
    AND?: ChairmanPresentationWhereInput | ChairmanPresentationWhereInput[]
    OR?: ChairmanPresentationWhereInput[]
    NOT?: ChairmanPresentationWhereInput | ChairmanPresentationWhereInput[]
    id?: IntFilter<"ChairmanPresentation"> | number
    name?: StringFilter<"ChairmanPresentation"> | string
    pdf?: StringFilter<"ChairmanPresentation"> | string
    date?: StringFilter<"ChairmanPresentation"> | string
  }

  export type ChairmanPresentationOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    pdf?: SortOrder
    date?: SortOrder
  }

  export type ChairmanPresentationWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: ChairmanPresentationWhereInput | ChairmanPresentationWhereInput[]
    OR?: ChairmanPresentationWhereInput[]
    NOT?: ChairmanPresentationWhereInput | ChairmanPresentationWhereInput[]
    name?: StringFilter<"ChairmanPresentation"> | string
    pdf?: StringFilter<"ChairmanPresentation"> | string
    date?: StringFilter<"ChairmanPresentation"> | string
  }, "id">

  export type ChairmanPresentationOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    pdf?: SortOrder
    date?: SortOrder
    _count?: ChairmanPresentationCountOrderByAggregateInput
    _avg?: ChairmanPresentationAvgOrderByAggregateInput
    _max?: ChairmanPresentationMaxOrderByAggregateInput
    _min?: ChairmanPresentationMinOrderByAggregateInput
    _sum?: ChairmanPresentationSumOrderByAggregateInput
  }

  export type ChairmanPresentationScalarWhereWithAggregatesInput = {
    AND?: ChairmanPresentationScalarWhereWithAggregatesInput | ChairmanPresentationScalarWhereWithAggregatesInput[]
    OR?: ChairmanPresentationScalarWhereWithAggregatesInput[]
    NOT?: ChairmanPresentationScalarWhereWithAggregatesInput | ChairmanPresentationScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"ChairmanPresentation"> | number
    name?: StringWithAggregatesFilter<"ChairmanPresentation"> | string
    pdf?: StringWithAggregatesFilter<"ChairmanPresentation"> | string
    date?: StringWithAggregatesFilter<"ChairmanPresentation"> | string
  }

  export type memorandumWhereInput = {
    AND?: memorandumWhereInput | memorandumWhereInput[]
    OR?: memorandumWhereInput[]
    NOT?: memorandumWhereInput | memorandumWhereInput[]
    id?: IntFilter<"memorandum"> | number
    pdf?: StringFilter<"memorandum"> | string
  }

  export type memorandumOrderByWithRelationInput = {
    id?: SortOrder
    pdf?: SortOrder
  }

  export type memorandumWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: memorandumWhereInput | memorandumWhereInput[]
    OR?: memorandumWhereInput[]
    NOT?: memorandumWhereInput | memorandumWhereInput[]
    pdf?: StringFilter<"memorandum"> | string
  }, "id">

  export type memorandumOrderByWithAggregationInput = {
    id?: SortOrder
    pdf?: SortOrder
    _count?: memorandumCountOrderByAggregateInput
    _avg?: memorandumAvgOrderByAggregateInput
    _max?: memorandumMaxOrderByAggregateInput
    _min?: memorandumMinOrderByAggregateInput
    _sum?: memorandumSumOrderByAggregateInput
  }

  export type memorandumScalarWhereWithAggregatesInput = {
    AND?: memorandumScalarWhereWithAggregatesInput | memorandumScalarWhereWithAggregatesInput[]
    OR?: memorandumScalarWhereWithAggregatesInput[]
    NOT?: memorandumScalarWhereWithAggregatesInput | memorandumScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"memorandum"> | number
    pdf?: StringWithAggregatesFilter<"memorandum"> | string
  }

  export type BoardOfDirectorsWhereInput = {
    AND?: BoardOfDirectorsWhereInput | BoardOfDirectorsWhereInput[]
    OR?: BoardOfDirectorsWhereInput[]
    NOT?: BoardOfDirectorsWhereInput | BoardOfDirectorsWhereInput[]
    id?: IntFilter<"BoardOfDirectors"> | number
    image?: StringFilter<"BoardOfDirectors"> | string
    name?: StringFilter<"BoardOfDirectors"> | string
    designation?: StringFilter<"BoardOfDirectors"> | string
  }

  export type BoardOfDirectorsOrderByWithRelationInput = {
    id?: SortOrder
    image?: SortOrder
    name?: SortOrder
    designation?: SortOrder
  }

  export type BoardOfDirectorsWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: BoardOfDirectorsWhereInput | BoardOfDirectorsWhereInput[]
    OR?: BoardOfDirectorsWhereInput[]
    NOT?: BoardOfDirectorsWhereInput | BoardOfDirectorsWhereInput[]
    image?: StringFilter<"BoardOfDirectors"> | string
    name?: StringFilter<"BoardOfDirectors"> | string
    designation?: StringFilter<"BoardOfDirectors"> | string
  }, "id">

  export type BoardOfDirectorsOrderByWithAggregationInput = {
    id?: SortOrder
    image?: SortOrder
    name?: SortOrder
    designation?: SortOrder
    _count?: BoardOfDirectorsCountOrderByAggregateInput
    _avg?: BoardOfDirectorsAvgOrderByAggregateInput
    _max?: BoardOfDirectorsMaxOrderByAggregateInput
    _min?: BoardOfDirectorsMinOrderByAggregateInput
    _sum?: BoardOfDirectorsSumOrderByAggregateInput
  }

  export type BoardOfDirectorsScalarWhereWithAggregatesInput = {
    AND?: BoardOfDirectorsScalarWhereWithAggregatesInput | BoardOfDirectorsScalarWhereWithAggregatesInput[]
    OR?: BoardOfDirectorsScalarWhereWithAggregatesInput[]
    NOT?: BoardOfDirectorsScalarWhereWithAggregatesInput | BoardOfDirectorsScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"BoardOfDirectors"> | number
    image?: StringWithAggregatesFilter<"BoardOfDirectors"> | string
    name?: StringWithAggregatesFilter<"BoardOfDirectors"> | string
    designation?: StringWithAggregatesFilter<"BoardOfDirectors"> | string
  }

  export type ShippersNewsWhereInput = {
    AND?: ShippersNewsWhereInput | ShippersNewsWhereInput[]
    OR?: ShippersNewsWhereInput[]
    NOT?: ShippersNewsWhereInput | ShippersNewsWhereInput[]
    id?: IntFilter<"ShippersNews"> | number
    image?: StringNullableFilter<"ShippersNews"> | string | null
    name?: StringFilter<"ShippersNews"> | string
    date?: StringFilter<"ShippersNews"> | string
    volume?: IntFilter<"ShippersNews"> | number
    pdf?: StringFilter<"ShippersNews"> | string
  }

  export type ShippersNewsOrderByWithRelationInput = {
    id?: SortOrder
    image?: SortOrderInput | SortOrder
    name?: SortOrder
    date?: SortOrder
    volume?: SortOrder
    pdf?: SortOrder
  }

  export type ShippersNewsWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: ShippersNewsWhereInput | ShippersNewsWhereInput[]
    OR?: ShippersNewsWhereInput[]
    NOT?: ShippersNewsWhereInput | ShippersNewsWhereInput[]
    image?: StringNullableFilter<"ShippersNews"> | string | null
    name?: StringFilter<"ShippersNews"> | string
    date?: StringFilter<"ShippersNews"> | string
    volume?: IntFilter<"ShippersNews"> | number
    pdf?: StringFilter<"ShippersNews"> | string
  }, "id">

  export type ShippersNewsOrderByWithAggregationInput = {
    id?: SortOrder
    image?: SortOrderInput | SortOrder
    name?: SortOrder
    date?: SortOrder
    volume?: SortOrder
    pdf?: SortOrder
    _count?: ShippersNewsCountOrderByAggregateInput
    _avg?: ShippersNewsAvgOrderByAggregateInput
    _max?: ShippersNewsMaxOrderByAggregateInput
    _min?: ShippersNewsMinOrderByAggregateInput
    _sum?: ShippersNewsSumOrderByAggregateInput
  }

  export type ShippersNewsScalarWhereWithAggregatesInput = {
    AND?: ShippersNewsScalarWhereWithAggregatesInput | ShippersNewsScalarWhereWithAggregatesInput[]
    OR?: ShippersNewsScalarWhereWithAggregatesInput[]
    NOT?: ShippersNewsScalarWhereWithAggregatesInput | ShippersNewsScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"ShippersNews"> | number
    image?: StringNullableWithAggregatesFilter<"ShippersNews"> | string | null
    name?: StringWithAggregatesFilter<"ShippersNews"> | string
    date?: StringWithAggregatesFilter<"ShippersNews"> | string
    volume?: IntWithAggregatesFilter<"ShippersNews"> | number
    pdf?: StringWithAggregatesFilter<"ShippersNews"> | string
  }

  export type AnnualReportWhereInput = {
    AND?: AnnualReportWhereInput | AnnualReportWhereInput[]
    OR?: AnnualReportWhereInput[]
    NOT?: AnnualReportWhereInput | AnnualReportWhereInput[]
    id?: IntFilter<"AnnualReport"> | number
    image?: StringNullableFilter<"AnnualReport"> | string | null
    name?: StringFilter<"AnnualReport"> | string
    date?: StringFilter<"AnnualReport"> | string
    pdf?: StringFilter<"AnnualReport"> | string
  }

  export type AnnualReportOrderByWithRelationInput = {
    id?: SortOrder
    image?: SortOrderInput | SortOrder
    name?: SortOrder
    date?: SortOrder
    pdf?: SortOrder
  }

  export type AnnualReportWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: AnnualReportWhereInput | AnnualReportWhereInput[]
    OR?: AnnualReportWhereInput[]
    NOT?: AnnualReportWhereInput | AnnualReportWhereInput[]
    image?: StringNullableFilter<"AnnualReport"> | string | null
    name?: StringFilter<"AnnualReport"> | string
    date?: StringFilter<"AnnualReport"> | string
    pdf?: StringFilter<"AnnualReport"> | string
  }, "id">

  export type AnnualReportOrderByWithAggregationInput = {
    id?: SortOrder
    image?: SortOrderInput | SortOrder
    name?: SortOrder
    date?: SortOrder
    pdf?: SortOrder
    _count?: AnnualReportCountOrderByAggregateInput
    _avg?: AnnualReportAvgOrderByAggregateInput
    _max?: AnnualReportMaxOrderByAggregateInput
    _min?: AnnualReportMinOrderByAggregateInput
    _sum?: AnnualReportSumOrderByAggregateInput
  }

  export type AnnualReportScalarWhereWithAggregatesInput = {
    AND?: AnnualReportScalarWhereWithAggregatesInput | AnnualReportScalarWhereWithAggregatesInput[]
    OR?: AnnualReportScalarWhereWithAggregatesInput[]
    NOT?: AnnualReportScalarWhereWithAggregatesInput | AnnualReportScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"AnnualReport"> | number
    image?: StringNullableWithAggregatesFilter<"AnnualReport"> | string | null
    name?: StringWithAggregatesFilter<"AnnualReport"> | string
    date?: StringWithAggregatesFilter<"AnnualReport"> | string
    pdf?: StringWithAggregatesFilter<"AnnualReport"> | string
  }

  export type OtherPublicationsWhereInput = {
    AND?: OtherPublicationsWhereInput | OtherPublicationsWhereInput[]
    OR?: OtherPublicationsWhereInput[]
    NOT?: OtherPublicationsWhereInput | OtherPublicationsWhereInput[]
    id?: IntFilter<"OtherPublications"> | number
    image?: StringNullableFilter<"OtherPublications"> | string | null
    name?: StringFilter<"OtherPublications"> | string
    date?: StringFilter<"OtherPublications"> | string
    pdf?: StringFilter<"OtherPublications"> | string
  }

  export type OtherPublicationsOrderByWithRelationInput = {
    id?: SortOrder
    image?: SortOrderInput | SortOrder
    name?: SortOrder
    date?: SortOrder
    pdf?: SortOrder
  }

  export type OtherPublicationsWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: OtherPublicationsWhereInput | OtherPublicationsWhereInput[]
    OR?: OtherPublicationsWhereInput[]
    NOT?: OtherPublicationsWhereInput | OtherPublicationsWhereInput[]
    image?: StringNullableFilter<"OtherPublications"> | string | null
    name?: StringFilter<"OtherPublications"> | string
    date?: StringFilter<"OtherPublications"> | string
    pdf?: StringFilter<"OtherPublications"> | string
  }, "id">

  export type OtherPublicationsOrderByWithAggregationInput = {
    id?: SortOrder
    image?: SortOrderInput | SortOrder
    name?: SortOrder
    date?: SortOrder
    pdf?: SortOrder
    _count?: OtherPublicationsCountOrderByAggregateInput
    _avg?: OtherPublicationsAvgOrderByAggregateInput
    _max?: OtherPublicationsMaxOrderByAggregateInput
    _min?: OtherPublicationsMinOrderByAggregateInput
    _sum?: OtherPublicationsSumOrderByAggregateInput
  }

  export type OtherPublicationsScalarWhereWithAggregatesInput = {
    AND?: OtherPublicationsScalarWhereWithAggregatesInput | OtherPublicationsScalarWhereWithAggregatesInput[]
    OR?: OtherPublicationsScalarWhereWithAggregatesInput[]
    NOT?: OtherPublicationsScalarWhereWithAggregatesInput | OtherPublicationsScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"OtherPublications"> | number
    image?: StringNullableWithAggregatesFilter<"OtherPublications"> | string | null
    name?: StringWithAggregatesFilter<"OtherPublications"> | string
    date?: StringWithAggregatesFilter<"OtherPublications"> | string
    pdf?: StringWithAggregatesFilter<"OtherPublications"> | string
  }

  export type SCBRecommendationsWhereInput = {
    AND?: SCBRecommendationsWhereInput | SCBRecommendationsWhereInput[]
    OR?: SCBRecommendationsWhereInput[]
    NOT?: SCBRecommendationsWhereInput | SCBRecommendationsWhereInput[]
    id?: IntFilter<"SCBRecommendations"> | number
    type?: StringFilter<"SCBRecommendations"> | string
    name?: StringFilter<"SCBRecommendations"> | string
    date?: StringFilter<"SCBRecommendations"> | string
    pdf?: StringFilter<"SCBRecommendations"> | string
  }

  export type SCBRecommendationsOrderByWithRelationInput = {
    id?: SortOrder
    type?: SortOrder
    name?: SortOrder
    date?: SortOrder
    pdf?: SortOrder
  }

  export type SCBRecommendationsWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: SCBRecommendationsWhereInput | SCBRecommendationsWhereInput[]
    OR?: SCBRecommendationsWhereInput[]
    NOT?: SCBRecommendationsWhereInput | SCBRecommendationsWhereInput[]
    type?: StringFilter<"SCBRecommendations"> | string
    name?: StringFilter<"SCBRecommendations"> | string
    date?: StringFilter<"SCBRecommendations"> | string
    pdf?: StringFilter<"SCBRecommendations"> | string
  }, "id">

  export type SCBRecommendationsOrderByWithAggregationInput = {
    id?: SortOrder
    type?: SortOrder
    name?: SortOrder
    date?: SortOrder
    pdf?: SortOrder
    _count?: SCBRecommendationsCountOrderByAggregateInput
    _avg?: SCBRecommendationsAvgOrderByAggregateInput
    _max?: SCBRecommendationsMaxOrderByAggregateInput
    _min?: SCBRecommendationsMinOrderByAggregateInput
    _sum?: SCBRecommendationsSumOrderByAggregateInput
  }

  export type SCBRecommendationsScalarWhereWithAggregatesInput = {
    AND?: SCBRecommendationsScalarWhereWithAggregatesInput | SCBRecommendationsScalarWhereWithAggregatesInput[]
    OR?: SCBRecommendationsScalarWhereWithAggregatesInput[]
    NOT?: SCBRecommendationsScalarWhereWithAggregatesInput | SCBRecommendationsScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"SCBRecommendations"> | number
    type?: StringWithAggregatesFilter<"SCBRecommendations"> | string
    name?: StringWithAggregatesFilter<"SCBRecommendations"> | string
    date?: StringWithAggregatesFilter<"SCBRecommendations"> | string
    pdf?: StringWithAggregatesFilter<"SCBRecommendations"> | string
  }

  export type SCBSeminarWhereInput = {
    AND?: SCBSeminarWhereInput | SCBSeminarWhereInput[]
    OR?: SCBSeminarWhereInput[]
    NOT?: SCBSeminarWhereInput | SCBSeminarWhereInput[]
    id?: IntFilter<"SCBSeminar"> | number
    type?: StringFilter<"SCBSeminar"> | string
    name?: StringFilter<"SCBSeminar"> | string
    date?: StringFilter<"SCBSeminar"> | string
    pdf?: StringFilter<"SCBSeminar"> | string
  }

  export type SCBSeminarOrderByWithRelationInput = {
    id?: SortOrder
    type?: SortOrder
    name?: SortOrder
    date?: SortOrder
    pdf?: SortOrder
  }

  export type SCBSeminarWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: SCBSeminarWhereInput | SCBSeminarWhereInput[]
    OR?: SCBSeminarWhereInput[]
    NOT?: SCBSeminarWhereInput | SCBSeminarWhereInput[]
    type?: StringFilter<"SCBSeminar"> | string
    name?: StringFilter<"SCBSeminar"> | string
    date?: StringFilter<"SCBSeminar"> | string
    pdf?: StringFilter<"SCBSeminar"> | string
  }, "id">

  export type SCBSeminarOrderByWithAggregationInput = {
    id?: SortOrder
    type?: SortOrder
    name?: SortOrder
    date?: SortOrder
    pdf?: SortOrder
    _count?: SCBSeminarCountOrderByAggregateInput
    _avg?: SCBSeminarAvgOrderByAggregateInput
    _max?: SCBSeminarMaxOrderByAggregateInput
    _min?: SCBSeminarMinOrderByAggregateInput
    _sum?: SCBSeminarSumOrderByAggregateInput
  }

  export type SCBSeminarScalarWhereWithAggregatesInput = {
    AND?: SCBSeminarScalarWhereWithAggregatesInput | SCBSeminarScalarWhereWithAggregatesInput[]
    OR?: SCBSeminarScalarWhereWithAggregatesInput[]
    NOT?: SCBSeminarScalarWhereWithAggregatesInput | SCBSeminarScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"SCBSeminar"> | number
    type?: StringWithAggregatesFilter<"SCBSeminar"> | string
    name?: StringWithAggregatesFilter<"SCBSeminar"> | string
    date?: StringWithAggregatesFilter<"SCBSeminar"> | string
    pdf?: StringWithAggregatesFilter<"SCBSeminar"> | string
  }

  export type EligibilityWhereInput = {
    AND?: EligibilityWhereInput | EligibilityWhereInput[]
    OR?: EligibilityWhereInput[]
    NOT?: EligibilityWhereInput | EligibilityWhereInput[]
    id?: IntFilter<"Eligibility"> | number
    type?: StringFilter<"Eligibility"> | string
    text?: StringFilter<"Eligibility"> | string
    admission?: IntFilter<"Eligibility"> | number
    subscription?: IntFilter<"Eligibility"> | number
  }

  export type EligibilityOrderByWithRelationInput = {
    id?: SortOrder
    type?: SortOrder
    text?: SortOrder
    admission?: SortOrder
    subscription?: SortOrder
  }

  export type EligibilityWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: EligibilityWhereInput | EligibilityWhereInput[]
    OR?: EligibilityWhereInput[]
    NOT?: EligibilityWhereInput | EligibilityWhereInput[]
    type?: StringFilter<"Eligibility"> | string
    text?: StringFilter<"Eligibility"> | string
    admission?: IntFilter<"Eligibility"> | number
    subscription?: IntFilter<"Eligibility"> | number
  }, "id">

  export type EligibilityOrderByWithAggregationInput = {
    id?: SortOrder
    type?: SortOrder
    text?: SortOrder
    admission?: SortOrder
    subscription?: SortOrder
    _count?: EligibilityCountOrderByAggregateInput
    _avg?: EligibilityAvgOrderByAggregateInput
    _max?: EligibilityMaxOrderByAggregateInput
    _min?: EligibilityMinOrderByAggregateInput
    _sum?: EligibilitySumOrderByAggregateInput
  }

  export type EligibilityScalarWhereWithAggregatesInput = {
    AND?: EligibilityScalarWhereWithAggregatesInput | EligibilityScalarWhereWithAggregatesInput[]
    OR?: EligibilityScalarWhereWithAggregatesInput[]
    NOT?: EligibilityScalarWhereWithAggregatesInput | EligibilityScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"Eligibility"> | number
    type?: StringWithAggregatesFilter<"Eligibility"> | string
    text?: StringWithAggregatesFilter<"Eligibility"> | string
    admission?: IntWithAggregatesFilter<"Eligibility"> | number
    subscription?: IntWithAggregatesFilter<"Eligibility"> | number
  }

  export type RelevantPapersWhereInput = {
    AND?: RelevantPapersWhereInput | RelevantPapersWhereInput[]
    OR?: RelevantPapersWhereInput[]
    NOT?: RelevantPapersWhereInput | RelevantPapersWhereInput[]
    id?: IntFilter<"RelevantPapers"> | number
    type?: StringFilter<"RelevantPapers"> | string
    papers?: StringFilter<"RelevantPapers"> | string
  }

  export type RelevantPapersOrderByWithRelationInput = {
    id?: SortOrder
    type?: SortOrder
    papers?: SortOrder
  }

  export type RelevantPapersWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: RelevantPapersWhereInput | RelevantPapersWhereInput[]
    OR?: RelevantPapersWhereInput[]
    NOT?: RelevantPapersWhereInput | RelevantPapersWhereInput[]
    type?: StringFilter<"RelevantPapers"> | string
    papers?: StringFilter<"RelevantPapers"> | string
  }, "id">

  export type RelevantPapersOrderByWithAggregationInput = {
    id?: SortOrder
    type?: SortOrder
    papers?: SortOrder
    _count?: RelevantPapersCountOrderByAggregateInput
    _avg?: RelevantPapersAvgOrderByAggregateInput
    _max?: RelevantPapersMaxOrderByAggregateInput
    _min?: RelevantPapersMinOrderByAggregateInput
    _sum?: RelevantPapersSumOrderByAggregateInput
  }

  export type RelevantPapersScalarWhereWithAggregatesInput = {
    AND?: RelevantPapersScalarWhereWithAggregatesInput | RelevantPapersScalarWhereWithAggregatesInput[]
    OR?: RelevantPapersScalarWhereWithAggregatesInput[]
    NOT?: RelevantPapersScalarWhereWithAggregatesInput | RelevantPapersScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"RelevantPapers"> | number
    type?: StringWithAggregatesFilter<"RelevantPapers"> | string
    papers?: StringWithAggregatesFilter<"RelevantPapers"> | string
  }

  export type MembersListWhereInput = {
    AND?: MembersListWhereInput | MembersListWhereInput[]
    OR?: MembersListWhereInput[]
    NOT?: MembersListWhereInput | MembersListWhereInput[]
    id?: IntFilter<"MembersList"> | number
    name?: StringFilter<"MembersList"> | string
    type?: StringFilter<"MembersList"> | string
    membershipId?: StringFilter<"MembersList"> | string
  }

  export type MembersListOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    type?: SortOrder
    membershipId?: SortOrder
  }

  export type MembersListWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: MembersListWhereInput | MembersListWhereInput[]
    OR?: MembersListWhereInput[]
    NOT?: MembersListWhereInput | MembersListWhereInput[]
    name?: StringFilter<"MembersList"> | string
    type?: StringFilter<"MembersList"> | string
    membershipId?: StringFilter<"MembersList"> | string
  }, "id">

  export type MembersListOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    type?: SortOrder
    membershipId?: SortOrder
    _count?: MembersListCountOrderByAggregateInput
    _avg?: MembersListAvgOrderByAggregateInput
    _max?: MembersListMaxOrderByAggregateInput
    _min?: MembersListMinOrderByAggregateInput
    _sum?: MembersListSumOrderByAggregateInput
  }

  export type MembersListScalarWhereWithAggregatesInput = {
    AND?: MembersListScalarWhereWithAggregatesInput | MembersListScalarWhereWithAggregatesInput[]
    OR?: MembersListScalarWhereWithAggregatesInput[]
    NOT?: MembersListScalarWhereWithAggregatesInput | MembersListScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"MembersList"> | number
    name?: StringWithAggregatesFilter<"MembersList"> | string
    type?: StringWithAggregatesFilter<"MembersList"> | string
    membershipId?: StringWithAggregatesFilter<"MembersList"> | string
  }

  export type UsefulLinksWhereInput = {
    AND?: UsefulLinksWhereInput | UsefulLinksWhereInput[]
    OR?: UsefulLinksWhereInput[]
    NOT?: UsefulLinksWhereInput | UsefulLinksWhereInput[]
    id?: IntFilter<"UsefulLinks"> | number
    type?: StringFilter<"UsefulLinks"> | string
    logo?: StringFilter<"UsefulLinks"> | string
    Name?: StringFilter<"UsefulLinks"> | string
    text?: StringNullableFilter<"UsefulLinks"> | string | null
  }

  export type UsefulLinksOrderByWithRelationInput = {
    id?: SortOrder
    type?: SortOrder
    logo?: SortOrder
    Name?: SortOrder
    text?: SortOrderInput | SortOrder
  }

  export type UsefulLinksWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: UsefulLinksWhereInput | UsefulLinksWhereInput[]
    OR?: UsefulLinksWhereInput[]
    NOT?: UsefulLinksWhereInput | UsefulLinksWhereInput[]
    type?: StringFilter<"UsefulLinks"> | string
    logo?: StringFilter<"UsefulLinks"> | string
    Name?: StringFilter<"UsefulLinks"> | string
    text?: StringNullableFilter<"UsefulLinks"> | string | null
  }, "id">

  export type UsefulLinksOrderByWithAggregationInput = {
    id?: SortOrder
    type?: SortOrder
    logo?: SortOrder
    Name?: SortOrder
    text?: SortOrderInput | SortOrder
    _count?: UsefulLinksCountOrderByAggregateInput
    _avg?: UsefulLinksAvgOrderByAggregateInput
    _max?: UsefulLinksMaxOrderByAggregateInput
    _min?: UsefulLinksMinOrderByAggregateInput
    _sum?: UsefulLinksSumOrderByAggregateInput
  }

  export type UsefulLinksScalarWhereWithAggregatesInput = {
    AND?: UsefulLinksScalarWhereWithAggregatesInput | UsefulLinksScalarWhereWithAggregatesInput[]
    OR?: UsefulLinksScalarWhereWithAggregatesInput[]
    NOT?: UsefulLinksScalarWhereWithAggregatesInput | UsefulLinksScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"UsefulLinks"> | number
    type?: StringWithAggregatesFilter<"UsefulLinks"> | string
    logo?: StringWithAggregatesFilter<"UsefulLinks"> | string
    Name?: StringWithAggregatesFilter<"UsefulLinks"> | string
    text?: StringNullableWithAggregatesFilter<"UsefulLinks"> | string | null
  }

  export type ContactUsWhereInput = {
    AND?: ContactUsWhereInput | ContactUsWhereInput[]
    OR?: ContactUsWhereInput[]
    NOT?: ContactUsWhereInput | ContactUsWhereInput[]
    id?: IntFilter<"ContactUs"> | number
    address?: StringFilter<"ContactUs"> | string
    telephone?: StringFilter<"ContactUs"> | string
    email?: StringFilter<"ContactUs"> | string
  }

  export type ContactUsOrderByWithRelationInput = {
    id?: SortOrder
    address?: SortOrder
    telephone?: SortOrder
    email?: SortOrder
  }

  export type ContactUsWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: ContactUsWhereInput | ContactUsWhereInput[]
    OR?: ContactUsWhereInput[]
    NOT?: ContactUsWhereInput | ContactUsWhereInput[]
    address?: StringFilter<"ContactUs"> | string
    telephone?: StringFilter<"ContactUs"> | string
    email?: StringFilter<"ContactUs"> | string
  }, "id">

  export type ContactUsOrderByWithAggregationInput = {
    id?: SortOrder
    address?: SortOrder
    telephone?: SortOrder
    email?: SortOrder
    _count?: ContactUsCountOrderByAggregateInput
    _avg?: ContactUsAvgOrderByAggregateInput
    _max?: ContactUsMaxOrderByAggregateInput
    _min?: ContactUsMinOrderByAggregateInput
    _sum?: ContactUsSumOrderByAggregateInput
  }

  export type ContactUsScalarWhereWithAggregatesInput = {
    AND?: ContactUsScalarWhereWithAggregatesInput | ContactUsScalarWhereWithAggregatesInput[]
    OR?: ContactUsScalarWhereWithAggregatesInput[]
    NOT?: ContactUsScalarWhereWithAggregatesInput | ContactUsScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"ContactUs"> | number
    address?: StringWithAggregatesFilter<"ContactUs"> | string
    telephone?: StringWithAggregatesFilter<"ContactUs"> | string
    email?: StringWithAggregatesFilter<"ContactUs"> | string
  }

  export type SecretariatWhereInput = {
    AND?: SecretariatWhereInput | SecretariatWhereInput[]
    OR?: SecretariatWhereInput[]
    NOT?: SecretariatWhereInput | SecretariatWhereInput[]
    id?: IntFilter<"Secretariat"> | number
    name?: StringFilter<"Secretariat"> | string
    position?: StringFilter<"Secretariat"> | string
  }

  export type SecretariatOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    position?: SortOrder
  }

  export type SecretariatWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: SecretariatWhereInput | SecretariatWhereInput[]
    OR?: SecretariatWhereInput[]
    NOT?: SecretariatWhereInput | SecretariatWhereInput[]
    name?: StringFilter<"Secretariat"> | string
    position?: StringFilter<"Secretariat"> | string
  }, "id">

  export type SecretariatOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    position?: SortOrder
    _count?: SecretariatCountOrderByAggregateInput
    _avg?: SecretariatAvgOrderByAggregateInput
    _max?: SecretariatMaxOrderByAggregateInput
    _min?: SecretariatMinOrderByAggregateInput
    _sum?: SecretariatSumOrderByAggregateInput
  }

  export type SecretariatScalarWhereWithAggregatesInput = {
    AND?: SecretariatScalarWhereWithAggregatesInput | SecretariatScalarWhereWithAggregatesInput[]
    OR?: SecretariatScalarWhereWithAggregatesInput[]
    NOT?: SecretariatScalarWhereWithAggregatesInput | SecretariatScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"Secretariat"> | number
    name?: StringWithAggregatesFilter<"Secretariat"> | string
    position?: StringWithAggregatesFilter<"Secretariat"> | string
  }

  export type PDFsWhereInput = {
    AND?: PDFsWhereInput | PDFsWhereInput[]
    OR?: PDFsWhereInput[]
    NOT?: PDFsWhereInput | PDFsWhereInput[]
    id?: IntFilter<"PDFs"> | number
    pdf?: StringFilter<"PDFs"> | string
    image?: StringNullableFilter<"PDFs"> | string | null
    title?: StringFilter<"PDFs"> | string
    type?: StringFilter<"PDFs"> | string
  }

  export type PDFsOrderByWithRelationInput = {
    id?: SortOrder
    pdf?: SortOrder
    image?: SortOrderInput | SortOrder
    title?: SortOrder
    type?: SortOrder
  }

  export type PDFsWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: PDFsWhereInput | PDFsWhereInput[]
    OR?: PDFsWhereInput[]
    NOT?: PDFsWhereInput | PDFsWhereInput[]
    pdf?: StringFilter<"PDFs"> | string
    image?: StringNullableFilter<"PDFs"> | string | null
    title?: StringFilter<"PDFs"> | string
    type?: StringFilter<"PDFs"> | string
  }, "id">

  export type PDFsOrderByWithAggregationInput = {
    id?: SortOrder
    pdf?: SortOrder
    image?: SortOrderInput | SortOrder
    title?: SortOrder
    type?: SortOrder
    _count?: PDFsCountOrderByAggregateInput
    _avg?: PDFsAvgOrderByAggregateInput
    _max?: PDFsMaxOrderByAggregateInput
    _min?: PDFsMinOrderByAggregateInput
    _sum?: PDFsSumOrderByAggregateInput
  }

  export type PDFsScalarWhereWithAggregatesInput = {
    AND?: PDFsScalarWhereWithAggregatesInput | PDFsScalarWhereWithAggregatesInput[]
    OR?: PDFsScalarWhereWithAggregatesInput[]
    NOT?: PDFsScalarWhereWithAggregatesInput | PDFsScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"PDFs"> | number
    pdf?: StringWithAggregatesFilter<"PDFs"> | string
    image?: StringNullableWithAggregatesFilter<"PDFs"> | string | null
    title?: StringWithAggregatesFilter<"PDFs"> | string
    type?: StringWithAggregatesFilter<"PDFs"> | string
  }

  export type FormsWhereInput = {
    AND?: FormsWhereInput | FormsWhereInput[]
    OR?: FormsWhereInput[]
    NOT?: FormsWhereInput | FormsWhereInput[]
    id?: IntFilter<"Forms"> | number
    pdf?: StringFilter<"Forms"> | string
    title?: StringFilter<"Forms"> | string
    type?: StringFilter<"Forms"> | string
  }

  export type FormsOrderByWithRelationInput = {
    id?: SortOrder
    pdf?: SortOrder
    title?: SortOrder
    type?: SortOrder
  }

  export type FormsWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: FormsWhereInput | FormsWhereInput[]
    OR?: FormsWhereInput[]
    NOT?: FormsWhereInput | FormsWhereInput[]
    pdf?: StringFilter<"Forms"> | string
    title?: StringFilter<"Forms"> | string
    type?: StringFilter<"Forms"> | string
  }, "id">

  export type FormsOrderByWithAggregationInput = {
    id?: SortOrder
    pdf?: SortOrder
    title?: SortOrder
    type?: SortOrder
    _count?: FormsCountOrderByAggregateInput
    _avg?: FormsAvgOrderByAggregateInput
    _max?: FormsMaxOrderByAggregateInput
    _min?: FormsMinOrderByAggregateInput
    _sum?: FormsSumOrderByAggregateInput
  }

  export type FormsScalarWhereWithAggregatesInput = {
    AND?: FormsScalarWhereWithAggregatesInput | FormsScalarWhereWithAggregatesInput[]
    OR?: FormsScalarWhereWithAggregatesInput[]
    NOT?: FormsScalarWhereWithAggregatesInput | FormsScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"Forms"> | number
    pdf?: StringWithAggregatesFilter<"Forms"> | string
    title?: StringWithAggregatesFilter<"Forms"> | string
    type?: StringWithAggregatesFilter<"Forms"> | string
  }

  export type MembershipTextWhereInput = {
    AND?: MembershipTextWhereInput | MembershipTextWhereInput[]
    OR?: MembershipTextWhereInput[]
    NOT?: MembershipTextWhereInput | MembershipTextWhereInput[]
    id?: IntFilter<"MembershipText"> | number
    title?: StringFilter<"MembershipText"> | string
    text?: StringFilter<"MembershipText"> | string
  }

  export type MembershipTextOrderByWithRelationInput = {
    id?: SortOrder
    title?: SortOrder
    text?: SortOrder
  }

  export type MembershipTextWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: MembershipTextWhereInput | MembershipTextWhereInput[]
    OR?: MembershipTextWhereInput[]
    NOT?: MembershipTextWhereInput | MembershipTextWhereInput[]
    title?: StringFilter<"MembershipText"> | string
    text?: StringFilter<"MembershipText"> | string
  }, "id">

  export type MembershipTextOrderByWithAggregationInput = {
    id?: SortOrder
    title?: SortOrder
    text?: SortOrder
    _count?: MembershipTextCountOrderByAggregateInput
    _avg?: MembershipTextAvgOrderByAggregateInput
    _max?: MembershipTextMaxOrderByAggregateInput
    _min?: MembershipTextMinOrderByAggregateInput
    _sum?: MembershipTextSumOrderByAggregateInput
  }

  export type MembershipTextScalarWhereWithAggregatesInput = {
    AND?: MembershipTextScalarWhereWithAggregatesInput | MembershipTextScalarWhereWithAggregatesInput[]
    OR?: MembershipTextScalarWhereWithAggregatesInput[]
    NOT?: MembershipTextScalarWhereWithAggregatesInput | MembershipTextScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"MembershipText"> | number
    title?: StringWithAggregatesFilter<"MembershipText"> | string
    text?: StringWithAggregatesFilter<"MembershipText"> | string
  }

  export type ApplicationProcedureWhereInput = {
    AND?: ApplicationProcedureWhereInput | ApplicationProcedureWhereInput[]
    OR?: ApplicationProcedureWhereInput[]
    NOT?: ApplicationProcedureWhereInput | ApplicationProcedureWhereInput[]
    id?: IntFilter<"ApplicationProcedure"> | number
    text?: StringFilter<"ApplicationProcedure"> | string
  }

  export type ApplicationProcedureOrderByWithRelationInput = {
    id?: SortOrder
    text?: SortOrder
  }

  export type ApplicationProcedureWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: ApplicationProcedureWhereInput | ApplicationProcedureWhereInput[]
    OR?: ApplicationProcedureWhereInput[]
    NOT?: ApplicationProcedureWhereInput | ApplicationProcedureWhereInput[]
    text?: StringFilter<"ApplicationProcedure"> | string
  }, "id">

  export type ApplicationProcedureOrderByWithAggregationInput = {
    id?: SortOrder
    text?: SortOrder
    _count?: ApplicationProcedureCountOrderByAggregateInput
    _avg?: ApplicationProcedureAvgOrderByAggregateInput
    _max?: ApplicationProcedureMaxOrderByAggregateInput
    _min?: ApplicationProcedureMinOrderByAggregateInput
    _sum?: ApplicationProcedureSumOrderByAggregateInput
  }

  export type ApplicationProcedureScalarWhereWithAggregatesInput = {
    AND?: ApplicationProcedureScalarWhereWithAggregatesInput | ApplicationProcedureScalarWhereWithAggregatesInput[]
    OR?: ApplicationProcedureScalarWhereWithAggregatesInput[]
    NOT?: ApplicationProcedureScalarWhereWithAggregatesInput | ApplicationProcedureScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"ApplicationProcedure"> | number
    text?: StringWithAggregatesFilter<"ApplicationProcedure"> | string
  }

  export type BenefitsWhereInput = {
    AND?: BenefitsWhereInput | BenefitsWhereInput[]
    OR?: BenefitsWhereInput[]
    NOT?: BenefitsWhereInput | BenefitsWhereInput[]
    id?: IntFilter<"Benefits"> | number
    benefits?: StringFilter<"Benefits"> | string
    advantages?: StringFilter<"Benefits"> | string
  }

  export type BenefitsOrderByWithRelationInput = {
    id?: SortOrder
    benefits?: SortOrder
    advantages?: SortOrder
  }

  export type BenefitsWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: BenefitsWhereInput | BenefitsWhereInput[]
    OR?: BenefitsWhereInput[]
    NOT?: BenefitsWhereInput | BenefitsWhereInput[]
    benefits?: StringFilter<"Benefits"> | string
    advantages?: StringFilter<"Benefits"> | string
  }, "id">

  export type BenefitsOrderByWithAggregationInput = {
    id?: SortOrder
    benefits?: SortOrder
    advantages?: SortOrder
    _count?: BenefitsCountOrderByAggregateInput
    _avg?: BenefitsAvgOrderByAggregateInput
    _max?: BenefitsMaxOrderByAggregateInput
    _min?: BenefitsMinOrderByAggregateInput
    _sum?: BenefitsSumOrderByAggregateInput
  }

  export type BenefitsScalarWhereWithAggregatesInput = {
    AND?: BenefitsScalarWhereWithAggregatesInput | BenefitsScalarWhereWithAggregatesInput[]
    OR?: BenefitsScalarWhereWithAggregatesInput[]
    NOT?: BenefitsScalarWhereWithAggregatesInput | BenefitsScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"Benefits"> | number
    benefits?: StringWithAggregatesFilter<"Benefits"> | string
    advantages?: StringWithAggregatesFilter<"Benefits"> | string
  }

  export type PhotoAlbumWhereInput = {
    AND?: PhotoAlbumWhereInput | PhotoAlbumWhereInput[]
    OR?: PhotoAlbumWhereInput[]
    NOT?: PhotoAlbumWhereInput | PhotoAlbumWhereInput[]
    id?: IntFilter<"PhotoAlbum"> | number
    title?: StringFilter<"PhotoAlbum"> | string
    photos?: GalleryPhotoListRelationFilter
  }

  export type PhotoAlbumOrderByWithRelationInput = {
    id?: SortOrder
    title?: SortOrder
    photos?: GalleryPhotoOrderByRelationAggregateInput
  }

  export type PhotoAlbumWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: PhotoAlbumWhereInput | PhotoAlbumWhereInput[]
    OR?: PhotoAlbumWhereInput[]
    NOT?: PhotoAlbumWhereInput | PhotoAlbumWhereInput[]
    title?: StringFilter<"PhotoAlbum"> | string
    photos?: GalleryPhotoListRelationFilter
  }, "id">

  export type PhotoAlbumOrderByWithAggregationInput = {
    id?: SortOrder
    title?: SortOrder
    _count?: PhotoAlbumCountOrderByAggregateInput
    _avg?: PhotoAlbumAvgOrderByAggregateInput
    _max?: PhotoAlbumMaxOrderByAggregateInput
    _min?: PhotoAlbumMinOrderByAggregateInput
    _sum?: PhotoAlbumSumOrderByAggregateInput
  }

  export type PhotoAlbumScalarWhereWithAggregatesInput = {
    AND?: PhotoAlbumScalarWhereWithAggregatesInput | PhotoAlbumScalarWhereWithAggregatesInput[]
    OR?: PhotoAlbumScalarWhereWithAggregatesInput[]
    NOT?: PhotoAlbumScalarWhereWithAggregatesInput | PhotoAlbumScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"PhotoAlbum"> | number
    title?: StringWithAggregatesFilter<"PhotoAlbum"> | string
  }

  export type GalleryPhotoWhereInput = {
    AND?: GalleryPhotoWhereInput | GalleryPhotoWhereInput[]
    OR?: GalleryPhotoWhereInput[]
    NOT?: GalleryPhotoWhereInput | GalleryPhotoWhereInput[]
    id?: IntFilter<"GalleryPhoto"> | number
    image?: StringFilter<"GalleryPhoto"> | string
    PhotoAlbumId?: IntNullableFilter<"GalleryPhoto"> | number | null
    album?: XOR<PhotoAlbumNullableRelationFilter, PhotoAlbumWhereInput> | null
  }

  export type GalleryPhotoOrderByWithRelationInput = {
    id?: SortOrder
    image?: SortOrder
    PhotoAlbumId?: SortOrderInput | SortOrder
    album?: PhotoAlbumOrderByWithRelationInput
  }

  export type GalleryPhotoWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: GalleryPhotoWhereInput | GalleryPhotoWhereInput[]
    OR?: GalleryPhotoWhereInput[]
    NOT?: GalleryPhotoWhereInput | GalleryPhotoWhereInput[]
    image?: StringFilter<"GalleryPhoto"> | string
    PhotoAlbumId?: IntNullableFilter<"GalleryPhoto"> | number | null
    album?: XOR<PhotoAlbumNullableRelationFilter, PhotoAlbumWhereInput> | null
  }, "id">

  export type GalleryPhotoOrderByWithAggregationInput = {
    id?: SortOrder
    image?: SortOrder
    PhotoAlbumId?: SortOrderInput | SortOrder
    _count?: GalleryPhotoCountOrderByAggregateInput
    _avg?: GalleryPhotoAvgOrderByAggregateInput
    _max?: GalleryPhotoMaxOrderByAggregateInput
    _min?: GalleryPhotoMinOrderByAggregateInput
    _sum?: GalleryPhotoSumOrderByAggregateInput
  }

  export type GalleryPhotoScalarWhereWithAggregatesInput = {
    AND?: GalleryPhotoScalarWhereWithAggregatesInput | GalleryPhotoScalarWhereWithAggregatesInput[]
    OR?: GalleryPhotoScalarWhereWithAggregatesInput[]
    NOT?: GalleryPhotoScalarWhereWithAggregatesInput | GalleryPhotoScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"GalleryPhoto"> | number
    image?: StringWithAggregatesFilter<"GalleryPhoto"> | string
    PhotoAlbumId?: IntNullableWithAggregatesFilter<"GalleryPhoto"> | number | null
  }

  export type GalleryVideoWhereInput = {
    AND?: GalleryVideoWhereInput | GalleryVideoWhereInput[]
    OR?: GalleryVideoWhereInput[]
    NOT?: GalleryVideoWhereInput | GalleryVideoWhereInput[]
    id?: IntFilter<"GalleryVideo"> | number
    title?: StringFilter<"GalleryVideo"> | string
    link?: StringFilter<"GalleryVideo"> | string
  }

  export type GalleryVideoOrderByWithRelationInput = {
    id?: SortOrder
    title?: SortOrder
    link?: SortOrder
  }

  export type GalleryVideoWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: GalleryVideoWhereInput | GalleryVideoWhereInput[]
    OR?: GalleryVideoWhereInput[]
    NOT?: GalleryVideoWhereInput | GalleryVideoWhereInput[]
    title?: StringFilter<"GalleryVideo"> | string
    link?: StringFilter<"GalleryVideo"> | string
  }, "id">

  export type GalleryVideoOrderByWithAggregationInput = {
    id?: SortOrder
    title?: SortOrder
    link?: SortOrder
    _count?: GalleryVideoCountOrderByAggregateInput
    _avg?: GalleryVideoAvgOrderByAggregateInput
    _max?: GalleryVideoMaxOrderByAggregateInput
    _min?: GalleryVideoMinOrderByAggregateInput
    _sum?: GalleryVideoSumOrderByAggregateInput
  }

  export type GalleryVideoScalarWhereWithAggregatesInput = {
    AND?: GalleryVideoScalarWhereWithAggregatesInput | GalleryVideoScalarWhereWithAggregatesInput[]
    OR?: GalleryVideoScalarWhereWithAggregatesInput[]
    NOT?: GalleryVideoScalarWhereWithAggregatesInput | GalleryVideoScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"GalleryVideo"> | number
    title?: StringWithAggregatesFilter<"GalleryVideo"> | string
    link?: StringWithAggregatesFilter<"GalleryVideo"> | string
  }

  export type CondolenceWhereInput = {
    AND?: CondolenceWhereInput | CondolenceWhereInput[]
    OR?: CondolenceWhereInput[]
    NOT?: CondolenceWhereInput | CondolenceWhereInput[]
    id?: IntFilter<"Condolence"> | number
    name?: StringFilter<"Condolence"> | string
    position?: StringFilter<"Condolence"> | string
    period?: StringFilter<"Condolence"> | string
    featured?: BoolFilter<"Condolence"> | boolean
    image?: StringFilter<"Condolence"> | string
    text?: StringNullableFilter<"Condolence"> | string | null
  }

  export type CondolenceOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    position?: SortOrder
    period?: SortOrder
    featured?: SortOrder
    image?: SortOrder
    text?: SortOrderInput | SortOrder
  }

  export type CondolenceWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: CondolenceWhereInput | CondolenceWhereInput[]
    OR?: CondolenceWhereInput[]
    NOT?: CondolenceWhereInput | CondolenceWhereInput[]
    name?: StringFilter<"Condolence"> | string
    position?: StringFilter<"Condolence"> | string
    period?: StringFilter<"Condolence"> | string
    featured?: BoolFilter<"Condolence"> | boolean
    image?: StringFilter<"Condolence"> | string
    text?: StringNullableFilter<"Condolence"> | string | null
  }, "id">

  export type CondolenceOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    position?: SortOrder
    period?: SortOrder
    featured?: SortOrder
    image?: SortOrder
    text?: SortOrderInput | SortOrder
    _count?: CondolenceCountOrderByAggregateInput
    _avg?: CondolenceAvgOrderByAggregateInput
    _max?: CondolenceMaxOrderByAggregateInput
    _min?: CondolenceMinOrderByAggregateInput
    _sum?: CondolenceSumOrderByAggregateInput
  }

  export type CondolenceScalarWhereWithAggregatesInput = {
    AND?: CondolenceScalarWhereWithAggregatesInput | CondolenceScalarWhereWithAggregatesInput[]
    OR?: CondolenceScalarWhereWithAggregatesInput[]
    NOT?: CondolenceScalarWhereWithAggregatesInput | CondolenceScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"Condolence"> | number
    name?: StringWithAggregatesFilter<"Condolence"> | string
    position?: StringWithAggregatesFilter<"Condolence"> | string
    period?: StringWithAggregatesFilter<"Condolence"> | string
    featured?: BoolWithAggregatesFilter<"Condolence"> | boolean
    image?: StringWithAggregatesFilter<"Condolence"> | string
    text?: StringNullableWithAggregatesFilter<"Condolence"> | string | null
  }

  export type AffiliatesWhereInput = {
    AND?: AffiliatesWhereInput | AffiliatesWhereInput[]
    OR?: AffiliatesWhereInput[]
    NOT?: AffiliatesWhereInput | AffiliatesWhereInput[]
    id?: IntFilter<"Affiliates"> | number
    logo?: StringFilter<"Affiliates"> | string
  }

  export type AffiliatesOrderByWithRelationInput = {
    id?: SortOrder
    logo?: SortOrder
  }

  export type AffiliatesWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: AffiliatesWhereInput | AffiliatesWhereInput[]
    OR?: AffiliatesWhereInput[]
    NOT?: AffiliatesWhereInput | AffiliatesWhereInput[]
    logo?: StringFilter<"Affiliates"> | string
  }, "id">

  export type AffiliatesOrderByWithAggregationInput = {
    id?: SortOrder
    logo?: SortOrder
    _count?: AffiliatesCountOrderByAggregateInput
    _avg?: AffiliatesAvgOrderByAggregateInput
    _max?: AffiliatesMaxOrderByAggregateInput
    _min?: AffiliatesMinOrderByAggregateInput
    _sum?: AffiliatesSumOrderByAggregateInput
  }

  export type AffiliatesScalarWhereWithAggregatesInput = {
    AND?: AffiliatesScalarWhereWithAggregatesInput | AffiliatesScalarWhereWithAggregatesInput[]
    OR?: AffiliatesScalarWhereWithAggregatesInput[]
    NOT?: AffiliatesScalarWhereWithAggregatesInput | AffiliatesScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"Affiliates"> | number
    logo?: StringWithAggregatesFilter<"Affiliates"> | string
  }

  export type SubscribersWhereInput = {
    AND?: SubscribersWhereInput | SubscribersWhereInput[]
    OR?: SubscribersWhereInput[]
    NOT?: SubscribersWhereInput | SubscribersWhereInput[]
    id?: IntFilter<"Subscribers"> | number
    email?: StringFilter<"Subscribers"> | string
    date?: DateTimeFilter<"Subscribers"> | Date | string
  }

  export type SubscribersOrderByWithRelationInput = {
    id?: SortOrder
    email?: SortOrder
    date?: SortOrder
  }

  export type SubscribersWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    email?: string
    AND?: SubscribersWhereInput | SubscribersWhereInput[]
    OR?: SubscribersWhereInput[]
    NOT?: SubscribersWhereInput | SubscribersWhereInput[]
    date?: DateTimeFilter<"Subscribers"> | Date | string
  }, "id" | "email">

  export type SubscribersOrderByWithAggregationInput = {
    id?: SortOrder
    email?: SortOrder
    date?: SortOrder
    _count?: SubscribersCountOrderByAggregateInput
    _avg?: SubscribersAvgOrderByAggregateInput
    _max?: SubscribersMaxOrderByAggregateInput
    _min?: SubscribersMinOrderByAggregateInput
    _sum?: SubscribersSumOrderByAggregateInput
  }

  export type SubscribersScalarWhereWithAggregatesInput = {
    AND?: SubscribersScalarWhereWithAggregatesInput | SubscribersScalarWhereWithAggregatesInput[]
    OR?: SubscribersScalarWhereWithAggregatesInput[]
    NOT?: SubscribersScalarWhereWithAggregatesInput | SubscribersScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"Subscribers"> | number
    email?: StringWithAggregatesFilter<"Subscribers"> | string
    date?: DateTimeWithAggregatesFilter<"Subscribers"> | Date | string
  }

  export type MessagesWhereInput = {
    AND?: MessagesWhereInput | MessagesWhereInput[]
    OR?: MessagesWhereInput[]
    NOT?: MessagesWhereInput | MessagesWhereInput[]
    id?: IntFilter<"Messages"> | number
    email?: StringFilter<"Messages"> | string
    name?: StringFilter<"Messages"> | string
    phone?: StringFilter<"Messages"> | string
    message?: StringFilter<"Messages"> | string
    date?: DateTimeFilter<"Messages"> | Date | string
  }

  export type MessagesOrderByWithRelationInput = {
    id?: SortOrder
    email?: SortOrder
    name?: SortOrder
    phone?: SortOrder
    message?: SortOrder
    date?: SortOrder
  }

  export type MessagesWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: MessagesWhereInput | MessagesWhereInput[]
    OR?: MessagesWhereInput[]
    NOT?: MessagesWhereInput | MessagesWhereInput[]
    email?: StringFilter<"Messages"> | string
    name?: StringFilter<"Messages"> | string
    phone?: StringFilter<"Messages"> | string
    message?: StringFilter<"Messages"> | string
    date?: DateTimeFilter<"Messages"> | Date | string
  }, "id">

  export type MessagesOrderByWithAggregationInput = {
    id?: SortOrder
    email?: SortOrder
    name?: SortOrder
    phone?: SortOrder
    message?: SortOrder
    date?: SortOrder
    _count?: MessagesCountOrderByAggregateInput
    _avg?: MessagesAvgOrderByAggregateInput
    _max?: MessagesMaxOrderByAggregateInput
    _min?: MessagesMinOrderByAggregateInput
    _sum?: MessagesSumOrderByAggregateInput
  }

  export type MessagesScalarWhereWithAggregatesInput = {
    AND?: MessagesScalarWhereWithAggregatesInput | MessagesScalarWhereWithAggregatesInput[]
    OR?: MessagesScalarWhereWithAggregatesInput[]
    NOT?: MessagesScalarWhereWithAggregatesInput | MessagesScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"Messages"> | number
    email?: StringWithAggregatesFilter<"Messages"> | string
    name?: StringWithAggregatesFilter<"Messages"> | string
    phone?: StringWithAggregatesFilter<"Messages"> | string
    message?: StringWithAggregatesFilter<"Messages"> | string
    date?: DateTimeWithAggregatesFilter<"Messages"> | Date | string
  }

  export type latestNewsCreateInput = {
    news: string
  }

  export type latestNewsUncheckedCreateInput = {
    id?: number
    news: string
  }

  export type latestNewsUpdateInput = {
    news?: StringFieldUpdateOperationsInput | string
  }

  export type latestNewsUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    news?: StringFieldUpdateOperationsInput | string
  }

  export type latestNewsCreateManyInput = {
    id?: number
    news: string
  }

  export type latestNewsUpdateManyMutationInput = {
    news?: StringFieldUpdateOperationsInput | string
  }

  export type latestNewsUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    news?: StringFieldUpdateOperationsInput | string
  }

  export type sliderImagesCreateInput = {
    image: string
    caption: string
  }

  export type sliderImagesUncheckedCreateInput = {
    id?: number
    image: string
    caption: string
  }

  export type sliderImagesUpdateInput = {
    image?: StringFieldUpdateOperationsInput | string
    caption?: StringFieldUpdateOperationsInput | string
  }

  export type sliderImagesUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    image?: StringFieldUpdateOperationsInput | string
    caption?: StringFieldUpdateOperationsInput | string
  }

  export type sliderImagesCreateManyInput = {
    id?: number
    image: string
    caption: string
  }

  export type sliderImagesUpdateManyMutationInput = {
    image?: StringFieldUpdateOperationsInput | string
    caption?: StringFieldUpdateOperationsInput | string
  }

  export type sliderImagesUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    image?: StringFieldUpdateOperationsInput | string
    caption?: StringFieldUpdateOperationsInput | string
  }

  export type missionsCreateInput = {
    text: string
    pdfName: string
    objectiveList?: objectivesCreateNestedManyWithoutMissionsInput
  }

  export type missionsUncheckedCreateInput = {
    id?: number
    text: string
    pdfName: string
    objectiveList?: objectivesUncheckedCreateNestedManyWithoutMissionsInput
  }

  export type missionsUpdateInput = {
    text?: StringFieldUpdateOperationsInput | string
    pdfName?: StringFieldUpdateOperationsInput | string
    objectiveList?: objectivesUpdateManyWithoutMissionsNestedInput
  }

  export type missionsUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    text?: StringFieldUpdateOperationsInput | string
    pdfName?: StringFieldUpdateOperationsInput | string
    objectiveList?: objectivesUncheckedUpdateManyWithoutMissionsNestedInput
  }

  export type missionsCreateManyInput = {
    id?: number
    text: string
    pdfName: string
  }

  export type missionsUpdateManyMutationInput = {
    text?: StringFieldUpdateOperationsInput | string
    pdfName?: StringFieldUpdateOperationsInput | string
  }

  export type missionsUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    text?: StringFieldUpdateOperationsInput | string
    pdfName?: StringFieldUpdateOperationsInput | string
  }

  export type objectivesCreateInput = {
    text: string
    bg: string
    missions?: missionsCreateNestedOneWithoutObjectiveListInput
  }

  export type objectivesUncheckedCreateInput = {
    id?: number
    text: string
    bg: string
    missionsId?: number | null
  }

  export type objectivesUpdateInput = {
    text?: StringFieldUpdateOperationsInput | string
    bg?: StringFieldUpdateOperationsInput | string
    missions?: missionsUpdateOneWithoutObjectiveListNestedInput
  }

  export type objectivesUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    text?: StringFieldUpdateOperationsInput | string
    bg?: StringFieldUpdateOperationsInput | string
    missionsId?: NullableIntFieldUpdateOperationsInput | number | null
  }

  export type objectivesCreateManyInput = {
    id?: number
    text: string
    bg: string
    missionsId?: number | null
  }

  export type objectivesUpdateManyMutationInput = {
    text?: StringFieldUpdateOperationsInput | string
    bg?: StringFieldUpdateOperationsInput | string
  }

  export type objectivesUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    text?: StringFieldUpdateOperationsInput | string
    bg?: StringFieldUpdateOperationsInput | string
    missionsId?: NullableIntFieldUpdateOperationsInput | number | null
  }

  export type homeDataCreateInput = {
    title: string
    text: string
    image?: NullableJsonNullValueInput | InputJsonValue
    pdf?: string | null
  }

  export type homeDataUncheckedCreateInput = {
    id?: number
    title: string
    text: string
    image?: NullableJsonNullValueInput | InputJsonValue
    pdf?: string | null
  }

  export type homeDataUpdateInput = {
    title?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
    image?: NullableJsonNullValueInput | InputJsonValue
    pdf?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type homeDataUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
    image?: NullableJsonNullValueInput | InputJsonValue
    pdf?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type homeDataCreateManyInput = {
    id?: number
    title: string
    text: string
    image?: NullableJsonNullValueInput | InputJsonValue
    pdf?: string | null
  }

  export type homeDataUpdateManyMutationInput = {
    title?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
    image?: NullableJsonNullValueInput | InputJsonValue
    pdf?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type homeDataUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
    image?: NullableJsonNullValueInput | InputJsonValue
    pdf?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type briefDataCreateInput = {
    text: string
    image?: NullableJsonNullValueInput | InputJsonValue
  }

  export type briefDataUncheckedCreateInput = {
    id?: number
    text: string
    image?: NullableJsonNullValueInput | InputJsonValue
  }

  export type briefDataUpdateInput = {
    text?: StringFieldUpdateOperationsInput | string
    image?: NullableJsonNullValueInput | InputJsonValue
  }

  export type briefDataUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    text?: StringFieldUpdateOperationsInput | string
    image?: NullableJsonNullValueInput | InputJsonValue
  }

  export type briefDataCreateManyInput = {
    id?: number
    text: string
    image?: NullableJsonNullValueInput | InputJsonValue
  }

  export type briefDataUpdateManyMutationInput = {
    text?: StringFieldUpdateOperationsInput | string
    image?: NullableJsonNullValueInput | InputJsonValue
  }

  export type briefDataUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    text?: StringFieldUpdateOperationsInput | string
    image?: NullableJsonNullValueInput | InputJsonValue
  }

  export type serviceDataCreateInput = {
    text: string
    bg: string
    bg2: string
  }

  export type serviceDataUncheckedCreateInput = {
    id?: number
    text: string
    bg: string
    bg2: string
  }

  export type serviceDataUpdateInput = {
    text?: StringFieldUpdateOperationsInput | string
    bg?: StringFieldUpdateOperationsInput | string
    bg2?: StringFieldUpdateOperationsInput | string
  }

  export type serviceDataUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    text?: StringFieldUpdateOperationsInput | string
    bg?: StringFieldUpdateOperationsInput | string
    bg2?: StringFieldUpdateOperationsInput | string
  }

  export type serviceDataCreateManyInput = {
    id?: number
    text: string
    bg: string
    bg2: string
  }

  export type serviceDataUpdateManyMutationInput = {
    text?: StringFieldUpdateOperationsInput | string
    bg?: StringFieldUpdateOperationsInput | string
    bg2?: StringFieldUpdateOperationsInput | string
  }

  export type serviceDataUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    text?: StringFieldUpdateOperationsInput | string
    bg?: StringFieldUpdateOperationsInput | string
    bg2?: StringFieldUpdateOperationsInput | string
  }

  export type activitiesDataCreateInput = {
    text: string
    bg: string
    bg2: string
  }

  export type activitiesDataUncheckedCreateInput = {
    id?: number
    text: string
    bg: string
    bg2: string
  }

  export type activitiesDataUpdateInput = {
    text?: StringFieldUpdateOperationsInput | string
    bg?: StringFieldUpdateOperationsInput | string
    bg2?: StringFieldUpdateOperationsInput | string
  }

  export type activitiesDataUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    text?: StringFieldUpdateOperationsInput | string
    bg?: StringFieldUpdateOperationsInput | string
    bg2?: StringFieldUpdateOperationsInput | string
  }

  export type activitiesDataCreateManyInput = {
    id?: number
    text: string
    bg: string
    bg2: string
  }

  export type activitiesDataUpdateManyMutationInput = {
    text?: StringFieldUpdateOperationsInput | string
    bg?: StringFieldUpdateOperationsInput | string
    bg2?: StringFieldUpdateOperationsInput | string
  }

  export type activitiesDataUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    text?: StringFieldUpdateOperationsInput | string
    bg?: StringFieldUpdateOperationsInput | string
    bg2?: StringFieldUpdateOperationsInput | string
  }

  export type formerChairmanCreateInput = {
    name: string
    position: string
    period: string
  }

  export type formerChairmanUncheckedCreateInput = {
    id?: number
    name: string
    position: string
    period: string
  }

  export type formerChairmanUpdateInput = {
    name?: StringFieldUpdateOperationsInput | string
    position?: StringFieldUpdateOperationsInput | string
    period?: StringFieldUpdateOperationsInput | string
  }

  export type formerChairmanUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    position?: StringFieldUpdateOperationsInput | string
    period?: StringFieldUpdateOperationsInput | string
  }

  export type formerChairmanCreateManyInput = {
    id?: number
    name: string
    position: string
    period: string
  }

  export type formerChairmanUpdateManyMutationInput = {
    name?: StringFieldUpdateOperationsInput | string
    position?: StringFieldUpdateOperationsInput | string
    period?: StringFieldUpdateOperationsInput | string
  }

  export type formerChairmanUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    position?: StringFieldUpdateOperationsInput | string
    period?: StringFieldUpdateOperationsInput | string
  }

  export type formerSrViceChairmanCreateInput = {
    name: string
    position: string
    period: string
  }

  export type formerSrViceChairmanUncheckedCreateInput = {
    id?: number
    name: string
    position: string
    period: string
  }

  export type formerSrViceChairmanUpdateInput = {
    name?: StringFieldUpdateOperationsInput | string
    position?: StringFieldUpdateOperationsInput | string
    period?: StringFieldUpdateOperationsInput | string
  }

  export type formerSrViceChairmanUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    position?: StringFieldUpdateOperationsInput | string
    period?: StringFieldUpdateOperationsInput | string
  }

  export type formerSrViceChairmanCreateManyInput = {
    id?: number
    name: string
    position: string
    period: string
  }

  export type formerSrViceChairmanUpdateManyMutationInput = {
    name?: StringFieldUpdateOperationsInput | string
    position?: StringFieldUpdateOperationsInput | string
    period?: StringFieldUpdateOperationsInput | string
  }

  export type formerSrViceChairmanUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    position?: StringFieldUpdateOperationsInput | string
    period?: StringFieldUpdateOperationsInput | string
  }

  export type formerViceChairmanCreateInput = {
    name: string
    position?: string
    period: string
  }

  export type formerViceChairmanUncheckedCreateInput = {
    id?: number
    name: string
    position?: string
    period: string
  }

  export type formerViceChairmanUpdateInput = {
    name?: StringFieldUpdateOperationsInput | string
    position?: StringFieldUpdateOperationsInput | string
    period?: StringFieldUpdateOperationsInput | string
  }

  export type formerViceChairmanUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    position?: StringFieldUpdateOperationsInput | string
    period?: StringFieldUpdateOperationsInput | string
  }

  export type formerViceChairmanCreateManyInput = {
    id?: number
    name: string
    position?: string
    period: string
  }

  export type formerViceChairmanUpdateManyMutationInput = {
    name?: StringFieldUpdateOperationsInput | string
    position?: StringFieldUpdateOperationsInput | string
    period?: StringFieldUpdateOperationsInput | string
  }

  export type formerViceChairmanUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    position?: StringFieldUpdateOperationsInput | string
    period?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanProfileCreateInput = {
    image: string
    name: string
    academic: string
    profession: string
    business?: string | null
    presentPosition: string
    foreignTravel?: string | null
    associations?: ChairmanAssociationCreateNestedManyWithoutProfileInput
    clubs?: ChairmanClubsCreateNestedManyWithoutProfileInput
  }

  export type ChairmanProfileUncheckedCreateInput = {
    id?: number
    image: string
    name: string
    academic: string
    profession: string
    business?: string | null
    presentPosition: string
    foreignTravel?: string | null
    associations?: ChairmanAssociationUncheckedCreateNestedManyWithoutProfileInput
    clubs?: ChairmanClubsUncheckedCreateNestedManyWithoutProfileInput
  }

  export type ChairmanProfileUpdateInput = {
    image?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    academic?: StringFieldUpdateOperationsInput | string
    profession?: StringFieldUpdateOperationsInput | string
    business?: NullableStringFieldUpdateOperationsInput | string | null
    presentPosition?: StringFieldUpdateOperationsInput | string
    foreignTravel?: NullableStringFieldUpdateOperationsInput | string | null
    associations?: ChairmanAssociationUpdateManyWithoutProfileNestedInput
    clubs?: ChairmanClubsUpdateManyWithoutProfileNestedInput
  }

  export type ChairmanProfileUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    image?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    academic?: StringFieldUpdateOperationsInput | string
    profession?: StringFieldUpdateOperationsInput | string
    business?: NullableStringFieldUpdateOperationsInput | string | null
    presentPosition?: StringFieldUpdateOperationsInput | string
    foreignTravel?: NullableStringFieldUpdateOperationsInput | string | null
    associations?: ChairmanAssociationUncheckedUpdateManyWithoutProfileNestedInput
    clubs?: ChairmanClubsUncheckedUpdateManyWithoutProfileNestedInput
  }

  export type ChairmanProfileCreateManyInput = {
    id?: number
    image: string
    name: string
    academic: string
    profession: string
    business?: string | null
    presentPosition: string
    foreignTravel?: string | null
  }

  export type ChairmanProfileUpdateManyMutationInput = {
    image?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    academic?: StringFieldUpdateOperationsInput | string
    profession?: StringFieldUpdateOperationsInput | string
    business?: NullableStringFieldUpdateOperationsInput | string | null
    presentPosition?: StringFieldUpdateOperationsInput | string
    foreignTravel?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ChairmanProfileUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    image?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    academic?: StringFieldUpdateOperationsInput | string
    profession?: StringFieldUpdateOperationsInput | string
    business?: NullableStringFieldUpdateOperationsInput | string | null
    presentPosition?: StringFieldUpdateOperationsInput | string
    foreignTravel?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ChairmanAssociationCreateInput = {
    name: string
    text: string
    profile?: ChairmanProfileCreateNestedOneWithoutAssociationsInput
  }

  export type ChairmanAssociationUncheckedCreateInput = {
    id?: number
    name: string
    text: string
    ChairmanProfileId?: number | null
  }

  export type ChairmanAssociationUpdateInput = {
    name?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
    profile?: ChairmanProfileUpdateOneWithoutAssociationsNestedInput
  }

  export type ChairmanAssociationUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
    ChairmanProfileId?: NullableIntFieldUpdateOperationsInput | number | null
  }

  export type ChairmanAssociationCreateManyInput = {
    id?: number
    name: string
    text: string
    ChairmanProfileId?: number | null
  }

  export type ChairmanAssociationUpdateManyMutationInput = {
    name?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanAssociationUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
    ChairmanProfileId?: NullableIntFieldUpdateOperationsInput | number | null
  }

  export type ChairmanClubsCreateInput = {
    name: string
    text: string
    profile?: ChairmanProfileCreateNestedOneWithoutClubsInput
  }

  export type ChairmanClubsUncheckedCreateInput = {
    id?: number
    name: string
    text: string
    ChairmanProfileId?: number | null
  }

  export type ChairmanClubsUpdateInput = {
    name?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
    profile?: ChairmanProfileUpdateOneWithoutClubsNestedInput
  }

  export type ChairmanClubsUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
    ChairmanProfileId?: NullableIntFieldUpdateOperationsInput | number | null
  }

  export type ChairmanClubsCreateManyInput = {
    id?: number
    name: string
    text: string
    ChairmanProfileId?: number | null
  }

  export type ChairmanClubsUpdateManyMutationInput = {
    name?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanClubsUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
    ChairmanProfileId?: NullableIntFieldUpdateOperationsInput | number | null
  }

  export type ChairmanMessageCreateInput = {
    message: string
  }

  export type ChairmanMessageUncheckedCreateInput = {
    id?: number
    message: string
  }

  export type ChairmanMessageUpdateInput = {
    message?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanMessageUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    message?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanMessageCreateManyInput = {
    id?: number
    message: string
  }

  export type ChairmanMessageUpdateManyMutationInput = {
    message?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanMessageUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    message?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanSpeechCreateInput = {
    name: string
    pdf: string
    date: string
  }

  export type ChairmanSpeechUncheckedCreateInput = {
    id?: number
    name: string
    pdf: string
    date: string
  }

  export type ChairmanSpeechUpdateInput = {
    name?: StringFieldUpdateOperationsInput | string
    pdf?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanSpeechUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    pdf?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanSpeechCreateManyInput = {
    id?: number
    name: string
    pdf: string
    date: string
  }

  export type ChairmanSpeechUpdateManyMutationInput = {
    name?: StringFieldUpdateOperationsInput | string
    pdf?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanSpeechUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    pdf?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanInterviewPrintCreateInput = {
    name: string
    pdf: string
    date: string
  }

  export type ChairmanInterviewPrintUncheckedCreateInput = {
    id?: number
    name: string
    pdf: string
    date: string
  }

  export type ChairmanInterviewPrintUpdateInput = {
    name?: StringFieldUpdateOperationsInput | string
    pdf?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanInterviewPrintUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    pdf?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanInterviewPrintCreateManyInput = {
    id?: number
    name: string
    pdf: string
    date: string
  }

  export type ChairmanInterviewPrintUpdateManyMutationInput = {
    name?: StringFieldUpdateOperationsInput | string
    pdf?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanInterviewPrintUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    pdf?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanInterviewElectronicCreateInput = {
    title: string
    link: string
  }

  export type ChairmanInterviewElectronicUncheckedCreateInput = {
    id?: number
    title: string
    link: string
  }

  export type ChairmanInterviewElectronicUpdateInput = {
    title?: StringFieldUpdateOperationsInput | string
    link?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanInterviewElectronicUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    link?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanInterviewElectronicCreateManyInput = {
    id?: number
    title: string
    link: string
  }

  export type ChairmanInterviewElectronicUpdateManyMutationInput = {
    title?: StringFieldUpdateOperationsInput | string
    link?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanInterviewElectronicUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    link?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanPresentationCreateInput = {
    name: string
    pdf: string
    date: string
  }

  export type ChairmanPresentationUncheckedCreateInput = {
    id?: number
    name: string
    pdf: string
    date: string
  }

  export type ChairmanPresentationUpdateInput = {
    name?: StringFieldUpdateOperationsInput | string
    pdf?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanPresentationUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    pdf?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanPresentationCreateManyInput = {
    id?: number
    name: string
    pdf: string
    date: string
  }

  export type ChairmanPresentationUpdateManyMutationInput = {
    name?: StringFieldUpdateOperationsInput | string
    pdf?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanPresentationUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    pdf?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
  }

  export type memorandumCreateInput = {
    pdf: string
  }

  export type memorandumUncheckedCreateInput = {
    id?: number
    pdf: string
  }

  export type memorandumUpdateInput = {
    pdf?: StringFieldUpdateOperationsInput | string
  }

  export type memorandumUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    pdf?: StringFieldUpdateOperationsInput | string
  }

  export type memorandumCreateManyInput = {
    id?: number
    pdf: string
  }

  export type memorandumUpdateManyMutationInput = {
    pdf?: StringFieldUpdateOperationsInput | string
  }

  export type memorandumUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    pdf?: StringFieldUpdateOperationsInput | string
  }

  export type BoardOfDirectorsCreateInput = {
    image: string
    name: string
    designation: string
  }

  export type BoardOfDirectorsUncheckedCreateInput = {
    id?: number
    image: string
    name: string
    designation: string
  }

  export type BoardOfDirectorsUpdateInput = {
    image?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    designation?: StringFieldUpdateOperationsInput | string
  }

  export type BoardOfDirectorsUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    image?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    designation?: StringFieldUpdateOperationsInput | string
  }

  export type BoardOfDirectorsCreateManyInput = {
    id?: number
    image: string
    name: string
    designation: string
  }

  export type BoardOfDirectorsUpdateManyMutationInput = {
    image?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    designation?: StringFieldUpdateOperationsInput | string
  }

  export type BoardOfDirectorsUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    image?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    designation?: StringFieldUpdateOperationsInput | string
  }

  export type ShippersNewsCreateInput = {
    image?: string | null
    name: string
    date: string
    volume: number
    pdf: string
  }

  export type ShippersNewsUncheckedCreateInput = {
    id?: number
    image?: string | null
    name: string
    date: string
    volume: number
    pdf: string
  }

  export type ShippersNewsUpdateInput = {
    image?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    volume?: IntFieldUpdateOperationsInput | number
    pdf?: StringFieldUpdateOperationsInput | string
  }

  export type ShippersNewsUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    image?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    volume?: IntFieldUpdateOperationsInput | number
    pdf?: StringFieldUpdateOperationsInput | string
  }

  export type ShippersNewsCreateManyInput = {
    id?: number
    image?: string | null
    name: string
    date: string
    volume: number
    pdf: string
  }

  export type ShippersNewsUpdateManyMutationInput = {
    image?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    volume?: IntFieldUpdateOperationsInput | number
    pdf?: StringFieldUpdateOperationsInput | string
  }

  export type ShippersNewsUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    image?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    volume?: IntFieldUpdateOperationsInput | number
    pdf?: StringFieldUpdateOperationsInput | string
  }

  export type AnnualReportCreateInput = {
    image?: string | null
    name: string
    date: string
    pdf: string
  }

  export type AnnualReportUncheckedCreateInput = {
    id?: number
    image?: string | null
    name: string
    date: string
    pdf: string
  }

  export type AnnualReportUpdateInput = {
    image?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    pdf?: StringFieldUpdateOperationsInput | string
  }

  export type AnnualReportUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    image?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    pdf?: StringFieldUpdateOperationsInput | string
  }

  export type AnnualReportCreateManyInput = {
    id?: number
    image?: string | null
    name: string
    date: string
    pdf: string
  }

  export type AnnualReportUpdateManyMutationInput = {
    image?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    pdf?: StringFieldUpdateOperationsInput | string
  }

  export type AnnualReportUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    image?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    pdf?: StringFieldUpdateOperationsInput | string
  }

  export type OtherPublicationsCreateInput = {
    image?: string | null
    name: string
    date: string
    pdf: string
  }

  export type OtherPublicationsUncheckedCreateInput = {
    id?: number
    image?: string | null
    name: string
    date: string
    pdf: string
  }

  export type OtherPublicationsUpdateInput = {
    image?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    pdf?: StringFieldUpdateOperationsInput | string
  }

  export type OtherPublicationsUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    image?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    pdf?: StringFieldUpdateOperationsInput | string
  }

  export type OtherPublicationsCreateManyInput = {
    id?: number
    image?: string | null
    name: string
    date: string
    pdf: string
  }

  export type OtherPublicationsUpdateManyMutationInput = {
    image?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    pdf?: StringFieldUpdateOperationsInput | string
  }

  export type OtherPublicationsUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    image?: NullableStringFieldUpdateOperationsInput | string | null
    name?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    pdf?: StringFieldUpdateOperationsInput | string
  }

  export type SCBRecommendationsCreateInput = {
    type: string
    name: string
    date: string
    pdf: string
  }

  export type SCBRecommendationsUncheckedCreateInput = {
    id?: number
    type: string
    name: string
    date: string
    pdf: string
  }

  export type SCBRecommendationsUpdateInput = {
    type?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    pdf?: StringFieldUpdateOperationsInput | string
  }

  export type SCBRecommendationsUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    type?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    pdf?: StringFieldUpdateOperationsInput | string
  }

  export type SCBRecommendationsCreateManyInput = {
    id?: number
    type: string
    name: string
    date: string
    pdf: string
  }

  export type SCBRecommendationsUpdateManyMutationInput = {
    type?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    pdf?: StringFieldUpdateOperationsInput | string
  }

  export type SCBRecommendationsUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    type?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    pdf?: StringFieldUpdateOperationsInput | string
  }

  export type SCBSeminarCreateInput = {
    type: string
    name: string
    date: string
    pdf: string
  }

  export type SCBSeminarUncheckedCreateInput = {
    id?: number
    type: string
    name: string
    date: string
    pdf: string
  }

  export type SCBSeminarUpdateInput = {
    type?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    pdf?: StringFieldUpdateOperationsInput | string
  }

  export type SCBSeminarUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    type?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    pdf?: StringFieldUpdateOperationsInput | string
  }

  export type SCBSeminarCreateManyInput = {
    id?: number
    type: string
    name: string
    date: string
    pdf: string
  }

  export type SCBSeminarUpdateManyMutationInput = {
    type?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    pdf?: StringFieldUpdateOperationsInput | string
  }

  export type SCBSeminarUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    type?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    date?: StringFieldUpdateOperationsInput | string
    pdf?: StringFieldUpdateOperationsInput | string
  }

  export type EligibilityCreateInput = {
    type: string
    text: string
    admission: number
    subscription: number
  }

  export type EligibilityUncheckedCreateInput = {
    id?: number
    type: string
    text: string
    admission: number
    subscription: number
  }

  export type EligibilityUpdateInput = {
    type?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
    admission?: IntFieldUpdateOperationsInput | number
    subscription?: IntFieldUpdateOperationsInput | number
  }

  export type EligibilityUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    type?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
    admission?: IntFieldUpdateOperationsInput | number
    subscription?: IntFieldUpdateOperationsInput | number
  }

  export type EligibilityCreateManyInput = {
    id?: number
    type: string
    text: string
    admission: number
    subscription: number
  }

  export type EligibilityUpdateManyMutationInput = {
    type?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
    admission?: IntFieldUpdateOperationsInput | number
    subscription?: IntFieldUpdateOperationsInput | number
  }

  export type EligibilityUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    type?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
    admission?: IntFieldUpdateOperationsInput | number
    subscription?: IntFieldUpdateOperationsInput | number
  }

  export type RelevantPapersCreateInput = {
    type: string
    papers: string
  }

  export type RelevantPapersUncheckedCreateInput = {
    id?: number
    type: string
    papers: string
  }

  export type RelevantPapersUpdateInput = {
    type?: StringFieldUpdateOperationsInput | string
    papers?: StringFieldUpdateOperationsInput | string
  }

  export type RelevantPapersUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    type?: StringFieldUpdateOperationsInput | string
    papers?: StringFieldUpdateOperationsInput | string
  }

  export type RelevantPapersCreateManyInput = {
    id?: number
    type: string
    papers: string
  }

  export type RelevantPapersUpdateManyMutationInput = {
    type?: StringFieldUpdateOperationsInput | string
    papers?: StringFieldUpdateOperationsInput | string
  }

  export type RelevantPapersUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    type?: StringFieldUpdateOperationsInput | string
    papers?: StringFieldUpdateOperationsInput | string
  }

  export type MembersListCreateInput = {
    name: string
    type: string
    membershipId: string
  }

  export type MembersListUncheckedCreateInput = {
    id?: number
    name: string
    type: string
    membershipId: string
  }

  export type MembersListUpdateInput = {
    name?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    membershipId?: StringFieldUpdateOperationsInput | string
  }

  export type MembersListUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    membershipId?: StringFieldUpdateOperationsInput | string
  }

  export type MembersListCreateManyInput = {
    id?: number
    name: string
    type: string
    membershipId: string
  }

  export type MembersListUpdateManyMutationInput = {
    name?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    membershipId?: StringFieldUpdateOperationsInput | string
  }

  export type MembersListUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
    membershipId?: StringFieldUpdateOperationsInput | string
  }

  export type UsefulLinksCreateInput = {
    type: string
    logo: string
    Name: string
    text?: string | null
  }

  export type UsefulLinksUncheckedCreateInput = {
    id?: number
    type: string
    logo: string
    Name: string
    text?: string | null
  }

  export type UsefulLinksUpdateInput = {
    type?: StringFieldUpdateOperationsInput | string
    logo?: StringFieldUpdateOperationsInput | string
    Name?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type UsefulLinksUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    type?: StringFieldUpdateOperationsInput | string
    logo?: StringFieldUpdateOperationsInput | string
    Name?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type UsefulLinksCreateManyInput = {
    id?: number
    type: string
    logo: string
    Name: string
    text?: string | null
  }

  export type UsefulLinksUpdateManyMutationInput = {
    type?: StringFieldUpdateOperationsInput | string
    logo?: StringFieldUpdateOperationsInput | string
    Name?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type UsefulLinksUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    type?: StringFieldUpdateOperationsInput | string
    logo?: StringFieldUpdateOperationsInput | string
    Name?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ContactUsCreateInput = {
    address: string
    telephone: string
    email: string
  }

  export type ContactUsUncheckedCreateInput = {
    id?: number
    address: string
    telephone: string
    email: string
  }

  export type ContactUsUpdateInput = {
    address?: StringFieldUpdateOperationsInput | string
    telephone?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
  }

  export type ContactUsUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    address?: StringFieldUpdateOperationsInput | string
    telephone?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
  }

  export type ContactUsCreateManyInput = {
    id?: number
    address: string
    telephone: string
    email: string
  }

  export type ContactUsUpdateManyMutationInput = {
    address?: StringFieldUpdateOperationsInput | string
    telephone?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
  }

  export type ContactUsUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    address?: StringFieldUpdateOperationsInput | string
    telephone?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
  }

  export type SecretariatCreateInput = {
    name: string
    position: string
  }

  export type SecretariatUncheckedCreateInput = {
    id?: number
    name: string
    position: string
  }

  export type SecretariatUpdateInput = {
    name?: StringFieldUpdateOperationsInput | string
    position?: StringFieldUpdateOperationsInput | string
  }

  export type SecretariatUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    position?: StringFieldUpdateOperationsInput | string
  }

  export type SecretariatCreateManyInput = {
    id?: number
    name: string
    position: string
  }

  export type SecretariatUpdateManyMutationInput = {
    name?: StringFieldUpdateOperationsInput | string
    position?: StringFieldUpdateOperationsInput | string
  }

  export type SecretariatUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    position?: StringFieldUpdateOperationsInput | string
  }

  export type PDFsCreateInput = {
    pdf: string
    image?: string | null
    title: string
    type: string
  }

  export type PDFsUncheckedCreateInput = {
    id?: number
    pdf: string
    image?: string | null
    title: string
    type: string
  }

  export type PDFsUpdateInput = {
    pdf?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    title?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
  }

  export type PDFsUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    pdf?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    title?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
  }

  export type PDFsCreateManyInput = {
    id?: number
    pdf: string
    image?: string | null
    title: string
    type: string
  }

  export type PDFsUpdateManyMutationInput = {
    pdf?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    title?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
  }

  export type PDFsUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    pdf?: StringFieldUpdateOperationsInput | string
    image?: NullableStringFieldUpdateOperationsInput | string | null
    title?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
  }

  export type FormsCreateInput = {
    pdf: string
    title: string
    type: string
  }

  export type FormsUncheckedCreateInput = {
    id?: number
    pdf: string
    title: string
    type: string
  }

  export type FormsUpdateInput = {
    pdf?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
  }

  export type FormsUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    pdf?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
  }

  export type FormsCreateManyInput = {
    id?: number
    pdf: string
    title: string
    type: string
  }

  export type FormsUpdateManyMutationInput = {
    pdf?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
  }

  export type FormsUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    pdf?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    type?: StringFieldUpdateOperationsInput | string
  }

  export type MembershipTextCreateInput = {
    title: string
    text: string
  }

  export type MembershipTextUncheckedCreateInput = {
    id?: number
    title: string
    text: string
  }

  export type MembershipTextUpdateInput = {
    title?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
  }

  export type MembershipTextUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
  }

  export type MembershipTextCreateManyInput = {
    id?: number
    title: string
    text: string
  }

  export type MembershipTextUpdateManyMutationInput = {
    title?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
  }

  export type MembershipTextUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
  }

  export type ApplicationProcedureCreateInput = {
    text: string
  }

  export type ApplicationProcedureUncheckedCreateInput = {
    id?: number
    text: string
  }

  export type ApplicationProcedureUpdateInput = {
    text?: StringFieldUpdateOperationsInput | string
  }

  export type ApplicationProcedureUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    text?: StringFieldUpdateOperationsInput | string
  }

  export type ApplicationProcedureCreateManyInput = {
    id?: number
    text: string
  }

  export type ApplicationProcedureUpdateManyMutationInput = {
    text?: StringFieldUpdateOperationsInput | string
  }

  export type ApplicationProcedureUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    text?: StringFieldUpdateOperationsInput | string
  }

  export type BenefitsCreateInput = {
    benefits: string
    advantages: string
  }

  export type BenefitsUncheckedCreateInput = {
    id?: number
    benefits: string
    advantages: string
  }

  export type BenefitsUpdateInput = {
    benefits?: StringFieldUpdateOperationsInput | string
    advantages?: StringFieldUpdateOperationsInput | string
  }

  export type BenefitsUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    benefits?: StringFieldUpdateOperationsInput | string
    advantages?: StringFieldUpdateOperationsInput | string
  }

  export type BenefitsCreateManyInput = {
    id?: number
    benefits: string
    advantages: string
  }

  export type BenefitsUpdateManyMutationInput = {
    benefits?: StringFieldUpdateOperationsInput | string
    advantages?: StringFieldUpdateOperationsInput | string
  }

  export type BenefitsUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    benefits?: StringFieldUpdateOperationsInput | string
    advantages?: StringFieldUpdateOperationsInput | string
  }

  export type PhotoAlbumCreateInput = {
    title: string
    photos?: GalleryPhotoCreateNestedManyWithoutAlbumInput
  }

  export type PhotoAlbumUncheckedCreateInput = {
    id?: number
    title: string
    photos?: GalleryPhotoUncheckedCreateNestedManyWithoutAlbumInput
  }

  export type PhotoAlbumUpdateInput = {
    title?: StringFieldUpdateOperationsInput | string
    photos?: GalleryPhotoUpdateManyWithoutAlbumNestedInput
  }

  export type PhotoAlbumUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    photos?: GalleryPhotoUncheckedUpdateManyWithoutAlbumNestedInput
  }

  export type PhotoAlbumCreateManyInput = {
    id?: number
    title: string
  }

  export type PhotoAlbumUpdateManyMutationInput = {
    title?: StringFieldUpdateOperationsInput | string
  }

  export type PhotoAlbumUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
  }

  export type GalleryPhotoCreateInput = {
    image: string
    album?: PhotoAlbumCreateNestedOneWithoutPhotosInput
  }

  export type GalleryPhotoUncheckedCreateInput = {
    id?: number
    image: string
    PhotoAlbumId?: number | null
  }

  export type GalleryPhotoUpdateInput = {
    image?: StringFieldUpdateOperationsInput | string
    album?: PhotoAlbumUpdateOneWithoutPhotosNestedInput
  }

  export type GalleryPhotoUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    image?: StringFieldUpdateOperationsInput | string
    PhotoAlbumId?: NullableIntFieldUpdateOperationsInput | number | null
  }

  export type GalleryPhotoCreateManyInput = {
    id?: number
    image: string
    PhotoAlbumId?: number | null
  }

  export type GalleryPhotoUpdateManyMutationInput = {
    image?: StringFieldUpdateOperationsInput | string
  }

  export type GalleryPhotoUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    image?: StringFieldUpdateOperationsInput | string
    PhotoAlbumId?: NullableIntFieldUpdateOperationsInput | number | null
  }

  export type GalleryVideoCreateInput = {
    title: string
    link: string
  }

  export type GalleryVideoUncheckedCreateInput = {
    id?: number
    title: string
    link: string
  }

  export type GalleryVideoUpdateInput = {
    title?: StringFieldUpdateOperationsInput | string
    link?: StringFieldUpdateOperationsInput | string
  }

  export type GalleryVideoUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    link?: StringFieldUpdateOperationsInput | string
  }

  export type GalleryVideoCreateManyInput = {
    id?: number
    title: string
    link: string
  }

  export type GalleryVideoUpdateManyMutationInput = {
    title?: StringFieldUpdateOperationsInput | string
    link?: StringFieldUpdateOperationsInput | string
  }

  export type GalleryVideoUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    link?: StringFieldUpdateOperationsInput | string
  }

  export type CondolenceCreateInput = {
    name: string
    position: string
    period: string
    featured: boolean
    image: string
    text?: string | null
  }

  export type CondolenceUncheckedCreateInput = {
    id?: number
    name: string
    position: string
    period: string
    featured: boolean
    image: string
    text?: string | null
  }

  export type CondolenceUpdateInput = {
    name?: StringFieldUpdateOperationsInput | string
    position?: StringFieldUpdateOperationsInput | string
    period?: StringFieldUpdateOperationsInput | string
    featured?: BoolFieldUpdateOperationsInput | boolean
    image?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type CondolenceUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    position?: StringFieldUpdateOperationsInput | string
    period?: StringFieldUpdateOperationsInput | string
    featured?: BoolFieldUpdateOperationsInput | boolean
    image?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type CondolenceCreateManyInput = {
    id?: number
    name: string
    position: string
    period: string
    featured: boolean
    image: string
    text?: string | null
  }

  export type CondolenceUpdateManyMutationInput = {
    name?: StringFieldUpdateOperationsInput | string
    position?: StringFieldUpdateOperationsInput | string
    period?: StringFieldUpdateOperationsInput | string
    featured?: BoolFieldUpdateOperationsInput | boolean
    image?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type CondolenceUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    position?: StringFieldUpdateOperationsInput | string
    period?: StringFieldUpdateOperationsInput | string
    featured?: BoolFieldUpdateOperationsInput | boolean
    image?: StringFieldUpdateOperationsInput | string
    text?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type AffiliatesCreateInput = {
    logo: string
  }

  export type AffiliatesUncheckedCreateInput = {
    id?: number
    logo: string
  }

  export type AffiliatesUpdateInput = {
    logo?: StringFieldUpdateOperationsInput | string
  }

  export type AffiliatesUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    logo?: StringFieldUpdateOperationsInput | string
  }

  export type AffiliatesCreateManyInput = {
    id?: number
    logo: string
  }

  export type AffiliatesUpdateManyMutationInput = {
    logo?: StringFieldUpdateOperationsInput | string
  }

  export type AffiliatesUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    logo?: StringFieldUpdateOperationsInput | string
  }

  export type SubscribersCreateInput = {
    email: string
    date?: Date | string
  }

  export type SubscribersUncheckedCreateInput = {
    id?: number
    email: string
    date?: Date | string
  }

  export type SubscribersUpdateInput = {
    email?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SubscribersUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    email?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SubscribersCreateManyInput = {
    id?: number
    email: string
    date?: Date | string
  }

  export type SubscribersUpdateManyMutationInput = {
    email?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SubscribersUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    email?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MessagesCreateInput = {
    email: string
    name: string
    phone: string
    message: string
    date?: Date | string
  }

  export type MessagesUncheckedCreateInput = {
    id?: number
    email: string
    name: string
    phone: string
    message: string
    date?: Date | string
  }

  export type MessagesUpdateInput = {
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MessagesUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MessagesCreateManyInput = {
    id?: number
    email: string
    name: string
    phone: string
    message: string
    date?: Date | string
  }

  export type MessagesUpdateManyMutationInput = {
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MessagesUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    email?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    phone?: StringFieldUpdateOperationsInput | string
    message?: StringFieldUpdateOperationsInput | string
    date?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type IntFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[]
    notIn?: number[]
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntFilter<$PrismaModel> | number
  }

  export type StringFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[]
    notIn?: string[]
    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 latestNewsCountOrderByAggregateInput = {
    id?: SortOrder
    news?: SortOrder
  }

  export type latestNewsAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type latestNewsMaxOrderByAggregateInput = {
    id?: SortOrder
    news?: SortOrder
  }

  export type latestNewsMinOrderByAggregateInput = {
    id?: SortOrder
    news?: SortOrder
  }

  export type latestNewsSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type IntWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[]
    notIn?: number[]
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntWithAggregatesFilter<$PrismaModel> | number
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedFloatFilter<$PrismaModel>
    _sum?: NestedIntFilter<$PrismaModel>
    _min?: NestedIntFilter<$PrismaModel>
    _max?: NestedIntFilter<$PrismaModel>
  }

  export type StringWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[]
    notIn?: string[]
    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 sliderImagesCountOrderByAggregateInput = {
    id?: SortOrder
    image?: SortOrder
    caption?: SortOrder
  }

  export type sliderImagesAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type sliderImagesMaxOrderByAggregateInput = {
    id?: SortOrder
    image?: SortOrder
    caption?: SortOrder
  }

  export type sliderImagesMinOrderByAggregateInput = {
    id?: SortOrder
    image?: SortOrder
    caption?: SortOrder
  }

  export type sliderImagesSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ObjectivesListRelationFilter = {
    every?: objectivesWhereInput
    some?: objectivesWhereInput
    none?: objectivesWhereInput
  }

  export type objectivesOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type missionsCountOrderByAggregateInput = {
    id?: SortOrder
    text?: SortOrder
    pdfName?: SortOrder
  }

  export type missionsAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type missionsMaxOrderByAggregateInput = {
    id?: SortOrder
    text?: SortOrder
    pdfName?: SortOrder
  }

  export type missionsMinOrderByAggregateInput = {
    id?: SortOrder
    text?: SortOrder
    pdfName?: SortOrder
  }

  export type missionsSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type IntNullableFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | null
    notIn?: number[] | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableFilter<$PrismaModel> | number | null
  }

  export type MissionsNullableRelationFilter = {
    is?: missionsWhereInput | null
    isNot?: missionsWhereInput | null
  }

  export type SortOrderInput = {
    sort: SortOrder
    nulls?: NullsOrder
  }

  export type objectivesCountOrderByAggregateInput = {
    id?: SortOrder
    text?: SortOrder
    bg?: SortOrder
    missionsId?: SortOrder
  }

  export type objectivesAvgOrderByAggregateInput = {
    id?: SortOrder
    missionsId?: SortOrder
  }

  export type objectivesMaxOrderByAggregateInput = {
    id?: SortOrder
    text?: SortOrder
    bg?: SortOrder
    missionsId?: SortOrder
  }

  export type objectivesMinOrderByAggregateInput = {
    id?: SortOrder
    text?: SortOrder
    bg?: SortOrder
    missionsId?: SortOrder
  }

  export type objectivesSumOrderByAggregateInput = {
    id?: SortOrder
    missionsId?: SortOrder
  }

  export type IntNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | null
    notIn?: number[] | 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 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
    lte?: InputJsonValue
    gt?: InputJsonValue
    gte?: InputJsonValue
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
  }

  export type StringNullableFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | null
    notIn?: string[] | 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 homeDataCountOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    text?: SortOrder
    image?: SortOrder
    pdf?: SortOrder
  }

  export type homeDataAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type homeDataMaxOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    text?: SortOrder
    pdf?: SortOrder
  }

  export type homeDataMinOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    text?: SortOrder
    pdf?: SortOrder
  }

  export type homeDataSumOrderByAggregateInput = {
    id?: SortOrder
  }
  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
    lte?: InputJsonValue
    gt?: InputJsonValue
    gte?: InputJsonValue
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedJsonNullableFilter<$PrismaModel>
    _max?: NestedJsonNullableFilter<$PrismaModel>
  }

  export type StringNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | null
    notIn?: string[] | 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 briefDataCountOrderByAggregateInput = {
    id?: SortOrder
    text?: SortOrder
    image?: SortOrder
  }

  export type briefDataAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type briefDataMaxOrderByAggregateInput = {
    id?: SortOrder
    text?: SortOrder
  }

  export type briefDataMinOrderByAggregateInput = {
    id?: SortOrder
    text?: SortOrder
  }

  export type briefDataSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type serviceDataCountOrderByAggregateInput = {
    id?: SortOrder
    text?: SortOrder
    bg?: SortOrder
    bg2?: SortOrder
  }

  export type serviceDataAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type serviceDataMaxOrderByAggregateInput = {
    id?: SortOrder
    text?: SortOrder
    bg?: SortOrder
    bg2?: SortOrder
  }

  export type serviceDataMinOrderByAggregateInput = {
    id?: SortOrder
    text?: SortOrder
    bg?: SortOrder
    bg2?: SortOrder
  }

  export type serviceDataSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type activitiesDataCountOrderByAggregateInput = {
    id?: SortOrder
    text?: SortOrder
    bg?: SortOrder
    bg2?: SortOrder
  }

  export type activitiesDataAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type activitiesDataMaxOrderByAggregateInput = {
    id?: SortOrder
    text?: SortOrder
    bg?: SortOrder
    bg2?: SortOrder
  }

  export type activitiesDataMinOrderByAggregateInput = {
    id?: SortOrder
    text?: SortOrder
    bg?: SortOrder
    bg2?: SortOrder
  }

  export type activitiesDataSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type formerChairmanCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    position?: SortOrder
    period?: SortOrder
  }

  export type formerChairmanAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type formerChairmanMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    position?: SortOrder
    period?: SortOrder
  }

  export type formerChairmanMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    position?: SortOrder
    period?: SortOrder
  }

  export type formerChairmanSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type formerSrViceChairmanCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    position?: SortOrder
    period?: SortOrder
  }

  export type formerSrViceChairmanAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type formerSrViceChairmanMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    position?: SortOrder
    period?: SortOrder
  }

  export type formerSrViceChairmanMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    position?: SortOrder
    period?: SortOrder
  }

  export type formerSrViceChairmanSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type formerViceChairmanCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    position?: SortOrder
    period?: SortOrder
  }

  export type formerViceChairmanAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type formerViceChairmanMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    position?: SortOrder
    period?: SortOrder
  }

  export type formerViceChairmanMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    position?: SortOrder
    period?: SortOrder
  }

  export type formerViceChairmanSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ChairmanAssociationListRelationFilter = {
    every?: ChairmanAssociationWhereInput
    some?: ChairmanAssociationWhereInput
    none?: ChairmanAssociationWhereInput
  }

  export type ChairmanClubsListRelationFilter = {
    every?: ChairmanClubsWhereInput
    some?: ChairmanClubsWhereInput
    none?: ChairmanClubsWhereInput
  }

  export type ChairmanAssociationOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ChairmanClubsOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ChairmanProfileCountOrderByAggregateInput = {
    id?: SortOrder
    image?: SortOrder
    name?: SortOrder
    academic?: SortOrder
    profession?: SortOrder
    business?: SortOrder
    presentPosition?: SortOrder
    foreignTravel?: SortOrder
  }

  export type ChairmanProfileAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ChairmanProfileMaxOrderByAggregateInput = {
    id?: SortOrder
    image?: SortOrder
    name?: SortOrder
    academic?: SortOrder
    profession?: SortOrder
    business?: SortOrder
    presentPosition?: SortOrder
    foreignTravel?: SortOrder
  }

  export type ChairmanProfileMinOrderByAggregateInput = {
    id?: SortOrder
    image?: SortOrder
    name?: SortOrder
    academic?: SortOrder
    profession?: SortOrder
    business?: SortOrder
    presentPosition?: SortOrder
    foreignTravel?: SortOrder
  }

  export type ChairmanProfileSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ChairmanProfileNullableRelationFilter = {
    is?: ChairmanProfileWhereInput | null
    isNot?: ChairmanProfileWhereInput | null
  }

  export type ChairmanAssociationCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    text?: SortOrder
    ChairmanProfileId?: SortOrder
  }

  export type ChairmanAssociationAvgOrderByAggregateInput = {
    id?: SortOrder
    ChairmanProfileId?: SortOrder
  }

  export type ChairmanAssociationMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    text?: SortOrder
    ChairmanProfileId?: SortOrder
  }

  export type ChairmanAssociationMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    text?: SortOrder
    ChairmanProfileId?: SortOrder
  }

  export type ChairmanAssociationSumOrderByAggregateInput = {
    id?: SortOrder
    ChairmanProfileId?: SortOrder
  }

  export type ChairmanClubsCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    text?: SortOrder
    ChairmanProfileId?: SortOrder
  }

  export type ChairmanClubsAvgOrderByAggregateInput = {
    id?: SortOrder
    ChairmanProfileId?: SortOrder
  }

  export type ChairmanClubsMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    text?: SortOrder
    ChairmanProfileId?: SortOrder
  }

  export type ChairmanClubsMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    text?: SortOrder
    ChairmanProfileId?: SortOrder
  }

  export type ChairmanClubsSumOrderByAggregateInput = {
    id?: SortOrder
    ChairmanProfileId?: SortOrder
  }

  export type ChairmanMessageCountOrderByAggregateInput = {
    id?: SortOrder
    message?: SortOrder
  }

  export type ChairmanMessageAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ChairmanMessageMaxOrderByAggregateInput = {
    id?: SortOrder
    message?: SortOrder
  }

  export type ChairmanMessageMinOrderByAggregateInput = {
    id?: SortOrder
    message?: SortOrder
  }

  export type ChairmanMessageSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ChairmanSpeechCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    pdf?: SortOrder
    date?: SortOrder
  }

  export type ChairmanSpeechAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ChairmanSpeechMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    pdf?: SortOrder
    date?: SortOrder
  }

  export type ChairmanSpeechMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    pdf?: SortOrder
    date?: SortOrder
  }

  export type ChairmanSpeechSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ChairmanInterviewPrintCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    pdf?: SortOrder
    date?: SortOrder
  }

  export type ChairmanInterviewPrintAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ChairmanInterviewPrintMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    pdf?: SortOrder
    date?: SortOrder
  }

  export type ChairmanInterviewPrintMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    pdf?: SortOrder
    date?: SortOrder
  }

  export type ChairmanInterviewPrintSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ChairmanInterviewElectronicCountOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    link?: SortOrder
  }

  export type ChairmanInterviewElectronicAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ChairmanInterviewElectronicMaxOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    link?: SortOrder
  }

  export type ChairmanInterviewElectronicMinOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    link?: SortOrder
  }

  export type ChairmanInterviewElectronicSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ChairmanPresentationCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    pdf?: SortOrder
    date?: SortOrder
  }

  export type ChairmanPresentationAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ChairmanPresentationMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    pdf?: SortOrder
    date?: SortOrder
  }

  export type ChairmanPresentationMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    pdf?: SortOrder
    date?: SortOrder
  }

  export type ChairmanPresentationSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type memorandumCountOrderByAggregateInput = {
    id?: SortOrder
    pdf?: SortOrder
  }

  export type memorandumAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type memorandumMaxOrderByAggregateInput = {
    id?: SortOrder
    pdf?: SortOrder
  }

  export type memorandumMinOrderByAggregateInput = {
    id?: SortOrder
    pdf?: SortOrder
  }

  export type memorandumSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type BoardOfDirectorsCountOrderByAggregateInput = {
    id?: SortOrder
    image?: SortOrder
    name?: SortOrder
    designation?: SortOrder
  }

  export type BoardOfDirectorsAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type BoardOfDirectorsMaxOrderByAggregateInput = {
    id?: SortOrder
    image?: SortOrder
    name?: SortOrder
    designation?: SortOrder
  }

  export type BoardOfDirectorsMinOrderByAggregateInput = {
    id?: SortOrder
    image?: SortOrder
    name?: SortOrder
    designation?: SortOrder
  }

  export type BoardOfDirectorsSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ShippersNewsCountOrderByAggregateInput = {
    id?: SortOrder
    image?: SortOrder
    name?: SortOrder
    date?: SortOrder
    volume?: SortOrder
    pdf?: SortOrder
  }

  export type ShippersNewsAvgOrderByAggregateInput = {
    id?: SortOrder
    volume?: SortOrder
  }

  export type ShippersNewsMaxOrderByAggregateInput = {
    id?: SortOrder
    image?: SortOrder
    name?: SortOrder
    date?: SortOrder
    volume?: SortOrder
    pdf?: SortOrder
  }

  export type ShippersNewsMinOrderByAggregateInput = {
    id?: SortOrder
    image?: SortOrder
    name?: SortOrder
    date?: SortOrder
    volume?: SortOrder
    pdf?: SortOrder
  }

  export type ShippersNewsSumOrderByAggregateInput = {
    id?: SortOrder
    volume?: SortOrder
  }

  export type AnnualReportCountOrderByAggregateInput = {
    id?: SortOrder
    image?: SortOrder
    name?: SortOrder
    date?: SortOrder
    pdf?: SortOrder
  }

  export type AnnualReportAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type AnnualReportMaxOrderByAggregateInput = {
    id?: SortOrder
    image?: SortOrder
    name?: SortOrder
    date?: SortOrder
    pdf?: SortOrder
  }

  export type AnnualReportMinOrderByAggregateInput = {
    id?: SortOrder
    image?: SortOrder
    name?: SortOrder
    date?: SortOrder
    pdf?: SortOrder
  }

  export type AnnualReportSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type OtherPublicationsCountOrderByAggregateInput = {
    id?: SortOrder
    image?: SortOrder
    name?: SortOrder
    date?: SortOrder
    pdf?: SortOrder
  }

  export type OtherPublicationsAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type OtherPublicationsMaxOrderByAggregateInput = {
    id?: SortOrder
    image?: SortOrder
    name?: SortOrder
    date?: SortOrder
    pdf?: SortOrder
  }

  export type OtherPublicationsMinOrderByAggregateInput = {
    id?: SortOrder
    image?: SortOrder
    name?: SortOrder
    date?: SortOrder
    pdf?: SortOrder
  }

  export type OtherPublicationsSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type SCBRecommendationsCountOrderByAggregateInput = {
    id?: SortOrder
    type?: SortOrder
    name?: SortOrder
    date?: SortOrder
    pdf?: SortOrder
  }

  export type SCBRecommendationsAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type SCBRecommendationsMaxOrderByAggregateInput = {
    id?: SortOrder
    type?: SortOrder
    name?: SortOrder
    date?: SortOrder
    pdf?: SortOrder
  }

  export type SCBRecommendationsMinOrderByAggregateInput = {
    id?: SortOrder
    type?: SortOrder
    name?: SortOrder
    date?: SortOrder
    pdf?: SortOrder
  }

  export type SCBRecommendationsSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type SCBSeminarCountOrderByAggregateInput = {
    id?: SortOrder
    type?: SortOrder
    name?: SortOrder
    date?: SortOrder
    pdf?: SortOrder
  }

  export type SCBSeminarAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type SCBSeminarMaxOrderByAggregateInput = {
    id?: SortOrder
    type?: SortOrder
    name?: SortOrder
    date?: SortOrder
    pdf?: SortOrder
  }

  export type SCBSeminarMinOrderByAggregateInput = {
    id?: SortOrder
    type?: SortOrder
    name?: SortOrder
    date?: SortOrder
    pdf?: SortOrder
  }

  export type SCBSeminarSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type EligibilityCountOrderByAggregateInput = {
    id?: SortOrder
    type?: SortOrder
    text?: SortOrder
    admission?: SortOrder
    subscription?: SortOrder
  }

  export type EligibilityAvgOrderByAggregateInput = {
    id?: SortOrder
    admission?: SortOrder
    subscription?: SortOrder
  }

  export type EligibilityMaxOrderByAggregateInput = {
    id?: SortOrder
    type?: SortOrder
    text?: SortOrder
    admission?: SortOrder
    subscription?: SortOrder
  }

  export type EligibilityMinOrderByAggregateInput = {
    id?: SortOrder
    type?: SortOrder
    text?: SortOrder
    admission?: SortOrder
    subscription?: SortOrder
  }

  export type EligibilitySumOrderByAggregateInput = {
    id?: SortOrder
    admission?: SortOrder
    subscription?: SortOrder
  }

  export type RelevantPapersCountOrderByAggregateInput = {
    id?: SortOrder
    type?: SortOrder
    papers?: SortOrder
  }

  export type RelevantPapersAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type RelevantPapersMaxOrderByAggregateInput = {
    id?: SortOrder
    type?: SortOrder
    papers?: SortOrder
  }

  export type RelevantPapersMinOrderByAggregateInput = {
    id?: SortOrder
    type?: SortOrder
    papers?: SortOrder
  }

  export type RelevantPapersSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type MembersListCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    type?: SortOrder
    membershipId?: SortOrder
  }

  export type MembersListAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type MembersListMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    type?: SortOrder
    membershipId?: SortOrder
  }

  export type MembersListMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    type?: SortOrder
    membershipId?: SortOrder
  }

  export type MembersListSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type UsefulLinksCountOrderByAggregateInput = {
    id?: SortOrder
    type?: SortOrder
    logo?: SortOrder
    Name?: SortOrder
    text?: SortOrder
  }

  export type UsefulLinksAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type UsefulLinksMaxOrderByAggregateInput = {
    id?: SortOrder
    type?: SortOrder
    logo?: SortOrder
    Name?: SortOrder
    text?: SortOrder
  }

  export type UsefulLinksMinOrderByAggregateInput = {
    id?: SortOrder
    type?: SortOrder
    logo?: SortOrder
    Name?: SortOrder
    text?: SortOrder
  }

  export type UsefulLinksSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ContactUsCountOrderByAggregateInput = {
    id?: SortOrder
    address?: SortOrder
    telephone?: SortOrder
    email?: SortOrder
  }

  export type ContactUsAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ContactUsMaxOrderByAggregateInput = {
    id?: SortOrder
    address?: SortOrder
    telephone?: SortOrder
    email?: SortOrder
  }

  export type ContactUsMinOrderByAggregateInput = {
    id?: SortOrder
    address?: SortOrder
    telephone?: SortOrder
    email?: SortOrder
  }

  export type ContactUsSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type SecretariatCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    position?: SortOrder
  }

  export type SecretariatAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type SecretariatMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    position?: SortOrder
  }

  export type SecretariatMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    position?: SortOrder
  }

  export type SecretariatSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type PDFsCountOrderByAggregateInput = {
    id?: SortOrder
    pdf?: SortOrder
    image?: SortOrder
    title?: SortOrder
    type?: SortOrder
  }

  export type PDFsAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type PDFsMaxOrderByAggregateInput = {
    id?: SortOrder
    pdf?: SortOrder
    image?: SortOrder
    title?: SortOrder
    type?: SortOrder
  }

  export type PDFsMinOrderByAggregateInput = {
    id?: SortOrder
    pdf?: SortOrder
    image?: SortOrder
    title?: SortOrder
    type?: SortOrder
  }

  export type PDFsSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type FormsCountOrderByAggregateInput = {
    id?: SortOrder
    pdf?: SortOrder
    title?: SortOrder
    type?: SortOrder
  }

  export type FormsAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type FormsMaxOrderByAggregateInput = {
    id?: SortOrder
    pdf?: SortOrder
    title?: SortOrder
    type?: SortOrder
  }

  export type FormsMinOrderByAggregateInput = {
    id?: SortOrder
    pdf?: SortOrder
    title?: SortOrder
    type?: SortOrder
  }

  export type FormsSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type MembershipTextCountOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    text?: SortOrder
  }

  export type MembershipTextAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type MembershipTextMaxOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    text?: SortOrder
  }

  export type MembershipTextMinOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    text?: SortOrder
  }

  export type MembershipTextSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ApplicationProcedureCountOrderByAggregateInput = {
    id?: SortOrder
    text?: SortOrder
  }

  export type ApplicationProcedureAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type ApplicationProcedureMaxOrderByAggregateInput = {
    id?: SortOrder
    text?: SortOrder
  }

  export type ApplicationProcedureMinOrderByAggregateInput = {
    id?: SortOrder
    text?: SortOrder
  }

  export type ApplicationProcedureSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type BenefitsCountOrderByAggregateInput = {
    id?: SortOrder
    benefits?: SortOrder
    advantages?: SortOrder
  }

  export type BenefitsAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type BenefitsMaxOrderByAggregateInput = {
    id?: SortOrder
    benefits?: SortOrder
    advantages?: SortOrder
  }

  export type BenefitsMinOrderByAggregateInput = {
    id?: SortOrder
    benefits?: SortOrder
    advantages?: SortOrder
  }

  export type BenefitsSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type GalleryPhotoListRelationFilter = {
    every?: GalleryPhotoWhereInput
    some?: GalleryPhotoWhereInput
    none?: GalleryPhotoWhereInput
  }

  export type GalleryPhotoOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type PhotoAlbumCountOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
  }

  export type PhotoAlbumAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type PhotoAlbumMaxOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
  }

  export type PhotoAlbumMinOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
  }

  export type PhotoAlbumSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type PhotoAlbumNullableRelationFilter = {
    is?: PhotoAlbumWhereInput | null
    isNot?: PhotoAlbumWhereInput | null
  }

  export type GalleryPhotoCountOrderByAggregateInput = {
    id?: SortOrder
    image?: SortOrder
    PhotoAlbumId?: SortOrder
  }

  export type GalleryPhotoAvgOrderByAggregateInput = {
    id?: SortOrder
    PhotoAlbumId?: SortOrder
  }

  export type GalleryPhotoMaxOrderByAggregateInput = {
    id?: SortOrder
    image?: SortOrder
    PhotoAlbumId?: SortOrder
  }

  export type GalleryPhotoMinOrderByAggregateInput = {
    id?: SortOrder
    image?: SortOrder
    PhotoAlbumId?: SortOrder
  }

  export type GalleryPhotoSumOrderByAggregateInput = {
    id?: SortOrder
    PhotoAlbumId?: SortOrder
  }

  export type GalleryVideoCountOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    link?: SortOrder
  }

  export type GalleryVideoAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type GalleryVideoMaxOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    link?: SortOrder
  }

  export type GalleryVideoMinOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    link?: SortOrder
  }

  export type GalleryVideoSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type BoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  export type CondolenceCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    position?: SortOrder
    period?: SortOrder
    featured?: SortOrder
    image?: SortOrder
    text?: SortOrder
  }

  export type CondolenceAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type CondolenceMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    position?: SortOrder
    period?: SortOrder
    featured?: SortOrder
    image?: SortOrder
    text?: SortOrder
  }

  export type CondolenceMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    position?: SortOrder
    period?: SortOrder
    featured?: SortOrder
    image?: SortOrder
    text?: SortOrder
  }

  export type CondolenceSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type BoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$PrismaModel>
  }

  export type AffiliatesCountOrderByAggregateInput = {
    id?: SortOrder
    logo?: SortOrder
  }

  export type AffiliatesAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type AffiliatesMaxOrderByAggregateInput = {
    id?: SortOrder
    logo?: SortOrder
  }

  export type AffiliatesMinOrderByAggregateInput = {
    id?: SortOrder
    logo?: SortOrder
  }

  export type AffiliatesSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type DateTimeFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[]
    notIn?: Date[] | string[]
    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 SubscribersCountOrderByAggregateInput = {
    id?: SortOrder
    email?: SortOrder
    date?: SortOrder
  }

  export type SubscribersAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type SubscribersMaxOrderByAggregateInput = {
    id?: SortOrder
    email?: SortOrder
    date?: SortOrder
  }

  export type SubscribersMinOrderByAggregateInput = {
    id?: SortOrder
    email?: SortOrder
    date?: SortOrder
  }

  export type SubscribersSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type DateTimeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[]
    notIn?: Date[] | string[]
    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 MessagesCountOrderByAggregateInput = {
    id?: SortOrder
    email?: SortOrder
    name?: SortOrder
    phone?: SortOrder
    message?: SortOrder
    date?: SortOrder
  }

  export type MessagesAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type MessagesMaxOrderByAggregateInput = {
    id?: SortOrder
    email?: SortOrder
    name?: SortOrder
    phone?: SortOrder
    message?: SortOrder
    date?: SortOrder
  }

  export type MessagesMinOrderByAggregateInput = {
    id?: SortOrder
    email?: SortOrder
    name?: SortOrder
    phone?: SortOrder
    message?: SortOrder
    date?: SortOrder
  }

  export type MessagesSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type StringFieldUpdateOperationsInput = {
    set?: string
  }

  export type IntFieldUpdateOperationsInput = {
    set?: number
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type objectivesCreateNestedManyWithoutMissionsInput = {
    create?: XOR<objectivesCreateWithoutMissionsInput, objectivesUncheckedCreateWithoutMissionsInput> | objectivesCreateWithoutMissionsInput[] | objectivesUncheckedCreateWithoutMissionsInput[]
    connectOrCreate?: objectivesCreateOrConnectWithoutMissionsInput | objectivesCreateOrConnectWithoutMissionsInput[]
    createMany?: objectivesCreateManyMissionsInputEnvelope
    connect?: objectivesWhereUniqueInput | objectivesWhereUniqueInput[]
  }

  export type objectivesUncheckedCreateNestedManyWithoutMissionsInput = {
    create?: XOR<objectivesCreateWithoutMissionsInput, objectivesUncheckedCreateWithoutMissionsInput> | objectivesCreateWithoutMissionsInput[] | objectivesUncheckedCreateWithoutMissionsInput[]
    connectOrCreate?: objectivesCreateOrConnectWithoutMissionsInput | objectivesCreateOrConnectWithoutMissionsInput[]
    createMany?: objectivesCreateManyMissionsInputEnvelope
    connect?: objectivesWhereUniqueInput | objectivesWhereUniqueInput[]
  }

  export type objectivesUpdateManyWithoutMissionsNestedInput = {
    create?: XOR<objectivesCreateWithoutMissionsInput, objectivesUncheckedCreateWithoutMissionsInput> | objectivesCreateWithoutMissionsInput[] | objectivesUncheckedCreateWithoutMissionsInput[]
    connectOrCreate?: objectivesCreateOrConnectWithoutMissionsInput | objectivesCreateOrConnectWithoutMissionsInput[]
    upsert?: objectivesUpsertWithWhereUniqueWithoutMissionsInput | objectivesUpsertWithWhereUniqueWithoutMissionsInput[]
    createMany?: objectivesCreateManyMissionsInputEnvelope
    set?: objectivesWhereUniqueInput | objectivesWhereUniqueInput[]
    disconnect?: objectivesWhereUniqueInput | objectivesWhereUniqueInput[]
    delete?: objectivesWhereUniqueInput | objectivesWhereUniqueInput[]
    connect?: objectivesWhereUniqueInput | objectivesWhereUniqueInput[]
    update?: objectivesUpdateWithWhereUniqueWithoutMissionsInput | objectivesUpdateWithWhereUniqueWithoutMissionsInput[]
    updateMany?: objectivesUpdateManyWithWhereWithoutMissionsInput | objectivesUpdateManyWithWhereWithoutMissionsInput[]
    deleteMany?: objectivesScalarWhereInput | objectivesScalarWhereInput[]
  }

  export type objectivesUncheckedUpdateManyWithoutMissionsNestedInput = {
    create?: XOR<objectivesCreateWithoutMissionsInput, objectivesUncheckedCreateWithoutMissionsInput> | objectivesCreateWithoutMissionsInput[] | objectivesUncheckedCreateWithoutMissionsInput[]
    connectOrCreate?: objectivesCreateOrConnectWithoutMissionsInput | objectivesCreateOrConnectWithoutMissionsInput[]
    upsert?: objectivesUpsertWithWhereUniqueWithoutMissionsInput | objectivesUpsertWithWhereUniqueWithoutMissionsInput[]
    createMany?: objectivesCreateManyMissionsInputEnvelope
    set?: objectivesWhereUniqueInput | objectivesWhereUniqueInput[]
    disconnect?: objectivesWhereUniqueInput | objectivesWhereUniqueInput[]
    delete?: objectivesWhereUniqueInput | objectivesWhereUniqueInput[]
    connect?: objectivesWhereUniqueInput | objectivesWhereUniqueInput[]
    update?: objectivesUpdateWithWhereUniqueWithoutMissionsInput | objectivesUpdateWithWhereUniqueWithoutMissionsInput[]
    updateMany?: objectivesUpdateManyWithWhereWithoutMissionsInput | objectivesUpdateManyWithWhereWithoutMissionsInput[]
    deleteMany?: objectivesScalarWhereInput | objectivesScalarWhereInput[]
  }

  export type missionsCreateNestedOneWithoutObjectiveListInput = {
    create?: XOR<missionsCreateWithoutObjectiveListInput, missionsUncheckedCreateWithoutObjectiveListInput>
    connectOrCreate?: missionsCreateOrConnectWithoutObjectiveListInput
    connect?: missionsWhereUniqueInput
  }

  export type missionsUpdateOneWithoutObjectiveListNestedInput = {
    create?: XOR<missionsCreateWithoutObjectiveListInput, missionsUncheckedCreateWithoutObjectiveListInput>
    connectOrCreate?: missionsCreateOrConnectWithoutObjectiveListInput
    upsert?: missionsUpsertWithoutObjectiveListInput
    disconnect?: missionsWhereInput | boolean
    delete?: missionsWhereInput | boolean
    connect?: missionsWhereUniqueInput
    update?: XOR<XOR<missionsUpdateToOneWithWhereWithoutObjectiveListInput, missionsUpdateWithoutObjectiveListInput>, missionsUncheckedUpdateWithoutObjectiveListInput>
  }

  export type NullableIntFieldUpdateOperationsInput = {
    set?: number | null
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type NullableStringFieldUpdateOperationsInput = {
    set?: string | null
  }

  export type ChairmanAssociationCreateNestedManyWithoutProfileInput = {
    create?: XOR<ChairmanAssociationCreateWithoutProfileInput, ChairmanAssociationUncheckedCreateWithoutProfileInput> | ChairmanAssociationCreateWithoutProfileInput[] | ChairmanAssociationUncheckedCreateWithoutProfileInput[]
    connectOrCreate?: ChairmanAssociationCreateOrConnectWithoutProfileInput | ChairmanAssociationCreateOrConnectWithoutProfileInput[]
    createMany?: ChairmanAssociationCreateManyProfileInputEnvelope
    connect?: ChairmanAssociationWhereUniqueInput | ChairmanAssociationWhereUniqueInput[]
  }

  export type ChairmanClubsCreateNestedManyWithoutProfileInput = {
    create?: XOR<ChairmanClubsCreateWithoutProfileInput, ChairmanClubsUncheckedCreateWithoutProfileInput> | ChairmanClubsCreateWithoutProfileInput[] | ChairmanClubsUncheckedCreateWithoutProfileInput[]
    connectOrCreate?: ChairmanClubsCreateOrConnectWithoutProfileInput | ChairmanClubsCreateOrConnectWithoutProfileInput[]
    createMany?: ChairmanClubsCreateManyProfileInputEnvelope
    connect?: ChairmanClubsWhereUniqueInput | ChairmanClubsWhereUniqueInput[]
  }

  export type ChairmanAssociationUncheckedCreateNestedManyWithoutProfileInput = {
    create?: XOR<ChairmanAssociationCreateWithoutProfileInput, ChairmanAssociationUncheckedCreateWithoutProfileInput> | ChairmanAssociationCreateWithoutProfileInput[] | ChairmanAssociationUncheckedCreateWithoutProfileInput[]
    connectOrCreate?: ChairmanAssociationCreateOrConnectWithoutProfileInput | ChairmanAssociationCreateOrConnectWithoutProfileInput[]
    createMany?: ChairmanAssociationCreateManyProfileInputEnvelope
    connect?: ChairmanAssociationWhereUniqueInput | ChairmanAssociationWhereUniqueInput[]
  }

  export type ChairmanClubsUncheckedCreateNestedManyWithoutProfileInput = {
    create?: XOR<ChairmanClubsCreateWithoutProfileInput, ChairmanClubsUncheckedCreateWithoutProfileInput> | ChairmanClubsCreateWithoutProfileInput[] | ChairmanClubsUncheckedCreateWithoutProfileInput[]
    connectOrCreate?: ChairmanClubsCreateOrConnectWithoutProfileInput | ChairmanClubsCreateOrConnectWithoutProfileInput[]
    createMany?: ChairmanClubsCreateManyProfileInputEnvelope
    connect?: ChairmanClubsWhereUniqueInput | ChairmanClubsWhereUniqueInput[]
  }

  export type ChairmanAssociationUpdateManyWithoutProfileNestedInput = {
    create?: XOR<ChairmanAssociationCreateWithoutProfileInput, ChairmanAssociationUncheckedCreateWithoutProfileInput> | ChairmanAssociationCreateWithoutProfileInput[] | ChairmanAssociationUncheckedCreateWithoutProfileInput[]
    connectOrCreate?: ChairmanAssociationCreateOrConnectWithoutProfileInput | ChairmanAssociationCreateOrConnectWithoutProfileInput[]
    upsert?: ChairmanAssociationUpsertWithWhereUniqueWithoutProfileInput | ChairmanAssociationUpsertWithWhereUniqueWithoutProfileInput[]
    createMany?: ChairmanAssociationCreateManyProfileInputEnvelope
    set?: ChairmanAssociationWhereUniqueInput | ChairmanAssociationWhereUniqueInput[]
    disconnect?: ChairmanAssociationWhereUniqueInput | ChairmanAssociationWhereUniqueInput[]
    delete?: ChairmanAssociationWhereUniqueInput | ChairmanAssociationWhereUniqueInput[]
    connect?: ChairmanAssociationWhereUniqueInput | ChairmanAssociationWhereUniqueInput[]
    update?: ChairmanAssociationUpdateWithWhereUniqueWithoutProfileInput | ChairmanAssociationUpdateWithWhereUniqueWithoutProfileInput[]
    updateMany?: ChairmanAssociationUpdateManyWithWhereWithoutProfileInput | ChairmanAssociationUpdateManyWithWhereWithoutProfileInput[]
    deleteMany?: ChairmanAssociationScalarWhereInput | ChairmanAssociationScalarWhereInput[]
  }

  export type ChairmanClubsUpdateManyWithoutProfileNestedInput = {
    create?: XOR<ChairmanClubsCreateWithoutProfileInput, ChairmanClubsUncheckedCreateWithoutProfileInput> | ChairmanClubsCreateWithoutProfileInput[] | ChairmanClubsUncheckedCreateWithoutProfileInput[]
    connectOrCreate?: ChairmanClubsCreateOrConnectWithoutProfileInput | ChairmanClubsCreateOrConnectWithoutProfileInput[]
    upsert?: ChairmanClubsUpsertWithWhereUniqueWithoutProfileInput | ChairmanClubsUpsertWithWhereUniqueWithoutProfileInput[]
    createMany?: ChairmanClubsCreateManyProfileInputEnvelope
    set?: ChairmanClubsWhereUniqueInput | ChairmanClubsWhereUniqueInput[]
    disconnect?: ChairmanClubsWhereUniqueInput | ChairmanClubsWhereUniqueInput[]
    delete?: ChairmanClubsWhereUniqueInput | ChairmanClubsWhereUniqueInput[]
    connect?: ChairmanClubsWhereUniqueInput | ChairmanClubsWhereUniqueInput[]
    update?: ChairmanClubsUpdateWithWhereUniqueWithoutProfileInput | ChairmanClubsUpdateWithWhereUniqueWithoutProfileInput[]
    updateMany?: ChairmanClubsUpdateManyWithWhereWithoutProfileInput | ChairmanClubsUpdateManyWithWhereWithoutProfileInput[]
    deleteMany?: ChairmanClubsScalarWhereInput | ChairmanClubsScalarWhereInput[]
  }

  export type ChairmanAssociationUncheckedUpdateManyWithoutProfileNestedInput = {
    create?: XOR<ChairmanAssociationCreateWithoutProfileInput, ChairmanAssociationUncheckedCreateWithoutProfileInput> | ChairmanAssociationCreateWithoutProfileInput[] | ChairmanAssociationUncheckedCreateWithoutProfileInput[]
    connectOrCreate?: ChairmanAssociationCreateOrConnectWithoutProfileInput | ChairmanAssociationCreateOrConnectWithoutProfileInput[]
    upsert?: ChairmanAssociationUpsertWithWhereUniqueWithoutProfileInput | ChairmanAssociationUpsertWithWhereUniqueWithoutProfileInput[]
    createMany?: ChairmanAssociationCreateManyProfileInputEnvelope
    set?: ChairmanAssociationWhereUniqueInput | ChairmanAssociationWhereUniqueInput[]
    disconnect?: ChairmanAssociationWhereUniqueInput | ChairmanAssociationWhereUniqueInput[]
    delete?: ChairmanAssociationWhereUniqueInput | ChairmanAssociationWhereUniqueInput[]
    connect?: ChairmanAssociationWhereUniqueInput | ChairmanAssociationWhereUniqueInput[]
    update?: ChairmanAssociationUpdateWithWhereUniqueWithoutProfileInput | ChairmanAssociationUpdateWithWhereUniqueWithoutProfileInput[]
    updateMany?: ChairmanAssociationUpdateManyWithWhereWithoutProfileInput | ChairmanAssociationUpdateManyWithWhereWithoutProfileInput[]
    deleteMany?: ChairmanAssociationScalarWhereInput | ChairmanAssociationScalarWhereInput[]
  }

  export type ChairmanClubsUncheckedUpdateManyWithoutProfileNestedInput = {
    create?: XOR<ChairmanClubsCreateWithoutProfileInput, ChairmanClubsUncheckedCreateWithoutProfileInput> | ChairmanClubsCreateWithoutProfileInput[] | ChairmanClubsUncheckedCreateWithoutProfileInput[]
    connectOrCreate?: ChairmanClubsCreateOrConnectWithoutProfileInput | ChairmanClubsCreateOrConnectWithoutProfileInput[]
    upsert?: ChairmanClubsUpsertWithWhereUniqueWithoutProfileInput | ChairmanClubsUpsertWithWhereUniqueWithoutProfileInput[]
    createMany?: ChairmanClubsCreateManyProfileInputEnvelope
    set?: ChairmanClubsWhereUniqueInput | ChairmanClubsWhereUniqueInput[]
    disconnect?: ChairmanClubsWhereUniqueInput | ChairmanClubsWhereUniqueInput[]
    delete?: ChairmanClubsWhereUniqueInput | ChairmanClubsWhereUniqueInput[]
    connect?: ChairmanClubsWhereUniqueInput | ChairmanClubsWhereUniqueInput[]
    update?: ChairmanClubsUpdateWithWhereUniqueWithoutProfileInput | ChairmanClubsUpdateWithWhereUniqueWithoutProfileInput[]
    updateMany?: ChairmanClubsUpdateManyWithWhereWithoutProfileInput | ChairmanClubsUpdateManyWithWhereWithoutProfileInput[]
    deleteMany?: ChairmanClubsScalarWhereInput | ChairmanClubsScalarWhereInput[]
  }

  export type ChairmanProfileCreateNestedOneWithoutAssociationsInput = {
    create?: XOR<ChairmanProfileCreateWithoutAssociationsInput, ChairmanProfileUncheckedCreateWithoutAssociationsInput>
    connectOrCreate?: ChairmanProfileCreateOrConnectWithoutAssociationsInput
    connect?: ChairmanProfileWhereUniqueInput
  }

  export type ChairmanProfileUpdateOneWithoutAssociationsNestedInput = {
    create?: XOR<ChairmanProfileCreateWithoutAssociationsInput, ChairmanProfileUncheckedCreateWithoutAssociationsInput>
    connectOrCreate?: ChairmanProfileCreateOrConnectWithoutAssociationsInput
    upsert?: ChairmanProfileUpsertWithoutAssociationsInput
    disconnect?: ChairmanProfileWhereInput | boolean
    delete?: ChairmanProfileWhereInput | boolean
    connect?: ChairmanProfileWhereUniqueInput
    update?: XOR<XOR<ChairmanProfileUpdateToOneWithWhereWithoutAssociationsInput, ChairmanProfileUpdateWithoutAssociationsInput>, ChairmanProfileUncheckedUpdateWithoutAssociationsInput>
  }

  export type ChairmanProfileCreateNestedOneWithoutClubsInput = {
    create?: XOR<ChairmanProfileCreateWithoutClubsInput, ChairmanProfileUncheckedCreateWithoutClubsInput>
    connectOrCreate?: ChairmanProfileCreateOrConnectWithoutClubsInput
    connect?: ChairmanProfileWhereUniqueInput
  }

  export type ChairmanProfileUpdateOneWithoutClubsNestedInput = {
    create?: XOR<ChairmanProfileCreateWithoutClubsInput, ChairmanProfileUncheckedCreateWithoutClubsInput>
    connectOrCreate?: ChairmanProfileCreateOrConnectWithoutClubsInput
    upsert?: ChairmanProfileUpsertWithoutClubsInput
    disconnect?: ChairmanProfileWhereInput | boolean
    delete?: ChairmanProfileWhereInput | boolean
    connect?: ChairmanProfileWhereUniqueInput
    update?: XOR<XOR<ChairmanProfileUpdateToOneWithWhereWithoutClubsInput, ChairmanProfileUpdateWithoutClubsInput>, ChairmanProfileUncheckedUpdateWithoutClubsInput>
  }

  export type GalleryPhotoCreateNestedManyWithoutAlbumInput = {
    create?: XOR<GalleryPhotoCreateWithoutAlbumInput, GalleryPhotoUncheckedCreateWithoutAlbumInput> | GalleryPhotoCreateWithoutAlbumInput[] | GalleryPhotoUncheckedCreateWithoutAlbumInput[]
    connectOrCreate?: GalleryPhotoCreateOrConnectWithoutAlbumInput | GalleryPhotoCreateOrConnectWithoutAlbumInput[]
    createMany?: GalleryPhotoCreateManyAlbumInputEnvelope
    connect?: GalleryPhotoWhereUniqueInput | GalleryPhotoWhereUniqueInput[]
  }

  export type GalleryPhotoUncheckedCreateNestedManyWithoutAlbumInput = {
    create?: XOR<GalleryPhotoCreateWithoutAlbumInput, GalleryPhotoUncheckedCreateWithoutAlbumInput> | GalleryPhotoCreateWithoutAlbumInput[] | GalleryPhotoUncheckedCreateWithoutAlbumInput[]
    connectOrCreate?: GalleryPhotoCreateOrConnectWithoutAlbumInput | GalleryPhotoCreateOrConnectWithoutAlbumInput[]
    createMany?: GalleryPhotoCreateManyAlbumInputEnvelope
    connect?: GalleryPhotoWhereUniqueInput | GalleryPhotoWhereUniqueInput[]
  }

  export type GalleryPhotoUpdateManyWithoutAlbumNestedInput = {
    create?: XOR<GalleryPhotoCreateWithoutAlbumInput, GalleryPhotoUncheckedCreateWithoutAlbumInput> | GalleryPhotoCreateWithoutAlbumInput[] | GalleryPhotoUncheckedCreateWithoutAlbumInput[]
    connectOrCreate?: GalleryPhotoCreateOrConnectWithoutAlbumInput | GalleryPhotoCreateOrConnectWithoutAlbumInput[]
    upsert?: GalleryPhotoUpsertWithWhereUniqueWithoutAlbumInput | GalleryPhotoUpsertWithWhereUniqueWithoutAlbumInput[]
    createMany?: GalleryPhotoCreateManyAlbumInputEnvelope
    set?: GalleryPhotoWhereUniqueInput | GalleryPhotoWhereUniqueInput[]
    disconnect?: GalleryPhotoWhereUniqueInput | GalleryPhotoWhereUniqueInput[]
    delete?: GalleryPhotoWhereUniqueInput | GalleryPhotoWhereUniqueInput[]
    connect?: GalleryPhotoWhereUniqueInput | GalleryPhotoWhereUniqueInput[]
    update?: GalleryPhotoUpdateWithWhereUniqueWithoutAlbumInput | GalleryPhotoUpdateWithWhereUniqueWithoutAlbumInput[]
    updateMany?: GalleryPhotoUpdateManyWithWhereWithoutAlbumInput | GalleryPhotoUpdateManyWithWhereWithoutAlbumInput[]
    deleteMany?: GalleryPhotoScalarWhereInput | GalleryPhotoScalarWhereInput[]
  }

  export type GalleryPhotoUncheckedUpdateManyWithoutAlbumNestedInput = {
    create?: XOR<GalleryPhotoCreateWithoutAlbumInput, GalleryPhotoUncheckedCreateWithoutAlbumInput> | GalleryPhotoCreateWithoutAlbumInput[] | GalleryPhotoUncheckedCreateWithoutAlbumInput[]
    connectOrCreate?: GalleryPhotoCreateOrConnectWithoutAlbumInput | GalleryPhotoCreateOrConnectWithoutAlbumInput[]
    upsert?: GalleryPhotoUpsertWithWhereUniqueWithoutAlbumInput | GalleryPhotoUpsertWithWhereUniqueWithoutAlbumInput[]
    createMany?: GalleryPhotoCreateManyAlbumInputEnvelope
    set?: GalleryPhotoWhereUniqueInput | GalleryPhotoWhereUniqueInput[]
    disconnect?: GalleryPhotoWhereUniqueInput | GalleryPhotoWhereUniqueInput[]
    delete?: GalleryPhotoWhereUniqueInput | GalleryPhotoWhereUniqueInput[]
    connect?: GalleryPhotoWhereUniqueInput | GalleryPhotoWhereUniqueInput[]
    update?: GalleryPhotoUpdateWithWhereUniqueWithoutAlbumInput | GalleryPhotoUpdateWithWhereUniqueWithoutAlbumInput[]
    updateMany?: GalleryPhotoUpdateManyWithWhereWithoutAlbumInput | GalleryPhotoUpdateManyWithWhereWithoutAlbumInput[]
    deleteMany?: GalleryPhotoScalarWhereInput | GalleryPhotoScalarWhereInput[]
  }

  export type PhotoAlbumCreateNestedOneWithoutPhotosInput = {
    create?: XOR<PhotoAlbumCreateWithoutPhotosInput, PhotoAlbumUncheckedCreateWithoutPhotosInput>
    connectOrCreate?: PhotoAlbumCreateOrConnectWithoutPhotosInput
    connect?: PhotoAlbumWhereUniqueInput
  }

  export type PhotoAlbumUpdateOneWithoutPhotosNestedInput = {
    create?: XOR<PhotoAlbumCreateWithoutPhotosInput, PhotoAlbumUncheckedCreateWithoutPhotosInput>
    connectOrCreate?: PhotoAlbumCreateOrConnectWithoutPhotosInput
    upsert?: PhotoAlbumUpsertWithoutPhotosInput
    disconnect?: PhotoAlbumWhereInput | boolean
    delete?: PhotoAlbumWhereInput | boolean
    connect?: PhotoAlbumWhereUniqueInput
    update?: XOR<XOR<PhotoAlbumUpdateToOneWithWhereWithoutPhotosInput, PhotoAlbumUpdateWithoutPhotosInput>, PhotoAlbumUncheckedUpdateWithoutPhotosInput>
  }

  export type BoolFieldUpdateOperationsInput = {
    set?: boolean
  }

  export type DateTimeFieldUpdateOperationsInput = {
    set?: Date | string
  }

  export type NestedIntFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[]
    notIn?: number[]
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntFilter<$PrismaModel> | number
  }

  export type NestedStringFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[]
    notIn?: string[]
    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 NestedIntWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[]
    notIn?: number[]
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntWithAggregatesFilter<$PrismaModel> | number
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedFloatFilter<$PrismaModel>
    _sum?: NestedIntFilter<$PrismaModel>
    _min?: NestedIntFilter<$PrismaModel>
    _max?: NestedIntFilter<$PrismaModel>
  }

  export type NestedFloatFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel>
    in?: number[]
    notIn?: number[]
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatFilter<$PrismaModel> | number
  }

  export type NestedStringWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[]
    notIn?: string[]
    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 NestedIntNullableFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | null
    notIn?: number[] | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableFilter<$PrismaModel> | number | null
  }

  export type NestedIntNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | null
    notIn?: number[] | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableWithAggregatesFilter<$PrismaModel> | number | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedFloatNullableFilter<$PrismaModel>
    _sum?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedIntNullableFilter<$PrismaModel>
    _max?: NestedIntNullableFilter<$PrismaModel>
  }

  export type NestedFloatNullableFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel> | null
    in?: number[] | null
    notIn?: number[] | null
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatNullableFilter<$PrismaModel> | number | null
  }

  export type NestedStringNullableFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | null
    notIn?: string[] | 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 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
    lte?: InputJsonValue
    gt?: InputJsonValue
    gte?: InputJsonValue
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
  }

  export type NestedStringNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | null
    notIn?: string[] | 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 NestedBoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  export type NestedBoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$PrismaModel>
  }

  export type NestedDateTimeFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[]
    notIn?: Date[] | string[]
    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 NestedDateTimeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[]
    notIn?: Date[] | string[]
    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 objectivesCreateWithoutMissionsInput = {
    text: string
    bg: string
  }

  export type objectivesUncheckedCreateWithoutMissionsInput = {
    id?: number
    text: string
    bg: string
  }

  export type objectivesCreateOrConnectWithoutMissionsInput = {
    where: objectivesWhereUniqueInput
    create: XOR<objectivesCreateWithoutMissionsInput, objectivesUncheckedCreateWithoutMissionsInput>
  }

  export type objectivesCreateManyMissionsInputEnvelope = {
    data: objectivesCreateManyMissionsInput | objectivesCreateManyMissionsInput[]
    skipDuplicates?: boolean
  }

  export type objectivesUpsertWithWhereUniqueWithoutMissionsInput = {
    where: objectivesWhereUniqueInput
    update: XOR<objectivesUpdateWithoutMissionsInput, objectivesUncheckedUpdateWithoutMissionsInput>
    create: XOR<objectivesCreateWithoutMissionsInput, objectivesUncheckedCreateWithoutMissionsInput>
  }

  export type objectivesUpdateWithWhereUniqueWithoutMissionsInput = {
    where: objectivesWhereUniqueInput
    data: XOR<objectivesUpdateWithoutMissionsInput, objectivesUncheckedUpdateWithoutMissionsInput>
  }

  export type objectivesUpdateManyWithWhereWithoutMissionsInput = {
    where: objectivesScalarWhereInput
    data: XOR<objectivesUpdateManyMutationInput, objectivesUncheckedUpdateManyWithoutMissionsInput>
  }

  export type objectivesScalarWhereInput = {
    AND?: objectivesScalarWhereInput | objectivesScalarWhereInput[]
    OR?: objectivesScalarWhereInput[]
    NOT?: objectivesScalarWhereInput | objectivesScalarWhereInput[]
    id?: IntFilter<"objectives"> | number
    text?: StringFilter<"objectives"> | string
    bg?: StringFilter<"objectives"> | string
    missionsId?: IntNullableFilter<"objectives"> | number | null
  }

  export type missionsCreateWithoutObjectiveListInput = {
    text: string
    pdfName: string
  }

  export type missionsUncheckedCreateWithoutObjectiveListInput = {
    id?: number
    text: string
    pdfName: string
  }

  export type missionsCreateOrConnectWithoutObjectiveListInput = {
    where: missionsWhereUniqueInput
    create: XOR<missionsCreateWithoutObjectiveListInput, missionsUncheckedCreateWithoutObjectiveListInput>
  }

  export type missionsUpsertWithoutObjectiveListInput = {
    update: XOR<missionsUpdateWithoutObjectiveListInput, missionsUncheckedUpdateWithoutObjectiveListInput>
    create: XOR<missionsCreateWithoutObjectiveListInput, missionsUncheckedCreateWithoutObjectiveListInput>
    where?: missionsWhereInput
  }

  export type missionsUpdateToOneWithWhereWithoutObjectiveListInput = {
    where?: missionsWhereInput
    data: XOR<missionsUpdateWithoutObjectiveListInput, missionsUncheckedUpdateWithoutObjectiveListInput>
  }

  export type missionsUpdateWithoutObjectiveListInput = {
    text?: StringFieldUpdateOperationsInput | string
    pdfName?: StringFieldUpdateOperationsInput | string
  }

  export type missionsUncheckedUpdateWithoutObjectiveListInput = {
    id?: IntFieldUpdateOperationsInput | number
    text?: StringFieldUpdateOperationsInput | string
    pdfName?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanAssociationCreateWithoutProfileInput = {
    name: string
    text: string
  }

  export type ChairmanAssociationUncheckedCreateWithoutProfileInput = {
    id?: number
    name: string
    text: string
  }

  export type ChairmanAssociationCreateOrConnectWithoutProfileInput = {
    where: ChairmanAssociationWhereUniqueInput
    create: XOR<ChairmanAssociationCreateWithoutProfileInput, ChairmanAssociationUncheckedCreateWithoutProfileInput>
  }

  export type ChairmanAssociationCreateManyProfileInputEnvelope = {
    data: ChairmanAssociationCreateManyProfileInput | ChairmanAssociationCreateManyProfileInput[]
    skipDuplicates?: boolean
  }

  export type ChairmanClubsCreateWithoutProfileInput = {
    name: string
    text: string
  }

  export type ChairmanClubsUncheckedCreateWithoutProfileInput = {
    id?: number
    name: string
    text: string
  }

  export type ChairmanClubsCreateOrConnectWithoutProfileInput = {
    where: ChairmanClubsWhereUniqueInput
    create: XOR<ChairmanClubsCreateWithoutProfileInput, ChairmanClubsUncheckedCreateWithoutProfileInput>
  }

  export type ChairmanClubsCreateManyProfileInputEnvelope = {
    data: ChairmanClubsCreateManyProfileInput | ChairmanClubsCreateManyProfileInput[]
    skipDuplicates?: boolean
  }

  export type ChairmanAssociationUpsertWithWhereUniqueWithoutProfileInput = {
    where: ChairmanAssociationWhereUniqueInput
    update: XOR<ChairmanAssociationUpdateWithoutProfileInput, ChairmanAssociationUncheckedUpdateWithoutProfileInput>
    create: XOR<ChairmanAssociationCreateWithoutProfileInput, ChairmanAssociationUncheckedCreateWithoutProfileInput>
  }

  export type ChairmanAssociationUpdateWithWhereUniqueWithoutProfileInput = {
    where: ChairmanAssociationWhereUniqueInput
    data: XOR<ChairmanAssociationUpdateWithoutProfileInput, ChairmanAssociationUncheckedUpdateWithoutProfileInput>
  }

  export type ChairmanAssociationUpdateManyWithWhereWithoutProfileInput = {
    where: ChairmanAssociationScalarWhereInput
    data: XOR<ChairmanAssociationUpdateManyMutationInput, ChairmanAssociationUncheckedUpdateManyWithoutProfileInput>
  }

  export type ChairmanAssociationScalarWhereInput = {
    AND?: ChairmanAssociationScalarWhereInput | ChairmanAssociationScalarWhereInput[]
    OR?: ChairmanAssociationScalarWhereInput[]
    NOT?: ChairmanAssociationScalarWhereInput | ChairmanAssociationScalarWhereInput[]
    id?: IntFilter<"ChairmanAssociation"> | number
    name?: StringFilter<"ChairmanAssociation"> | string
    text?: StringFilter<"ChairmanAssociation"> | string
    ChairmanProfileId?: IntNullableFilter<"ChairmanAssociation"> | number | null
  }

  export type ChairmanClubsUpsertWithWhereUniqueWithoutProfileInput = {
    where: ChairmanClubsWhereUniqueInput
    update: XOR<ChairmanClubsUpdateWithoutProfileInput, ChairmanClubsUncheckedUpdateWithoutProfileInput>
    create: XOR<ChairmanClubsCreateWithoutProfileInput, ChairmanClubsUncheckedCreateWithoutProfileInput>
  }

  export type ChairmanClubsUpdateWithWhereUniqueWithoutProfileInput = {
    where: ChairmanClubsWhereUniqueInput
    data: XOR<ChairmanClubsUpdateWithoutProfileInput, ChairmanClubsUncheckedUpdateWithoutProfileInput>
  }

  export type ChairmanClubsUpdateManyWithWhereWithoutProfileInput = {
    where: ChairmanClubsScalarWhereInput
    data: XOR<ChairmanClubsUpdateManyMutationInput, ChairmanClubsUncheckedUpdateManyWithoutProfileInput>
  }

  export type ChairmanClubsScalarWhereInput = {
    AND?: ChairmanClubsScalarWhereInput | ChairmanClubsScalarWhereInput[]
    OR?: ChairmanClubsScalarWhereInput[]
    NOT?: ChairmanClubsScalarWhereInput | ChairmanClubsScalarWhereInput[]
    id?: IntFilter<"ChairmanClubs"> | number
    name?: StringFilter<"ChairmanClubs"> | string
    text?: StringFilter<"ChairmanClubs"> | string
    ChairmanProfileId?: IntNullableFilter<"ChairmanClubs"> | number | null
  }

  export type ChairmanProfileCreateWithoutAssociationsInput = {
    image: string
    name: string
    academic: string
    profession: string
    business?: string | null
    presentPosition: string
    foreignTravel?: string | null
    clubs?: ChairmanClubsCreateNestedManyWithoutProfileInput
  }

  export type ChairmanProfileUncheckedCreateWithoutAssociationsInput = {
    id?: number
    image: string
    name: string
    academic: string
    profession: string
    business?: string | null
    presentPosition: string
    foreignTravel?: string | null
    clubs?: ChairmanClubsUncheckedCreateNestedManyWithoutProfileInput
  }

  export type ChairmanProfileCreateOrConnectWithoutAssociationsInput = {
    where: ChairmanProfileWhereUniqueInput
    create: XOR<ChairmanProfileCreateWithoutAssociationsInput, ChairmanProfileUncheckedCreateWithoutAssociationsInput>
  }

  export type ChairmanProfileUpsertWithoutAssociationsInput = {
    update: XOR<ChairmanProfileUpdateWithoutAssociationsInput, ChairmanProfileUncheckedUpdateWithoutAssociationsInput>
    create: XOR<ChairmanProfileCreateWithoutAssociationsInput, ChairmanProfileUncheckedCreateWithoutAssociationsInput>
    where?: ChairmanProfileWhereInput
  }

  export type ChairmanProfileUpdateToOneWithWhereWithoutAssociationsInput = {
    where?: ChairmanProfileWhereInput
    data: XOR<ChairmanProfileUpdateWithoutAssociationsInput, ChairmanProfileUncheckedUpdateWithoutAssociationsInput>
  }

  export type ChairmanProfileUpdateWithoutAssociationsInput = {
    image?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    academic?: StringFieldUpdateOperationsInput | string
    profession?: StringFieldUpdateOperationsInput | string
    business?: NullableStringFieldUpdateOperationsInput | string | null
    presentPosition?: StringFieldUpdateOperationsInput | string
    foreignTravel?: NullableStringFieldUpdateOperationsInput | string | null
    clubs?: ChairmanClubsUpdateManyWithoutProfileNestedInput
  }

  export type ChairmanProfileUncheckedUpdateWithoutAssociationsInput = {
    id?: IntFieldUpdateOperationsInput | number
    image?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    academic?: StringFieldUpdateOperationsInput | string
    profession?: StringFieldUpdateOperationsInput | string
    business?: NullableStringFieldUpdateOperationsInput | string | null
    presentPosition?: StringFieldUpdateOperationsInput | string
    foreignTravel?: NullableStringFieldUpdateOperationsInput | string | null
    clubs?: ChairmanClubsUncheckedUpdateManyWithoutProfileNestedInput
  }

  export type ChairmanProfileCreateWithoutClubsInput = {
    image: string
    name: string
    academic: string
    profession: string
    business?: string | null
    presentPosition: string
    foreignTravel?: string | null
    associations?: ChairmanAssociationCreateNestedManyWithoutProfileInput
  }

  export type ChairmanProfileUncheckedCreateWithoutClubsInput = {
    id?: number
    image: string
    name: string
    academic: string
    profession: string
    business?: string | null
    presentPosition: string
    foreignTravel?: string | null
    associations?: ChairmanAssociationUncheckedCreateNestedManyWithoutProfileInput
  }

  export type ChairmanProfileCreateOrConnectWithoutClubsInput = {
    where: ChairmanProfileWhereUniqueInput
    create: XOR<ChairmanProfileCreateWithoutClubsInput, ChairmanProfileUncheckedCreateWithoutClubsInput>
  }

  export type ChairmanProfileUpsertWithoutClubsInput = {
    update: XOR<ChairmanProfileUpdateWithoutClubsInput, ChairmanProfileUncheckedUpdateWithoutClubsInput>
    create: XOR<ChairmanProfileCreateWithoutClubsInput, ChairmanProfileUncheckedCreateWithoutClubsInput>
    where?: ChairmanProfileWhereInput
  }

  export type ChairmanProfileUpdateToOneWithWhereWithoutClubsInput = {
    where?: ChairmanProfileWhereInput
    data: XOR<ChairmanProfileUpdateWithoutClubsInput, ChairmanProfileUncheckedUpdateWithoutClubsInput>
  }

  export type ChairmanProfileUpdateWithoutClubsInput = {
    image?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    academic?: StringFieldUpdateOperationsInput | string
    profession?: StringFieldUpdateOperationsInput | string
    business?: NullableStringFieldUpdateOperationsInput | string | null
    presentPosition?: StringFieldUpdateOperationsInput | string
    foreignTravel?: NullableStringFieldUpdateOperationsInput | string | null
    associations?: ChairmanAssociationUpdateManyWithoutProfileNestedInput
  }

  export type ChairmanProfileUncheckedUpdateWithoutClubsInput = {
    id?: IntFieldUpdateOperationsInput | number
    image?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    academic?: StringFieldUpdateOperationsInput | string
    profession?: StringFieldUpdateOperationsInput | string
    business?: NullableStringFieldUpdateOperationsInput | string | null
    presentPosition?: StringFieldUpdateOperationsInput | string
    foreignTravel?: NullableStringFieldUpdateOperationsInput | string | null
    associations?: ChairmanAssociationUncheckedUpdateManyWithoutProfileNestedInput
  }

  export type GalleryPhotoCreateWithoutAlbumInput = {
    image: string
  }

  export type GalleryPhotoUncheckedCreateWithoutAlbumInput = {
    id?: number
    image: string
  }

  export type GalleryPhotoCreateOrConnectWithoutAlbumInput = {
    where: GalleryPhotoWhereUniqueInput
    create: XOR<GalleryPhotoCreateWithoutAlbumInput, GalleryPhotoUncheckedCreateWithoutAlbumInput>
  }

  export type GalleryPhotoCreateManyAlbumInputEnvelope = {
    data: GalleryPhotoCreateManyAlbumInput | GalleryPhotoCreateManyAlbumInput[]
    skipDuplicates?: boolean
  }

  export type GalleryPhotoUpsertWithWhereUniqueWithoutAlbumInput = {
    where: GalleryPhotoWhereUniqueInput
    update: XOR<GalleryPhotoUpdateWithoutAlbumInput, GalleryPhotoUncheckedUpdateWithoutAlbumInput>
    create: XOR<GalleryPhotoCreateWithoutAlbumInput, GalleryPhotoUncheckedCreateWithoutAlbumInput>
  }

  export type GalleryPhotoUpdateWithWhereUniqueWithoutAlbumInput = {
    where: GalleryPhotoWhereUniqueInput
    data: XOR<GalleryPhotoUpdateWithoutAlbumInput, GalleryPhotoUncheckedUpdateWithoutAlbumInput>
  }

  export type GalleryPhotoUpdateManyWithWhereWithoutAlbumInput = {
    where: GalleryPhotoScalarWhereInput
    data: XOR<GalleryPhotoUpdateManyMutationInput, GalleryPhotoUncheckedUpdateManyWithoutAlbumInput>
  }

  export type GalleryPhotoScalarWhereInput = {
    AND?: GalleryPhotoScalarWhereInput | GalleryPhotoScalarWhereInput[]
    OR?: GalleryPhotoScalarWhereInput[]
    NOT?: GalleryPhotoScalarWhereInput | GalleryPhotoScalarWhereInput[]
    id?: IntFilter<"GalleryPhoto"> | number
    image?: StringFilter<"GalleryPhoto"> | string
    PhotoAlbumId?: IntNullableFilter<"GalleryPhoto"> | number | null
  }

  export type PhotoAlbumCreateWithoutPhotosInput = {
    title: string
  }

  export type PhotoAlbumUncheckedCreateWithoutPhotosInput = {
    id?: number
    title: string
  }

  export type PhotoAlbumCreateOrConnectWithoutPhotosInput = {
    where: PhotoAlbumWhereUniqueInput
    create: XOR<PhotoAlbumCreateWithoutPhotosInput, PhotoAlbumUncheckedCreateWithoutPhotosInput>
  }

  export type PhotoAlbumUpsertWithoutPhotosInput = {
    update: XOR<PhotoAlbumUpdateWithoutPhotosInput, PhotoAlbumUncheckedUpdateWithoutPhotosInput>
    create: XOR<PhotoAlbumCreateWithoutPhotosInput, PhotoAlbumUncheckedCreateWithoutPhotosInput>
    where?: PhotoAlbumWhereInput
  }

  export type PhotoAlbumUpdateToOneWithWhereWithoutPhotosInput = {
    where?: PhotoAlbumWhereInput
    data: XOR<PhotoAlbumUpdateWithoutPhotosInput, PhotoAlbumUncheckedUpdateWithoutPhotosInput>
  }

  export type PhotoAlbumUpdateWithoutPhotosInput = {
    title?: StringFieldUpdateOperationsInput | string
  }

  export type PhotoAlbumUncheckedUpdateWithoutPhotosInput = {
    id?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
  }

  export type objectivesCreateManyMissionsInput = {
    id?: number
    text: string
    bg: string
  }

  export type objectivesUpdateWithoutMissionsInput = {
    text?: StringFieldUpdateOperationsInput | string
    bg?: StringFieldUpdateOperationsInput | string
  }

  export type objectivesUncheckedUpdateWithoutMissionsInput = {
    id?: IntFieldUpdateOperationsInput | number
    text?: StringFieldUpdateOperationsInput | string
    bg?: StringFieldUpdateOperationsInput | string
  }

  export type objectivesUncheckedUpdateManyWithoutMissionsInput = {
    id?: IntFieldUpdateOperationsInput | number
    text?: StringFieldUpdateOperationsInput | string
    bg?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanAssociationCreateManyProfileInput = {
    id?: number
    name: string
    text: string
  }

  export type ChairmanClubsCreateManyProfileInput = {
    id?: number
    name: string
    text: string
  }

  export type ChairmanAssociationUpdateWithoutProfileInput = {
    name?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanAssociationUncheckedUpdateWithoutProfileInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanAssociationUncheckedUpdateManyWithoutProfileInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanClubsUpdateWithoutProfileInput = {
    name?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanClubsUncheckedUpdateWithoutProfileInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
  }

  export type ChairmanClubsUncheckedUpdateManyWithoutProfileInput = {
    id?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    text?: StringFieldUpdateOperationsInput | string
  }

  export type GalleryPhotoCreateManyAlbumInput = {
    id?: number
    image: string
  }

  export type GalleryPhotoUpdateWithoutAlbumInput = {
    image?: StringFieldUpdateOperationsInput | string
  }

  export type GalleryPhotoUncheckedUpdateWithoutAlbumInput = {
    id?: IntFieldUpdateOperationsInput | number
    image?: StringFieldUpdateOperationsInput | string
  }

  export type GalleryPhotoUncheckedUpdateManyWithoutAlbumInput = {
    id?: IntFieldUpdateOperationsInput | number
    image?: StringFieldUpdateOperationsInput | string
  }



  /**
   * Aliases for legacy arg types
   */
    /**
     * @deprecated Use MissionsCountOutputTypeDefaultArgs instead
     */
    export type MissionsCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = MissionsCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ChairmanProfileCountOutputTypeDefaultArgs instead
     */
    export type ChairmanProfileCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ChairmanProfileCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use PhotoAlbumCountOutputTypeDefaultArgs instead
     */
    export type PhotoAlbumCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = PhotoAlbumCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use latestNewsDefaultArgs instead
     */
    export type latestNewsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = latestNewsDefaultArgs<ExtArgs>
    /**
     * @deprecated Use sliderImagesDefaultArgs instead
     */
    export type sliderImagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = sliderImagesDefaultArgs<ExtArgs>
    /**
     * @deprecated Use missionsDefaultArgs instead
     */
    export type missionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = missionsDefaultArgs<ExtArgs>
    /**
     * @deprecated Use objectivesDefaultArgs instead
     */
    export type objectivesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = objectivesDefaultArgs<ExtArgs>
    /**
     * @deprecated Use homeDataDefaultArgs instead
     */
    export type homeDataArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = homeDataDefaultArgs<ExtArgs>
    /**
     * @deprecated Use briefDataDefaultArgs instead
     */
    export type briefDataArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = briefDataDefaultArgs<ExtArgs>
    /**
     * @deprecated Use serviceDataDefaultArgs instead
     */
    export type serviceDataArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = serviceDataDefaultArgs<ExtArgs>
    /**
     * @deprecated Use activitiesDataDefaultArgs instead
     */
    export type activitiesDataArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = activitiesDataDefaultArgs<ExtArgs>
    /**
     * @deprecated Use formerChairmanDefaultArgs instead
     */
    export type formerChairmanArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = formerChairmanDefaultArgs<ExtArgs>
    /**
     * @deprecated Use formerSrViceChairmanDefaultArgs instead
     */
    export type formerSrViceChairmanArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = formerSrViceChairmanDefaultArgs<ExtArgs>
    /**
     * @deprecated Use formerViceChairmanDefaultArgs instead
     */
    export type formerViceChairmanArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = formerViceChairmanDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ChairmanProfileDefaultArgs instead
     */
    export type ChairmanProfileArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ChairmanProfileDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ChairmanAssociationDefaultArgs instead
     */
    export type ChairmanAssociationArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ChairmanAssociationDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ChairmanClubsDefaultArgs instead
     */
    export type ChairmanClubsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ChairmanClubsDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ChairmanMessageDefaultArgs instead
     */
    export type ChairmanMessageArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ChairmanMessageDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ChairmanSpeechDefaultArgs instead
     */
    export type ChairmanSpeechArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ChairmanSpeechDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ChairmanInterviewPrintDefaultArgs instead
     */
    export type ChairmanInterviewPrintArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ChairmanInterviewPrintDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ChairmanInterviewElectronicDefaultArgs instead
     */
    export type ChairmanInterviewElectronicArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ChairmanInterviewElectronicDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ChairmanPresentationDefaultArgs instead
     */
    export type ChairmanPresentationArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ChairmanPresentationDefaultArgs<ExtArgs>
    /**
     * @deprecated Use memorandumDefaultArgs instead
     */
    export type memorandumArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = memorandumDefaultArgs<ExtArgs>
    /**
     * @deprecated Use BoardOfDirectorsDefaultArgs instead
     */
    export type BoardOfDirectorsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = BoardOfDirectorsDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ShippersNewsDefaultArgs instead
     */
    export type ShippersNewsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ShippersNewsDefaultArgs<ExtArgs>
    /**
     * @deprecated Use AnnualReportDefaultArgs instead
     */
    export type AnnualReportArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = AnnualReportDefaultArgs<ExtArgs>
    /**
     * @deprecated Use OtherPublicationsDefaultArgs instead
     */
    export type OtherPublicationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = OtherPublicationsDefaultArgs<ExtArgs>
    /**
     * @deprecated Use SCBRecommendationsDefaultArgs instead
     */
    export type SCBRecommendationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = SCBRecommendationsDefaultArgs<ExtArgs>
    /**
     * @deprecated Use SCBSeminarDefaultArgs instead
     */
    export type SCBSeminarArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = SCBSeminarDefaultArgs<ExtArgs>
    /**
     * @deprecated Use EligibilityDefaultArgs instead
     */
    export type EligibilityArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = EligibilityDefaultArgs<ExtArgs>
    /**
     * @deprecated Use RelevantPapersDefaultArgs instead
     */
    export type RelevantPapersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = RelevantPapersDefaultArgs<ExtArgs>
    /**
     * @deprecated Use MembersListDefaultArgs instead
     */
    export type MembersListArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = MembersListDefaultArgs<ExtArgs>
    /**
     * @deprecated Use UsefulLinksDefaultArgs instead
     */
    export type UsefulLinksArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UsefulLinksDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ContactUsDefaultArgs instead
     */
    export type ContactUsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ContactUsDefaultArgs<ExtArgs>
    /**
     * @deprecated Use SecretariatDefaultArgs instead
     */
    export type SecretariatArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = SecretariatDefaultArgs<ExtArgs>
    /**
     * @deprecated Use PDFsDefaultArgs instead
     */
    export type PDFsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = PDFsDefaultArgs<ExtArgs>
    /**
     * @deprecated Use FormsDefaultArgs instead
     */
    export type FormsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = FormsDefaultArgs<ExtArgs>
    /**
     * @deprecated Use MembershipTextDefaultArgs instead
     */
    export type MembershipTextArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = MembershipTextDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ApplicationProcedureDefaultArgs instead
     */
    export type ApplicationProcedureArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ApplicationProcedureDefaultArgs<ExtArgs>
    /**
     * @deprecated Use BenefitsDefaultArgs instead
     */
    export type BenefitsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = BenefitsDefaultArgs<ExtArgs>
    /**
     * @deprecated Use PhotoAlbumDefaultArgs instead
     */
    export type PhotoAlbumArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = PhotoAlbumDefaultArgs<ExtArgs>
    /**
     * @deprecated Use GalleryPhotoDefaultArgs instead
     */
    export type GalleryPhotoArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = GalleryPhotoDefaultArgs<ExtArgs>
    /**
     * @deprecated Use GalleryVideoDefaultArgs instead
     */
    export type GalleryVideoArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = GalleryVideoDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CondolenceDefaultArgs instead
     */
    export type CondolenceArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CondolenceDefaultArgs<ExtArgs>
    /**
     * @deprecated Use AffiliatesDefaultArgs instead
     */
    export type AffiliatesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = AffiliatesDefaultArgs<ExtArgs>
    /**
     * @deprecated Use SubscribersDefaultArgs instead
     */
    export type SubscribersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = SubscribersDefaultArgs<ExtArgs>
    /**
     * @deprecated Use MessagesDefaultArgs instead
     */
    export type MessagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = MessagesDefaultArgs<ExtArgs>

  /**
   * Batch Payload for updateMany & deleteMany & createMany
   */

  export type BatchPayload = {
    count: number
  }

  /**
   * DMMF
   */
  export const dmmf: runtime.BaseDMMF
}