
/**
 * Client
**/

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

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


/**
 * Model User
 * 
 */
export type User = $Result.DefaultSelection<Prisma.$UserPayload>
/**
 * Model MitraRequest
 * 
 */
export type MitraRequest = $Result.DefaultSelection<Prisma.$MitraRequestPayload>
/**
 * Model UserPackage
 * 
 */
export type UserPackage = $Result.DefaultSelection<Prisma.$UserPackagePayload>
/**
 * Model PackageType
 * 
 */
export type PackageType = $Result.DefaultSelection<Prisma.$PackageTypePayload>
/**
 * Model UserPackageOption
 * 
 */
export type UserPackageOption = $Result.DefaultSelection<Prisma.$UserPackageOptionPayload>
/**
 * Model UserPackageOrder
 * 
 */
export type UserPackageOrder = $Result.DefaultSelection<Prisma.$UserPackageOrderPayload>
/**
 * Model Category
 * 
 */
export type Category = $Result.DefaultSelection<Prisma.$CategoryPayload>
/**
 * Model Product
 * 
 */
export type Product = $Result.DefaultSelection<Prisma.$ProductPayload>
/**
 * Model ProductThumbnail
 * 
 */
export type ProductThumbnail = $Result.DefaultSelection<Prisma.$ProductThumbnailPayload>
/**
 * Model ProductCategory
 * 
 */
export type ProductCategory = $Result.DefaultSelection<Prisma.$ProductCategoryPayload>
/**
 * Model ProductVariation
 * 
 */
export type ProductVariation = $Result.DefaultSelection<Prisma.$ProductVariationPayload>
/**
 * Model ProductInclude
 * 
 */
export type ProductInclude = $Result.DefaultSelection<Prisma.$ProductIncludePayload>
/**
 * Model ProductExclude
 * 
 */
export type ProductExclude = $Result.DefaultSelection<Prisma.$ProductExcludePayload>
/**
 * Model ProductOrder
 * 
 */
export type ProductOrder = $Result.DefaultSelection<Prisma.$ProductOrderPayload>
/**
 * Model Vendor
 * 
 */
export type Vendor = $Result.DefaultSelection<Prisma.$VendorPayload>
/**
 * Model Hotel
 * 
 */
export type Hotel = $Result.DefaultSelection<Prisma.$HotelPayload>
/**
 * Model Period
 * 
 */
export type Period = $Result.DefaultSelection<Prisma.$PeriodPayload>
/**
 * Model HotelPeriodPrice
 * 
 */
export type HotelPeriodPrice = $Result.DefaultSelection<Prisma.$HotelPeriodPricePayload>
/**
 * Model Airline
 * 
 */
export type Airline = $Result.DefaultSelection<Prisma.$AirlinePayload>
/**
 * Model Visa
 * 
 */
export type Visa = $Result.DefaultSelection<Prisma.$VisaPayload>
/**
 * Model Transportation
 * 
 */
export type Transportation = $Result.DefaultSelection<Prisma.$TransportationPayload>
/**
 * Model Muthawif
 * 
 */
export type Muthawif = $Result.DefaultSelection<Prisma.$MuthawifPayload>
/**
 * Model HandlingSaudi
 * 
 */
export type HandlingSaudi = $Result.DefaultSelection<Prisma.$HandlingSaudiPayload>
/**
 * Model HandlingDomestic
 * 
 */
export type HandlingDomestic = $Result.DefaultSelection<Prisma.$HandlingDomesticPayload>
/**
 * Model Siskopatuh
 * 
 */
export type Siskopatuh = $Result.DefaultSelection<Prisma.$SiskopatuhPayload>
/**
 * Model Equipment
 * 
 */
export type Equipment = $Result.DefaultSelection<Prisma.$EquipmentPayload>
/**
 * Model TourPlus
 * 
 */
export type TourPlus = $Result.DefaultSelection<Prisma.$TourPlusPayload>
/**
 * Model Manasik
 * 
 */
export type Manasik = $Result.DefaultSelection<Prisma.$ManasikPayload>
/**
 * Model MitraPackage
 * 
 */
export type MitraPackage = $Result.DefaultSelection<Prisma.$MitraPackagePayload>
/**
 * Model MitraPackageOrder
 * 
 */
export type MitraPackageOrder = $Result.DefaultSelection<Prisma.$MitraPackageOrderPayload>
/**
 * Model ExchangeRate
 * 
 */
export type ExchangeRate = $Result.DefaultSelection<Prisma.$ExchangeRatePayload>
/**
 * Model Contact
 * 
 */
export type Contact = $Result.DefaultSelection<Prisma.$ContactPayload>
/**
 * Model Faq
 * 
 */
export type Faq = $Result.DefaultSelection<Prisma.$FaqPayload>
/**
 * Model Content
 * 
 */
export type Content = $Result.DefaultSelection<Prisma.$ContentPayload>
/**
 * Model MenuItem
 * 
 */
export type MenuItem = $Result.DefaultSelection<Prisma.$MenuItemPayload>
/**
 * Model Footer
 * 
 */
export type Footer = $Result.DefaultSelection<Prisma.$FooterPayload>
/**
 * Model FooterItem
 * 
 */
export type FooterItem = $Result.DefaultSelection<Prisma.$FooterItemPayload>
/**
 * Model Color
 * 
 */
export type Color = $Result.DefaultSelection<Prisma.$ColorPayload>

/**
 * Enums
 */
export namespace $Enums {
  export const Role: {
  ADMIN: 'ADMIN',
  MITRA: 'MITRA',
  USER: 'USER'
};

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


export const RequestStatus: {
  PENDING: 'PENDING',
  APPROVED: 'APPROVED',
  REJECTED: 'REJECTED'
};

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


export const City: {
  MEKKAH: 'MEKKAH',
  MADINAH: 'MADINAH'
};

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


export const PeriodCategory: {
  LOW: 'LOW',
  MID: 'MID',
  HIGH: 'HIGH',
  RAMADHAN: 'RAMADHAN',
  ITIKAF: 'ITIKAF'
};

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


export const ContentType: {
  TEXT: 'TEXT',
  IMAGE: 'IMAGE',
  BUTTON: 'BUTTON',
  BENEFIT_CARD: 'BENEFIT_CARD'
};

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


export const FooterType: {
  MENU: 'MENU',
  LINK: 'LINK',
  SOCIAL_MEDIA: 'SOCIAL_MEDIA'
};

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

}

export type Role = $Enums.Role

export const Role: typeof $Enums.Role

export type RequestStatus = $Enums.RequestStatus

export const RequestStatus: typeof $Enums.RequestStatus

export type City = $Enums.City

export const City: typeof $Enums.City

export type PeriodCategory = $Enums.PeriodCategory

export const PeriodCategory: typeof $Enums.PeriodCategory

export type ContentType = $Enums.ContentType

export const ContentType: typeof $Enums.ContentType

export type FooterType = $Enums.FooterType

export const FooterType: typeof $Enums.FooterType

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

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

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

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

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

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

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

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

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

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


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

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


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

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

  /**
   * `prisma.mitraRequest`: Exposes CRUD operations for the **MitraRequest** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more MitraRequests
    * const mitraRequests = await prisma.mitraRequest.findMany()
    * ```
    */
  get mitraRequest(): Prisma.MitraRequestDelegate<ExtArgs>;

  /**
   * `prisma.userPackage`: Exposes CRUD operations for the **UserPackage** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more UserPackages
    * const userPackages = await prisma.userPackage.findMany()
    * ```
    */
  get userPackage(): Prisma.UserPackageDelegate<ExtArgs>;

  /**
   * `prisma.packageType`: Exposes CRUD operations for the **PackageType** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more PackageTypes
    * const packageTypes = await prisma.packageType.findMany()
    * ```
    */
  get packageType(): Prisma.PackageTypeDelegate<ExtArgs>;

  /**
   * `prisma.userPackageOption`: Exposes CRUD operations for the **UserPackageOption** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more UserPackageOptions
    * const userPackageOptions = await prisma.userPackageOption.findMany()
    * ```
    */
  get userPackageOption(): Prisma.UserPackageOptionDelegate<ExtArgs>;

  /**
   * `prisma.userPackageOrder`: Exposes CRUD operations for the **UserPackageOrder** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more UserPackageOrders
    * const userPackageOrders = await prisma.userPackageOrder.findMany()
    * ```
    */
  get userPackageOrder(): Prisma.UserPackageOrderDelegate<ExtArgs>;

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

  /**
   * `prisma.product`: Exposes CRUD operations for the **Product** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Products
    * const products = await prisma.product.findMany()
    * ```
    */
  get product(): Prisma.ProductDelegate<ExtArgs>;

  /**
   * `prisma.productThumbnail`: Exposes CRUD operations for the **ProductThumbnail** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ProductThumbnails
    * const productThumbnails = await prisma.productThumbnail.findMany()
    * ```
    */
  get productThumbnail(): Prisma.ProductThumbnailDelegate<ExtArgs>;

  /**
   * `prisma.productCategory`: Exposes CRUD operations for the **ProductCategory** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ProductCategories
    * const productCategories = await prisma.productCategory.findMany()
    * ```
    */
  get productCategory(): Prisma.ProductCategoryDelegate<ExtArgs>;

  /**
   * `prisma.productVariation`: Exposes CRUD operations for the **ProductVariation** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ProductVariations
    * const productVariations = await prisma.productVariation.findMany()
    * ```
    */
  get productVariation(): Prisma.ProductVariationDelegate<ExtArgs>;

  /**
   * `prisma.productInclude`: Exposes CRUD operations for the **ProductInclude** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ProductIncludes
    * const productIncludes = await prisma.productInclude.findMany()
    * ```
    */
  get productInclude(): Prisma.ProductIncludeDelegate<ExtArgs>;

  /**
   * `prisma.productExclude`: Exposes CRUD operations for the **ProductExclude** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ProductExcludes
    * const productExcludes = await prisma.productExclude.findMany()
    * ```
    */
  get productExclude(): Prisma.ProductExcludeDelegate<ExtArgs>;

  /**
   * `prisma.productOrder`: Exposes CRUD operations for the **ProductOrder** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ProductOrders
    * const productOrders = await prisma.productOrder.findMany()
    * ```
    */
  get productOrder(): Prisma.ProductOrderDelegate<ExtArgs>;

  /**
   * `prisma.vendor`: Exposes CRUD operations for the **Vendor** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Vendors
    * const vendors = await prisma.vendor.findMany()
    * ```
    */
  get vendor(): Prisma.VendorDelegate<ExtArgs>;

  /**
   * `prisma.hotel`: Exposes CRUD operations for the **Hotel** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Hotels
    * const hotels = await prisma.hotel.findMany()
    * ```
    */
  get hotel(): Prisma.HotelDelegate<ExtArgs>;

  /**
   * `prisma.period`: Exposes CRUD operations for the **Period** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Periods
    * const periods = await prisma.period.findMany()
    * ```
    */
  get period(): Prisma.PeriodDelegate<ExtArgs>;

  /**
   * `prisma.hotelPeriodPrice`: Exposes CRUD operations for the **HotelPeriodPrice** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more HotelPeriodPrices
    * const hotelPeriodPrices = await prisma.hotelPeriodPrice.findMany()
    * ```
    */
  get hotelPeriodPrice(): Prisma.HotelPeriodPriceDelegate<ExtArgs>;

  /**
   * `prisma.airline`: Exposes CRUD operations for the **Airline** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Airlines
    * const airlines = await prisma.airline.findMany()
    * ```
    */
  get airline(): Prisma.AirlineDelegate<ExtArgs>;

  /**
   * `prisma.visa`: Exposes CRUD operations for the **Visa** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Visas
    * const visas = await prisma.visa.findMany()
    * ```
    */
  get visa(): Prisma.VisaDelegate<ExtArgs>;

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

  /**
   * `prisma.muthawif`: Exposes CRUD operations for the **Muthawif** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Muthawifs
    * const muthawifs = await prisma.muthawif.findMany()
    * ```
    */
  get muthawif(): Prisma.MuthawifDelegate<ExtArgs>;

  /**
   * `prisma.handlingSaudi`: Exposes CRUD operations for the **HandlingSaudi** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more HandlingSaudis
    * const handlingSaudis = await prisma.handlingSaudi.findMany()
    * ```
    */
  get handlingSaudi(): Prisma.HandlingSaudiDelegate<ExtArgs>;

  /**
   * `prisma.handlingDomestic`: Exposes CRUD operations for the **HandlingDomestic** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more HandlingDomestics
    * const handlingDomestics = await prisma.handlingDomestic.findMany()
    * ```
    */
  get handlingDomestic(): Prisma.HandlingDomesticDelegate<ExtArgs>;

  /**
   * `prisma.siskopatuh`: Exposes CRUD operations for the **Siskopatuh** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Siskopatuhs
    * const siskopatuhs = await prisma.siskopatuh.findMany()
    * ```
    */
  get siskopatuh(): Prisma.SiskopatuhDelegate<ExtArgs>;

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

  /**
   * `prisma.tourPlus`: Exposes CRUD operations for the **TourPlus** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more TourPluses
    * const tourPluses = await prisma.tourPlus.findMany()
    * ```
    */
  get tourPlus(): Prisma.TourPlusDelegate<ExtArgs>;

  /**
   * `prisma.manasik`: Exposes CRUD operations for the **Manasik** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Manasiks
    * const manasiks = await prisma.manasik.findMany()
    * ```
    */
  get manasik(): Prisma.ManasikDelegate<ExtArgs>;

  /**
   * `prisma.mitraPackage`: Exposes CRUD operations for the **MitraPackage** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more MitraPackages
    * const mitraPackages = await prisma.mitraPackage.findMany()
    * ```
    */
  get mitraPackage(): Prisma.MitraPackageDelegate<ExtArgs>;

  /**
   * `prisma.mitraPackageOrder`: Exposes CRUD operations for the **MitraPackageOrder** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more MitraPackageOrders
    * const mitraPackageOrders = await prisma.mitraPackageOrder.findMany()
    * ```
    */
  get mitraPackageOrder(): Prisma.MitraPackageOrderDelegate<ExtArgs>;

  /**
   * `prisma.exchangeRate`: Exposes CRUD operations for the **ExchangeRate** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ExchangeRates
    * const exchangeRates = await prisma.exchangeRate.findMany()
    * ```
    */
  get exchangeRate(): Prisma.ExchangeRateDelegate<ExtArgs>;

  /**
   * `prisma.contact`: Exposes CRUD operations for the **Contact** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Contacts
    * const contacts = await prisma.contact.findMany()
    * ```
    */
  get contact(): Prisma.ContactDelegate<ExtArgs>;

  /**
   * `prisma.faq`: Exposes CRUD operations for the **Faq** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Faqs
    * const faqs = await prisma.faq.findMany()
    * ```
    */
  get faq(): Prisma.FaqDelegate<ExtArgs>;

  /**
   * `prisma.content`: Exposes CRUD operations for the **Content** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Contents
    * const contents = await prisma.content.findMany()
    * ```
    */
  get content(): Prisma.ContentDelegate<ExtArgs>;

  /**
   * `prisma.menuItem`: Exposes CRUD operations for the **MenuItem** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more MenuItems
    * const menuItems = await prisma.menuItem.findMany()
    * ```
    */
  get menuItem(): Prisma.MenuItemDelegate<ExtArgs>;

  /**
   * `prisma.footer`: Exposes CRUD operations for the **Footer** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Footers
    * const footers = await prisma.footer.findMany()
    * ```
    */
  get footer(): Prisma.FooterDelegate<ExtArgs>;

  /**
   * `prisma.footerItem`: Exposes CRUD operations for the **FooterItem** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more FooterItems
    * const footerItems = await prisma.footerItem.findMany()
    * ```
    */
  get footerItem(): Prisma.FooterItemDelegate<ExtArgs>;

  /**
   * `prisma.color`: Exposes CRUD operations for the **Color** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Colors
    * const colors = await prisma.color.findMany()
    * ```
    */
  get color(): Prisma.ColorDelegate<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.21.1
   * Query Engine version: bf0e5e8a04cada8225617067eaa03d041e2bba36
   */
  export type PrismaVersion = {
    client: string
  }

  export const prismaVersion: PrismaVersion 

  /**
   * Utility Types
   */


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

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

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

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

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

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

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

  type SelectAndInclude = {
    select: any
    include: any
  }

  type SelectAndOmit = {
    select: any
    omit: any
  }

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

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

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


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

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

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

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

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

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

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

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

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


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


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

  /**
   * From ts-toolbelt
   */

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

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

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

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

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

  export type Union = any

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /**
  0
  */
  export type False = 0

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

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

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

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

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

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

  export const type: unique symbol;



  /**
   * Used by group by
   */

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

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

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

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

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

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


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

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


  export const ModelName: {
    User: 'User',
    MitraRequest: 'MitraRequest',
    UserPackage: 'UserPackage',
    PackageType: 'PackageType',
    UserPackageOption: 'UserPackageOption',
    UserPackageOrder: 'UserPackageOrder',
    Category: 'Category',
    Product: 'Product',
    ProductThumbnail: 'ProductThumbnail',
    ProductCategory: 'ProductCategory',
    ProductVariation: 'ProductVariation',
    ProductInclude: 'ProductInclude',
    ProductExclude: 'ProductExclude',
    ProductOrder: 'ProductOrder',
    Vendor: 'Vendor',
    Hotel: 'Hotel',
    Period: 'Period',
    HotelPeriodPrice: 'HotelPeriodPrice',
    Airline: 'Airline',
    Visa: 'Visa',
    Transportation: 'Transportation',
    Muthawif: 'Muthawif',
    HandlingSaudi: 'HandlingSaudi',
    HandlingDomestic: 'HandlingDomestic',
    Siskopatuh: 'Siskopatuh',
    Equipment: 'Equipment',
    TourPlus: 'TourPlus',
    Manasik: 'Manasik',
    MitraPackage: 'MitraPackage',
    MitraPackageOrder: 'MitraPackageOrder',
    ExchangeRate: 'ExchangeRate',
    Contact: 'Contact',
    Faq: 'Faq',
    Content: 'Content',
    MenuItem: 'MenuItem',
    Footer: 'Footer',
    FooterItem: 'FooterItem',
    Color: 'Color'
  };

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


  export type Datasources = {
    db?: Datasource
  }

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

  export type TypeMap<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, ClientOptions = {}> = {
    meta: {
      modelProps: "user" | "mitraRequest" | "userPackage" | "packageType" | "userPackageOption" | "userPackageOrder" | "category" | "product" | "productThumbnail" | "productCategory" | "productVariation" | "productInclude" | "productExclude" | "productOrder" | "vendor" | "hotel" | "period" | "hotelPeriodPrice" | "airline" | "visa" | "transportation" | "muthawif" | "handlingSaudi" | "handlingDomestic" | "siskopatuh" | "equipment" | "tourPlus" | "manasik" | "mitraPackage" | "mitraPackageOrder" | "exchangeRate" | "contact" | "faq" | "content" | "menuItem" | "footer" | "footerItem" | "color"
      txIsolationLevel: Prisma.TransactionIsolationLevel
    }
    model: {
      User: {
        payload: Prisma.$UserPayload<ExtArgs>
        fields: Prisma.UserFieldRefs
        operations: {
          findUnique: {
            args: Prisma.UserFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.UserFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          findFirst: {
            args: Prisma.UserFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.UserFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          findMany: {
            args: Prisma.UserFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>[]
          }
          create: {
            args: Prisma.UserCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          createMany: {
            args: Prisma.UserCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.UserDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          update: {
            args: Prisma.UserUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          deleteMany: {
            args: Prisma.UserDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.UserUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.UserUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPayload>
          }
          aggregate: {
            args: Prisma.UserAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateUser>
          }
          groupBy: {
            args: Prisma.UserGroupByArgs<ExtArgs>
            result: $Utils.Optional<UserGroupByOutputType>[]
          }
          count: {
            args: Prisma.UserCountArgs<ExtArgs>
            result: $Utils.Optional<UserCountAggregateOutputType> | number
          }
        }
      }
      MitraRequest: {
        payload: Prisma.$MitraRequestPayload<ExtArgs>
        fields: Prisma.MitraRequestFieldRefs
        operations: {
          findUnique: {
            args: Prisma.MitraRequestFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MitraRequestPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.MitraRequestFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MitraRequestPayload>
          }
          findFirst: {
            args: Prisma.MitraRequestFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MitraRequestPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.MitraRequestFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MitraRequestPayload>
          }
          findMany: {
            args: Prisma.MitraRequestFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MitraRequestPayload>[]
          }
          create: {
            args: Prisma.MitraRequestCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MitraRequestPayload>
          }
          createMany: {
            args: Prisma.MitraRequestCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.MitraRequestDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MitraRequestPayload>
          }
          update: {
            args: Prisma.MitraRequestUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MitraRequestPayload>
          }
          deleteMany: {
            args: Prisma.MitraRequestDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.MitraRequestUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.MitraRequestUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MitraRequestPayload>
          }
          aggregate: {
            args: Prisma.MitraRequestAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateMitraRequest>
          }
          groupBy: {
            args: Prisma.MitraRequestGroupByArgs<ExtArgs>
            result: $Utils.Optional<MitraRequestGroupByOutputType>[]
          }
          count: {
            args: Prisma.MitraRequestCountArgs<ExtArgs>
            result: $Utils.Optional<MitraRequestCountAggregateOutputType> | number
          }
        }
      }
      UserPackage: {
        payload: Prisma.$UserPackagePayload<ExtArgs>
        fields: Prisma.UserPackageFieldRefs
        operations: {
          findUnique: {
            args: Prisma.UserPackageFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPackagePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.UserPackageFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPackagePayload>
          }
          findFirst: {
            args: Prisma.UserPackageFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPackagePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.UserPackageFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPackagePayload>
          }
          findMany: {
            args: Prisma.UserPackageFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPackagePayload>[]
          }
          create: {
            args: Prisma.UserPackageCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPackagePayload>
          }
          createMany: {
            args: Prisma.UserPackageCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.UserPackageDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPackagePayload>
          }
          update: {
            args: Prisma.UserPackageUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPackagePayload>
          }
          deleteMany: {
            args: Prisma.UserPackageDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.UserPackageUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.UserPackageUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPackagePayload>
          }
          aggregate: {
            args: Prisma.UserPackageAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateUserPackage>
          }
          groupBy: {
            args: Prisma.UserPackageGroupByArgs<ExtArgs>
            result: $Utils.Optional<UserPackageGroupByOutputType>[]
          }
          count: {
            args: Prisma.UserPackageCountArgs<ExtArgs>
            result: $Utils.Optional<UserPackageCountAggregateOutputType> | number
          }
        }
      }
      PackageType: {
        payload: Prisma.$PackageTypePayload<ExtArgs>
        fields: Prisma.PackageTypeFieldRefs
        operations: {
          findUnique: {
            args: Prisma.PackageTypeFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PackageTypePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.PackageTypeFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PackageTypePayload>
          }
          findFirst: {
            args: Prisma.PackageTypeFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PackageTypePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.PackageTypeFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PackageTypePayload>
          }
          findMany: {
            args: Prisma.PackageTypeFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PackageTypePayload>[]
          }
          create: {
            args: Prisma.PackageTypeCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PackageTypePayload>
          }
          createMany: {
            args: Prisma.PackageTypeCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.PackageTypeDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PackageTypePayload>
          }
          update: {
            args: Prisma.PackageTypeUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PackageTypePayload>
          }
          deleteMany: {
            args: Prisma.PackageTypeDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.PackageTypeUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.PackageTypeUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PackageTypePayload>
          }
          aggregate: {
            args: Prisma.PackageTypeAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregatePackageType>
          }
          groupBy: {
            args: Prisma.PackageTypeGroupByArgs<ExtArgs>
            result: $Utils.Optional<PackageTypeGroupByOutputType>[]
          }
          count: {
            args: Prisma.PackageTypeCountArgs<ExtArgs>
            result: $Utils.Optional<PackageTypeCountAggregateOutputType> | number
          }
        }
      }
      UserPackageOption: {
        payload: Prisma.$UserPackageOptionPayload<ExtArgs>
        fields: Prisma.UserPackageOptionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.UserPackageOptionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPackageOptionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.UserPackageOptionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPackageOptionPayload>
          }
          findFirst: {
            args: Prisma.UserPackageOptionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPackageOptionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.UserPackageOptionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPackageOptionPayload>
          }
          findMany: {
            args: Prisma.UserPackageOptionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPackageOptionPayload>[]
          }
          create: {
            args: Prisma.UserPackageOptionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPackageOptionPayload>
          }
          createMany: {
            args: Prisma.UserPackageOptionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.UserPackageOptionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPackageOptionPayload>
          }
          update: {
            args: Prisma.UserPackageOptionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPackageOptionPayload>
          }
          deleteMany: {
            args: Prisma.UserPackageOptionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.UserPackageOptionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.UserPackageOptionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPackageOptionPayload>
          }
          aggregate: {
            args: Prisma.UserPackageOptionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateUserPackageOption>
          }
          groupBy: {
            args: Prisma.UserPackageOptionGroupByArgs<ExtArgs>
            result: $Utils.Optional<UserPackageOptionGroupByOutputType>[]
          }
          count: {
            args: Prisma.UserPackageOptionCountArgs<ExtArgs>
            result: $Utils.Optional<UserPackageOptionCountAggregateOutputType> | number
          }
        }
      }
      UserPackageOrder: {
        payload: Prisma.$UserPackageOrderPayload<ExtArgs>
        fields: Prisma.UserPackageOrderFieldRefs
        operations: {
          findUnique: {
            args: Prisma.UserPackageOrderFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPackageOrderPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.UserPackageOrderFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPackageOrderPayload>
          }
          findFirst: {
            args: Prisma.UserPackageOrderFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPackageOrderPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.UserPackageOrderFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPackageOrderPayload>
          }
          findMany: {
            args: Prisma.UserPackageOrderFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPackageOrderPayload>[]
          }
          create: {
            args: Prisma.UserPackageOrderCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPackageOrderPayload>
          }
          createMany: {
            args: Prisma.UserPackageOrderCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.UserPackageOrderDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPackageOrderPayload>
          }
          update: {
            args: Prisma.UserPackageOrderUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPackageOrderPayload>
          }
          deleteMany: {
            args: Prisma.UserPackageOrderDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.UserPackageOrderUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.UserPackageOrderUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserPackageOrderPayload>
          }
          aggregate: {
            args: Prisma.UserPackageOrderAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateUserPackageOrder>
          }
          groupBy: {
            args: Prisma.UserPackageOrderGroupByArgs<ExtArgs>
            result: $Utils.Optional<UserPackageOrderGroupByOutputType>[]
          }
          count: {
            args: Prisma.UserPackageOrderCountArgs<ExtArgs>
            result: $Utils.Optional<UserPackageOrderCountAggregateOutputType> | number
          }
        }
      }
      Category: {
        payload: Prisma.$CategoryPayload<ExtArgs>
        fields: Prisma.CategoryFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CategoryFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CategoryPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CategoryFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CategoryPayload>
          }
          findFirst: {
            args: Prisma.CategoryFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CategoryPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CategoryFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CategoryPayload>
          }
          findMany: {
            args: Prisma.CategoryFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CategoryPayload>[]
          }
          create: {
            args: Prisma.CategoryCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CategoryPayload>
          }
          createMany: {
            args: Prisma.CategoryCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.CategoryDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CategoryPayload>
          }
          update: {
            args: Prisma.CategoryUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CategoryPayload>
          }
          deleteMany: {
            args: Prisma.CategoryDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.CategoryUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.CategoryUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CategoryPayload>
          }
          aggregate: {
            args: Prisma.CategoryAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCategory>
          }
          groupBy: {
            args: Prisma.CategoryGroupByArgs<ExtArgs>
            result: $Utils.Optional<CategoryGroupByOutputType>[]
          }
          count: {
            args: Prisma.CategoryCountArgs<ExtArgs>
            result: $Utils.Optional<CategoryCountAggregateOutputType> | number
          }
        }
      }
      Product: {
        payload: Prisma.$ProductPayload<ExtArgs>
        fields: Prisma.ProductFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ProductFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ProductFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductPayload>
          }
          findFirst: {
            args: Prisma.ProductFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ProductFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductPayload>
          }
          findMany: {
            args: Prisma.ProductFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductPayload>[]
          }
          create: {
            args: Prisma.ProductCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductPayload>
          }
          createMany: {
            args: Prisma.ProductCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.ProductDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductPayload>
          }
          update: {
            args: Prisma.ProductUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductPayload>
          }
          deleteMany: {
            args: Prisma.ProductDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ProductUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ProductUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductPayload>
          }
          aggregate: {
            args: Prisma.ProductAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateProduct>
          }
          groupBy: {
            args: Prisma.ProductGroupByArgs<ExtArgs>
            result: $Utils.Optional<ProductGroupByOutputType>[]
          }
          count: {
            args: Prisma.ProductCountArgs<ExtArgs>
            result: $Utils.Optional<ProductCountAggregateOutputType> | number
          }
        }
      }
      ProductThumbnail: {
        payload: Prisma.$ProductThumbnailPayload<ExtArgs>
        fields: Prisma.ProductThumbnailFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ProductThumbnailFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductThumbnailPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ProductThumbnailFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductThumbnailPayload>
          }
          findFirst: {
            args: Prisma.ProductThumbnailFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductThumbnailPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ProductThumbnailFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductThumbnailPayload>
          }
          findMany: {
            args: Prisma.ProductThumbnailFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductThumbnailPayload>[]
          }
          create: {
            args: Prisma.ProductThumbnailCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductThumbnailPayload>
          }
          createMany: {
            args: Prisma.ProductThumbnailCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.ProductThumbnailDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductThumbnailPayload>
          }
          update: {
            args: Prisma.ProductThumbnailUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductThumbnailPayload>
          }
          deleteMany: {
            args: Prisma.ProductThumbnailDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ProductThumbnailUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ProductThumbnailUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductThumbnailPayload>
          }
          aggregate: {
            args: Prisma.ProductThumbnailAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateProductThumbnail>
          }
          groupBy: {
            args: Prisma.ProductThumbnailGroupByArgs<ExtArgs>
            result: $Utils.Optional<ProductThumbnailGroupByOutputType>[]
          }
          count: {
            args: Prisma.ProductThumbnailCountArgs<ExtArgs>
            result: $Utils.Optional<ProductThumbnailCountAggregateOutputType> | number
          }
        }
      }
      ProductCategory: {
        payload: Prisma.$ProductCategoryPayload<ExtArgs>
        fields: Prisma.ProductCategoryFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ProductCategoryFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductCategoryPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ProductCategoryFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductCategoryPayload>
          }
          findFirst: {
            args: Prisma.ProductCategoryFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductCategoryPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ProductCategoryFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductCategoryPayload>
          }
          findMany: {
            args: Prisma.ProductCategoryFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductCategoryPayload>[]
          }
          create: {
            args: Prisma.ProductCategoryCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductCategoryPayload>
          }
          createMany: {
            args: Prisma.ProductCategoryCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.ProductCategoryDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductCategoryPayload>
          }
          update: {
            args: Prisma.ProductCategoryUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductCategoryPayload>
          }
          deleteMany: {
            args: Prisma.ProductCategoryDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ProductCategoryUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ProductCategoryUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductCategoryPayload>
          }
          aggregate: {
            args: Prisma.ProductCategoryAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateProductCategory>
          }
          groupBy: {
            args: Prisma.ProductCategoryGroupByArgs<ExtArgs>
            result: $Utils.Optional<ProductCategoryGroupByOutputType>[]
          }
          count: {
            args: Prisma.ProductCategoryCountArgs<ExtArgs>
            result: $Utils.Optional<ProductCategoryCountAggregateOutputType> | number
          }
        }
      }
      ProductVariation: {
        payload: Prisma.$ProductVariationPayload<ExtArgs>
        fields: Prisma.ProductVariationFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ProductVariationFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductVariationPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ProductVariationFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductVariationPayload>
          }
          findFirst: {
            args: Prisma.ProductVariationFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductVariationPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ProductVariationFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductVariationPayload>
          }
          findMany: {
            args: Prisma.ProductVariationFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductVariationPayload>[]
          }
          create: {
            args: Prisma.ProductVariationCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductVariationPayload>
          }
          createMany: {
            args: Prisma.ProductVariationCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.ProductVariationDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductVariationPayload>
          }
          update: {
            args: Prisma.ProductVariationUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductVariationPayload>
          }
          deleteMany: {
            args: Prisma.ProductVariationDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ProductVariationUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ProductVariationUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductVariationPayload>
          }
          aggregate: {
            args: Prisma.ProductVariationAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateProductVariation>
          }
          groupBy: {
            args: Prisma.ProductVariationGroupByArgs<ExtArgs>
            result: $Utils.Optional<ProductVariationGroupByOutputType>[]
          }
          count: {
            args: Prisma.ProductVariationCountArgs<ExtArgs>
            result: $Utils.Optional<ProductVariationCountAggregateOutputType> | number
          }
        }
      }
      ProductInclude: {
        payload: Prisma.$ProductIncludePayload<ExtArgs>
        fields: Prisma.ProductIncludeFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ProductIncludeFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductIncludePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ProductIncludeFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductIncludePayload>
          }
          findFirst: {
            args: Prisma.ProductIncludeFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductIncludePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ProductIncludeFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductIncludePayload>
          }
          findMany: {
            args: Prisma.ProductIncludeFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductIncludePayload>[]
          }
          create: {
            args: Prisma.ProductIncludeCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductIncludePayload>
          }
          createMany: {
            args: Prisma.ProductIncludeCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.ProductIncludeDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductIncludePayload>
          }
          update: {
            args: Prisma.ProductIncludeUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductIncludePayload>
          }
          deleteMany: {
            args: Prisma.ProductIncludeDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ProductIncludeUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ProductIncludeUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductIncludePayload>
          }
          aggregate: {
            args: Prisma.ProductIncludeAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateProductInclude>
          }
          groupBy: {
            args: Prisma.ProductIncludeGroupByArgs<ExtArgs>
            result: $Utils.Optional<ProductIncludeGroupByOutputType>[]
          }
          count: {
            args: Prisma.ProductIncludeCountArgs<ExtArgs>
            result: $Utils.Optional<ProductIncludeCountAggregateOutputType> | number
          }
        }
      }
      ProductExclude: {
        payload: Prisma.$ProductExcludePayload<ExtArgs>
        fields: Prisma.ProductExcludeFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ProductExcludeFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductExcludePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ProductExcludeFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductExcludePayload>
          }
          findFirst: {
            args: Prisma.ProductExcludeFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductExcludePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ProductExcludeFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductExcludePayload>
          }
          findMany: {
            args: Prisma.ProductExcludeFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductExcludePayload>[]
          }
          create: {
            args: Prisma.ProductExcludeCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductExcludePayload>
          }
          createMany: {
            args: Prisma.ProductExcludeCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.ProductExcludeDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductExcludePayload>
          }
          update: {
            args: Prisma.ProductExcludeUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductExcludePayload>
          }
          deleteMany: {
            args: Prisma.ProductExcludeDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ProductExcludeUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ProductExcludeUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductExcludePayload>
          }
          aggregate: {
            args: Prisma.ProductExcludeAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateProductExclude>
          }
          groupBy: {
            args: Prisma.ProductExcludeGroupByArgs<ExtArgs>
            result: $Utils.Optional<ProductExcludeGroupByOutputType>[]
          }
          count: {
            args: Prisma.ProductExcludeCountArgs<ExtArgs>
            result: $Utils.Optional<ProductExcludeCountAggregateOutputType> | number
          }
        }
      }
      ProductOrder: {
        payload: Prisma.$ProductOrderPayload<ExtArgs>
        fields: Prisma.ProductOrderFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ProductOrderFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductOrderPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ProductOrderFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductOrderPayload>
          }
          findFirst: {
            args: Prisma.ProductOrderFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductOrderPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ProductOrderFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductOrderPayload>
          }
          findMany: {
            args: Prisma.ProductOrderFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductOrderPayload>[]
          }
          create: {
            args: Prisma.ProductOrderCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductOrderPayload>
          }
          createMany: {
            args: Prisma.ProductOrderCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.ProductOrderDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductOrderPayload>
          }
          update: {
            args: Prisma.ProductOrderUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductOrderPayload>
          }
          deleteMany: {
            args: Prisma.ProductOrderDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ProductOrderUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ProductOrderUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductOrderPayload>
          }
          aggregate: {
            args: Prisma.ProductOrderAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateProductOrder>
          }
          groupBy: {
            args: Prisma.ProductOrderGroupByArgs<ExtArgs>
            result: $Utils.Optional<ProductOrderGroupByOutputType>[]
          }
          count: {
            args: Prisma.ProductOrderCountArgs<ExtArgs>
            result: $Utils.Optional<ProductOrderCountAggregateOutputType> | number
          }
        }
      }
      Vendor: {
        payload: Prisma.$VendorPayload<ExtArgs>
        fields: Prisma.VendorFieldRefs
        operations: {
          findUnique: {
            args: Prisma.VendorFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VendorPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.VendorFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VendorPayload>
          }
          findFirst: {
            args: Prisma.VendorFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VendorPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.VendorFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VendorPayload>
          }
          findMany: {
            args: Prisma.VendorFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VendorPayload>[]
          }
          create: {
            args: Prisma.VendorCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VendorPayload>
          }
          createMany: {
            args: Prisma.VendorCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.VendorDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VendorPayload>
          }
          update: {
            args: Prisma.VendorUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VendorPayload>
          }
          deleteMany: {
            args: Prisma.VendorDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.VendorUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.VendorUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VendorPayload>
          }
          aggregate: {
            args: Prisma.VendorAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateVendor>
          }
          groupBy: {
            args: Prisma.VendorGroupByArgs<ExtArgs>
            result: $Utils.Optional<VendorGroupByOutputType>[]
          }
          count: {
            args: Prisma.VendorCountArgs<ExtArgs>
            result: $Utils.Optional<VendorCountAggregateOutputType> | number
          }
        }
      }
      Hotel: {
        payload: Prisma.$HotelPayload<ExtArgs>
        fields: Prisma.HotelFieldRefs
        operations: {
          findUnique: {
            args: Prisma.HotelFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HotelPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.HotelFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HotelPayload>
          }
          findFirst: {
            args: Prisma.HotelFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HotelPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.HotelFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HotelPayload>
          }
          findMany: {
            args: Prisma.HotelFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HotelPayload>[]
          }
          create: {
            args: Prisma.HotelCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HotelPayload>
          }
          createMany: {
            args: Prisma.HotelCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.HotelDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HotelPayload>
          }
          update: {
            args: Prisma.HotelUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HotelPayload>
          }
          deleteMany: {
            args: Prisma.HotelDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.HotelUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.HotelUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HotelPayload>
          }
          aggregate: {
            args: Prisma.HotelAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateHotel>
          }
          groupBy: {
            args: Prisma.HotelGroupByArgs<ExtArgs>
            result: $Utils.Optional<HotelGroupByOutputType>[]
          }
          count: {
            args: Prisma.HotelCountArgs<ExtArgs>
            result: $Utils.Optional<HotelCountAggregateOutputType> | number
          }
        }
      }
      Period: {
        payload: Prisma.$PeriodPayload<ExtArgs>
        fields: Prisma.PeriodFieldRefs
        operations: {
          findUnique: {
            args: Prisma.PeriodFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PeriodPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.PeriodFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PeriodPayload>
          }
          findFirst: {
            args: Prisma.PeriodFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PeriodPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.PeriodFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PeriodPayload>
          }
          findMany: {
            args: Prisma.PeriodFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PeriodPayload>[]
          }
          create: {
            args: Prisma.PeriodCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PeriodPayload>
          }
          createMany: {
            args: Prisma.PeriodCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.PeriodDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PeriodPayload>
          }
          update: {
            args: Prisma.PeriodUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PeriodPayload>
          }
          deleteMany: {
            args: Prisma.PeriodDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.PeriodUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.PeriodUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PeriodPayload>
          }
          aggregate: {
            args: Prisma.PeriodAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregatePeriod>
          }
          groupBy: {
            args: Prisma.PeriodGroupByArgs<ExtArgs>
            result: $Utils.Optional<PeriodGroupByOutputType>[]
          }
          count: {
            args: Prisma.PeriodCountArgs<ExtArgs>
            result: $Utils.Optional<PeriodCountAggregateOutputType> | number
          }
        }
      }
      HotelPeriodPrice: {
        payload: Prisma.$HotelPeriodPricePayload<ExtArgs>
        fields: Prisma.HotelPeriodPriceFieldRefs
        operations: {
          findUnique: {
            args: Prisma.HotelPeriodPriceFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HotelPeriodPricePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.HotelPeriodPriceFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HotelPeriodPricePayload>
          }
          findFirst: {
            args: Prisma.HotelPeriodPriceFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HotelPeriodPricePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.HotelPeriodPriceFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HotelPeriodPricePayload>
          }
          findMany: {
            args: Prisma.HotelPeriodPriceFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HotelPeriodPricePayload>[]
          }
          create: {
            args: Prisma.HotelPeriodPriceCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HotelPeriodPricePayload>
          }
          createMany: {
            args: Prisma.HotelPeriodPriceCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.HotelPeriodPriceDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HotelPeriodPricePayload>
          }
          update: {
            args: Prisma.HotelPeriodPriceUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HotelPeriodPricePayload>
          }
          deleteMany: {
            args: Prisma.HotelPeriodPriceDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.HotelPeriodPriceUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.HotelPeriodPriceUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HotelPeriodPricePayload>
          }
          aggregate: {
            args: Prisma.HotelPeriodPriceAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateHotelPeriodPrice>
          }
          groupBy: {
            args: Prisma.HotelPeriodPriceGroupByArgs<ExtArgs>
            result: $Utils.Optional<HotelPeriodPriceGroupByOutputType>[]
          }
          count: {
            args: Prisma.HotelPeriodPriceCountArgs<ExtArgs>
            result: $Utils.Optional<HotelPeriodPriceCountAggregateOutputType> | number
          }
        }
      }
      Airline: {
        payload: Prisma.$AirlinePayload<ExtArgs>
        fields: Prisma.AirlineFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AirlineFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AirlinePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AirlineFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AirlinePayload>
          }
          findFirst: {
            args: Prisma.AirlineFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AirlinePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AirlineFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AirlinePayload>
          }
          findMany: {
            args: Prisma.AirlineFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AirlinePayload>[]
          }
          create: {
            args: Prisma.AirlineCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AirlinePayload>
          }
          createMany: {
            args: Prisma.AirlineCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.AirlineDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AirlinePayload>
          }
          update: {
            args: Prisma.AirlineUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AirlinePayload>
          }
          deleteMany: {
            args: Prisma.AirlineDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.AirlineUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.AirlineUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AirlinePayload>
          }
          aggregate: {
            args: Prisma.AirlineAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAirline>
          }
          groupBy: {
            args: Prisma.AirlineGroupByArgs<ExtArgs>
            result: $Utils.Optional<AirlineGroupByOutputType>[]
          }
          count: {
            args: Prisma.AirlineCountArgs<ExtArgs>
            result: $Utils.Optional<AirlineCountAggregateOutputType> | number
          }
        }
      }
      Visa: {
        payload: Prisma.$VisaPayload<ExtArgs>
        fields: Prisma.VisaFieldRefs
        operations: {
          findUnique: {
            args: Prisma.VisaFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VisaPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.VisaFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VisaPayload>
          }
          findFirst: {
            args: Prisma.VisaFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VisaPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.VisaFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VisaPayload>
          }
          findMany: {
            args: Prisma.VisaFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VisaPayload>[]
          }
          create: {
            args: Prisma.VisaCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VisaPayload>
          }
          createMany: {
            args: Prisma.VisaCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.VisaDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VisaPayload>
          }
          update: {
            args: Prisma.VisaUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VisaPayload>
          }
          deleteMany: {
            args: Prisma.VisaDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.VisaUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.VisaUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$VisaPayload>
          }
          aggregate: {
            args: Prisma.VisaAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateVisa>
          }
          groupBy: {
            args: Prisma.VisaGroupByArgs<ExtArgs>
            result: $Utils.Optional<VisaGroupByOutputType>[]
          }
          count: {
            args: Prisma.VisaCountArgs<ExtArgs>
            result: $Utils.Optional<VisaCountAggregateOutputType> | number
          }
        }
      }
      Transportation: {
        payload: Prisma.$TransportationPayload<ExtArgs>
        fields: Prisma.TransportationFieldRefs
        operations: {
          findUnique: {
            args: Prisma.TransportationFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TransportationPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.TransportationFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TransportationPayload>
          }
          findFirst: {
            args: Prisma.TransportationFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TransportationPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.TransportationFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TransportationPayload>
          }
          findMany: {
            args: Prisma.TransportationFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TransportationPayload>[]
          }
          create: {
            args: Prisma.TransportationCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TransportationPayload>
          }
          createMany: {
            args: Prisma.TransportationCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.TransportationDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TransportationPayload>
          }
          update: {
            args: Prisma.TransportationUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TransportationPayload>
          }
          deleteMany: {
            args: Prisma.TransportationDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.TransportationUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.TransportationUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TransportationPayload>
          }
          aggregate: {
            args: Prisma.TransportationAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateTransportation>
          }
          groupBy: {
            args: Prisma.TransportationGroupByArgs<ExtArgs>
            result: $Utils.Optional<TransportationGroupByOutputType>[]
          }
          count: {
            args: Prisma.TransportationCountArgs<ExtArgs>
            result: $Utils.Optional<TransportationCountAggregateOutputType> | number
          }
        }
      }
      Muthawif: {
        payload: Prisma.$MuthawifPayload<ExtArgs>
        fields: Prisma.MuthawifFieldRefs
        operations: {
          findUnique: {
            args: Prisma.MuthawifFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MuthawifPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.MuthawifFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MuthawifPayload>
          }
          findFirst: {
            args: Prisma.MuthawifFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MuthawifPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.MuthawifFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MuthawifPayload>
          }
          findMany: {
            args: Prisma.MuthawifFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MuthawifPayload>[]
          }
          create: {
            args: Prisma.MuthawifCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MuthawifPayload>
          }
          createMany: {
            args: Prisma.MuthawifCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.MuthawifDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MuthawifPayload>
          }
          update: {
            args: Prisma.MuthawifUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MuthawifPayload>
          }
          deleteMany: {
            args: Prisma.MuthawifDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.MuthawifUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.MuthawifUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MuthawifPayload>
          }
          aggregate: {
            args: Prisma.MuthawifAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateMuthawif>
          }
          groupBy: {
            args: Prisma.MuthawifGroupByArgs<ExtArgs>
            result: $Utils.Optional<MuthawifGroupByOutputType>[]
          }
          count: {
            args: Prisma.MuthawifCountArgs<ExtArgs>
            result: $Utils.Optional<MuthawifCountAggregateOutputType> | number
          }
        }
      }
      HandlingSaudi: {
        payload: Prisma.$HandlingSaudiPayload<ExtArgs>
        fields: Prisma.HandlingSaudiFieldRefs
        operations: {
          findUnique: {
            args: Prisma.HandlingSaudiFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HandlingSaudiPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.HandlingSaudiFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HandlingSaudiPayload>
          }
          findFirst: {
            args: Prisma.HandlingSaudiFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HandlingSaudiPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.HandlingSaudiFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HandlingSaudiPayload>
          }
          findMany: {
            args: Prisma.HandlingSaudiFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HandlingSaudiPayload>[]
          }
          create: {
            args: Prisma.HandlingSaudiCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HandlingSaudiPayload>
          }
          createMany: {
            args: Prisma.HandlingSaudiCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.HandlingSaudiDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HandlingSaudiPayload>
          }
          update: {
            args: Prisma.HandlingSaudiUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HandlingSaudiPayload>
          }
          deleteMany: {
            args: Prisma.HandlingSaudiDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.HandlingSaudiUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.HandlingSaudiUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HandlingSaudiPayload>
          }
          aggregate: {
            args: Prisma.HandlingSaudiAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateHandlingSaudi>
          }
          groupBy: {
            args: Prisma.HandlingSaudiGroupByArgs<ExtArgs>
            result: $Utils.Optional<HandlingSaudiGroupByOutputType>[]
          }
          count: {
            args: Prisma.HandlingSaudiCountArgs<ExtArgs>
            result: $Utils.Optional<HandlingSaudiCountAggregateOutputType> | number
          }
        }
      }
      HandlingDomestic: {
        payload: Prisma.$HandlingDomesticPayload<ExtArgs>
        fields: Prisma.HandlingDomesticFieldRefs
        operations: {
          findUnique: {
            args: Prisma.HandlingDomesticFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HandlingDomesticPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.HandlingDomesticFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HandlingDomesticPayload>
          }
          findFirst: {
            args: Prisma.HandlingDomesticFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HandlingDomesticPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.HandlingDomesticFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HandlingDomesticPayload>
          }
          findMany: {
            args: Prisma.HandlingDomesticFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HandlingDomesticPayload>[]
          }
          create: {
            args: Prisma.HandlingDomesticCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HandlingDomesticPayload>
          }
          createMany: {
            args: Prisma.HandlingDomesticCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.HandlingDomesticDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HandlingDomesticPayload>
          }
          update: {
            args: Prisma.HandlingDomesticUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HandlingDomesticPayload>
          }
          deleteMany: {
            args: Prisma.HandlingDomesticDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.HandlingDomesticUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.HandlingDomesticUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$HandlingDomesticPayload>
          }
          aggregate: {
            args: Prisma.HandlingDomesticAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateHandlingDomestic>
          }
          groupBy: {
            args: Prisma.HandlingDomesticGroupByArgs<ExtArgs>
            result: $Utils.Optional<HandlingDomesticGroupByOutputType>[]
          }
          count: {
            args: Prisma.HandlingDomesticCountArgs<ExtArgs>
            result: $Utils.Optional<HandlingDomesticCountAggregateOutputType> | number
          }
        }
      }
      Siskopatuh: {
        payload: Prisma.$SiskopatuhPayload<ExtArgs>
        fields: Prisma.SiskopatuhFieldRefs
        operations: {
          findUnique: {
            args: Prisma.SiskopatuhFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SiskopatuhPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.SiskopatuhFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SiskopatuhPayload>
          }
          findFirst: {
            args: Prisma.SiskopatuhFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SiskopatuhPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.SiskopatuhFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SiskopatuhPayload>
          }
          findMany: {
            args: Prisma.SiskopatuhFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SiskopatuhPayload>[]
          }
          create: {
            args: Prisma.SiskopatuhCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SiskopatuhPayload>
          }
          createMany: {
            args: Prisma.SiskopatuhCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.SiskopatuhDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SiskopatuhPayload>
          }
          update: {
            args: Prisma.SiskopatuhUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SiskopatuhPayload>
          }
          deleteMany: {
            args: Prisma.SiskopatuhDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.SiskopatuhUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.SiskopatuhUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SiskopatuhPayload>
          }
          aggregate: {
            args: Prisma.SiskopatuhAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateSiskopatuh>
          }
          groupBy: {
            args: Prisma.SiskopatuhGroupByArgs<ExtArgs>
            result: $Utils.Optional<SiskopatuhGroupByOutputType>[]
          }
          count: {
            args: Prisma.SiskopatuhCountArgs<ExtArgs>
            result: $Utils.Optional<SiskopatuhCountAggregateOutputType> | number
          }
        }
      }
      Equipment: {
        payload: Prisma.$EquipmentPayload<ExtArgs>
        fields: Prisma.EquipmentFieldRefs
        operations: {
          findUnique: {
            args: Prisma.EquipmentFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EquipmentPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.EquipmentFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EquipmentPayload>
          }
          findFirst: {
            args: Prisma.EquipmentFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EquipmentPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.EquipmentFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EquipmentPayload>
          }
          findMany: {
            args: Prisma.EquipmentFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EquipmentPayload>[]
          }
          create: {
            args: Prisma.EquipmentCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EquipmentPayload>
          }
          createMany: {
            args: Prisma.EquipmentCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.EquipmentDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EquipmentPayload>
          }
          update: {
            args: Prisma.EquipmentUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EquipmentPayload>
          }
          deleteMany: {
            args: Prisma.EquipmentDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.EquipmentUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.EquipmentUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$EquipmentPayload>
          }
          aggregate: {
            args: Prisma.EquipmentAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateEquipment>
          }
          groupBy: {
            args: Prisma.EquipmentGroupByArgs<ExtArgs>
            result: $Utils.Optional<EquipmentGroupByOutputType>[]
          }
          count: {
            args: Prisma.EquipmentCountArgs<ExtArgs>
            result: $Utils.Optional<EquipmentCountAggregateOutputType> | number
          }
        }
      }
      TourPlus: {
        payload: Prisma.$TourPlusPayload<ExtArgs>
        fields: Prisma.TourPlusFieldRefs
        operations: {
          findUnique: {
            args: Prisma.TourPlusFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TourPlusPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.TourPlusFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TourPlusPayload>
          }
          findFirst: {
            args: Prisma.TourPlusFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TourPlusPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.TourPlusFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TourPlusPayload>
          }
          findMany: {
            args: Prisma.TourPlusFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TourPlusPayload>[]
          }
          create: {
            args: Prisma.TourPlusCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TourPlusPayload>
          }
          createMany: {
            args: Prisma.TourPlusCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.TourPlusDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TourPlusPayload>
          }
          update: {
            args: Prisma.TourPlusUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TourPlusPayload>
          }
          deleteMany: {
            args: Prisma.TourPlusDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.TourPlusUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.TourPlusUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$TourPlusPayload>
          }
          aggregate: {
            args: Prisma.TourPlusAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateTourPlus>
          }
          groupBy: {
            args: Prisma.TourPlusGroupByArgs<ExtArgs>
            result: $Utils.Optional<TourPlusGroupByOutputType>[]
          }
          count: {
            args: Prisma.TourPlusCountArgs<ExtArgs>
            result: $Utils.Optional<TourPlusCountAggregateOutputType> | number
          }
        }
      }
      Manasik: {
        payload: Prisma.$ManasikPayload<ExtArgs>
        fields: Prisma.ManasikFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ManasikFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ManasikPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ManasikFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ManasikPayload>
          }
          findFirst: {
            args: Prisma.ManasikFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ManasikPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ManasikFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ManasikPayload>
          }
          findMany: {
            args: Prisma.ManasikFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ManasikPayload>[]
          }
          create: {
            args: Prisma.ManasikCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ManasikPayload>
          }
          createMany: {
            args: Prisma.ManasikCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.ManasikDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ManasikPayload>
          }
          update: {
            args: Prisma.ManasikUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ManasikPayload>
          }
          deleteMany: {
            args: Prisma.ManasikDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ManasikUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ManasikUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ManasikPayload>
          }
          aggregate: {
            args: Prisma.ManasikAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateManasik>
          }
          groupBy: {
            args: Prisma.ManasikGroupByArgs<ExtArgs>
            result: $Utils.Optional<ManasikGroupByOutputType>[]
          }
          count: {
            args: Prisma.ManasikCountArgs<ExtArgs>
            result: $Utils.Optional<ManasikCountAggregateOutputType> | number
          }
        }
      }
      MitraPackage: {
        payload: Prisma.$MitraPackagePayload<ExtArgs>
        fields: Prisma.MitraPackageFieldRefs
        operations: {
          findUnique: {
            args: Prisma.MitraPackageFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MitraPackagePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.MitraPackageFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MitraPackagePayload>
          }
          findFirst: {
            args: Prisma.MitraPackageFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MitraPackagePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.MitraPackageFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MitraPackagePayload>
          }
          findMany: {
            args: Prisma.MitraPackageFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MitraPackagePayload>[]
          }
          create: {
            args: Prisma.MitraPackageCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MitraPackagePayload>
          }
          createMany: {
            args: Prisma.MitraPackageCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.MitraPackageDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MitraPackagePayload>
          }
          update: {
            args: Prisma.MitraPackageUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MitraPackagePayload>
          }
          deleteMany: {
            args: Prisma.MitraPackageDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.MitraPackageUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.MitraPackageUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MitraPackagePayload>
          }
          aggregate: {
            args: Prisma.MitraPackageAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateMitraPackage>
          }
          groupBy: {
            args: Prisma.MitraPackageGroupByArgs<ExtArgs>
            result: $Utils.Optional<MitraPackageGroupByOutputType>[]
          }
          count: {
            args: Prisma.MitraPackageCountArgs<ExtArgs>
            result: $Utils.Optional<MitraPackageCountAggregateOutputType> | number
          }
        }
      }
      MitraPackageOrder: {
        payload: Prisma.$MitraPackageOrderPayload<ExtArgs>
        fields: Prisma.MitraPackageOrderFieldRefs
        operations: {
          findUnique: {
            args: Prisma.MitraPackageOrderFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MitraPackageOrderPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.MitraPackageOrderFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MitraPackageOrderPayload>
          }
          findFirst: {
            args: Prisma.MitraPackageOrderFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MitraPackageOrderPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.MitraPackageOrderFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MitraPackageOrderPayload>
          }
          findMany: {
            args: Prisma.MitraPackageOrderFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MitraPackageOrderPayload>[]
          }
          create: {
            args: Prisma.MitraPackageOrderCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MitraPackageOrderPayload>
          }
          createMany: {
            args: Prisma.MitraPackageOrderCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.MitraPackageOrderDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MitraPackageOrderPayload>
          }
          update: {
            args: Prisma.MitraPackageOrderUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MitraPackageOrderPayload>
          }
          deleteMany: {
            args: Prisma.MitraPackageOrderDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.MitraPackageOrderUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.MitraPackageOrderUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MitraPackageOrderPayload>
          }
          aggregate: {
            args: Prisma.MitraPackageOrderAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateMitraPackageOrder>
          }
          groupBy: {
            args: Prisma.MitraPackageOrderGroupByArgs<ExtArgs>
            result: $Utils.Optional<MitraPackageOrderGroupByOutputType>[]
          }
          count: {
            args: Prisma.MitraPackageOrderCountArgs<ExtArgs>
            result: $Utils.Optional<MitraPackageOrderCountAggregateOutputType> | number
          }
        }
      }
      ExchangeRate: {
        payload: Prisma.$ExchangeRatePayload<ExtArgs>
        fields: Prisma.ExchangeRateFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ExchangeRateFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExchangeRatePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ExchangeRateFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExchangeRatePayload>
          }
          findFirst: {
            args: Prisma.ExchangeRateFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExchangeRatePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ExchangeRateFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExchangeRatePayload>
          }
          findMany: {
            args: Prisma.ExchangeRateFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExchangeRatePayload>[]
          }
          create: {
            args: Prisma.ExchangeRateCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExchangeRatePayload>
          }
          createMany: {
            args: Prisma.ExchangeRateCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.ExchangeRateDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExchangeRatePayload>
          }
          update: {
            args: Prisma.ExchangeRateUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExchangeRatePayload>
          }
          deleteMany: {
            args: Prisma.ExchangeRateDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ExchangeRateUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ExchangeRateUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ExchangeRatePayload>
          }
          aggregate: {
            args: Prisma.ExchangeRateAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateExchangeRate>
          }
          groupBy: {
            args: Prisma.ExchangeRateGroupByArgs<ExtArgs>
            result: $Utils.Optional<ExchangeRateGroupByOutputType>[]
          }
          count: {
            args: Prisma.ExchangeRateCountArgs<ExtArgs>
            result: $Utils.Optional<ExchangeRateCountAggregateOutputType> | number
          }
        }
      }
      Contact: {
        payload: Prisma.$ContactPayload<ExtArgs>
        fields: Prisma.ContactFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ContactFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ContactPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ContactFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ContactPayload>
          }
          findFirst: {
            args: Prisma.ContactFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ContactPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ContactFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ContactPayload>
          }
          findMany: {
            args: Prisma.ContactFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ContactPayload>[]
          }
          create: {
            args: Prisma.ContactCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ContactPayload>
          }
          createMany: {
            args: Prisma.ContactCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.ContactDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ContactPayload>
          }
          update: {
            args: Prisma.ContactUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ContactPayload>
          }
          deleteMany: {
            args: Prisma.ContactDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ContactUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ContactUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ContactPayload>
          }
          aggregate: {
            args: Prisma.ContactAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateContact>
          }
          groupBy: {
            args: Prisma.ContactGroupByArgs<ExtArgs>
            result: $Utils.Optional<ContactGroupByOutputType>[]
          }
          count: {
            args: Prisma.ContactCountArgs<ExtArgs>
            result: $Utils.Optional<ContactCountAggregateOutputType> | number
          }
        }
      }
      Faq: {
        payload: Prisma.$FaqPayload<ExtArgs>
        fields: Prisma.FaqFieldRefs
        operations: {
          findUnique: {
            args: Prisma.FaqFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FaqPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.FaqFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FaqPayload>
          }
          findFirst: {
            args: Prisma.FaqFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FaqPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.FaqFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FaqPayload>
          }
          findMany: {
            args: Prisma.FaqFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FaqPayload>[]
          }
          create: {
            args: Prisma.FaqCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FaqPayload>
          }
          createMany: {
            args: Prisma.FaqCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.FaqDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FaqPayload>
          }
          update: {
            args: Prisma.FaqUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FaqPayload>
          }
          deleteMany: {
            args: Prisma.FaqDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.FaqUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.FaqUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FaqPayload>
          }
          aggregate: {
            args: Prisma.FaqAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateFaq>
          }
          groupBy: {
            args: Prisma.FaqGroupByArgs<ExtArgs>
            result: $Utils.Optional<FaqGroupByOutputType>[]
          }
          count: {
            args: Prisma.FaqCountArgs<ExtArgs>
            result: $Utils.Optional<FaqCountAggregateOutputType> | number
          }
        }
      }
      Content: {
        payload: Prisma.$ContentPayload<ExtArgs>
        fields: Prisma.ContentFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ContentFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ContentPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ContentFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ContentPayload>
          }
          findFirst: {
            args: Prisma.ContentFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ContentPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ContentFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ContentPayload>
          }
          findMany: {
            args: Prisma.ContentFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ContentPayload>[]
          }
          create: {
            args: Prisma.ContentCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ContentPayload>
          }
          createMany: {
            args: Prisma.ContentCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.ContentDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ContentPayload>
          }
          update: {
            args: Prisma.ContentUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ContentPayload>
          }
          deleteMany: {
            args: Prisma.ContentDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ContentUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ContentUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ContentPayload>
          }
          aggregate: {
            args: Prisma.ContentAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateContent>
          }
          groupBy: {
            args: Prisma.ContentGroupByArgs<ExtArgs>
            result: $Utils.Optional<ContentGroupByOutputType>[]
          }
          count: {
            args: Prisma.ContentCountArgs<ExtArgs>
            result: $Utils.Optional<ContentCountAggregateOutputType> | number
          }
        }
      }
      MenuItem: {
        payload: Prisma.$MenuItemPayload<ExtArgs>
        fields: Prisma.MenuItemFieldRefs
        operations: {
          findUnique: {
            args: Prisma.MenuItemFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MenuItemPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.MenuItemFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MenuItemPayload>
          }
          findFirst: {
            args: Prisma.MenuItemFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MenuItemPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.MenuItemFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MenuItemPayload>
          }
          findMany: {
            args: Prisma.MenuItemFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MenuItemPayload>[]
          }
          create: {
            args: Prisma.MenuItemCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MenuItemPayload>
          }
          createMany: {
            args: Prisma.MenuItemCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.MenuItemDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MenuItemPayload>
          }
          update: {
            args: Prisma.MenuItemUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MenuItemPayload>
          }
          deleteMany: {
            args: Prisma.MenuItemDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.MenuItemUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.MenuItemUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$MenuItemPayload>
          }
          aggregate: {
            args: Prisma.MenuItemAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateMenuItem>
          }
          groupBy: {
            args: Prisma.MenuItemGroupByArgs<ExtArgs>
            result: $Utils.Optional<MenuItemGroupByOutputType>[]
          }
          count: {
            args: Prisma.MenuItemCountArgs<ExtArgs>
            result: $Utils.Optional<MenuItemCountAggregateOutputType> | number
          }
        }
      }
      Footer: {
        payload: Prisma.$FooterPayload<ExtArgs>
        fields: Prisma.FooterFieldRefs
        operations: {
          findUnique: {
            args: Prisma.FooterFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FooterPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.FooterFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FooterPayload>
          }
          findFirst: {
            args: Prisma.FooterFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FooterPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.FooterFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FooterPayload>
          }
          findMany: {
            args: Prisma.FooterFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FooterPayload>[]
          }
          create: {
            args: Prisma.FooterCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FooterPayload>
          }
          createMany: {
            args: Prisma.FooterCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.FooterDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FooterPayload>
          }
          update: {
            args: Prisma.FooterUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FooterPayload>
          }
          deleteMany: {
            args: Prisma.FooterDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.FooterUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.FooterUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FooterPayload>
          }
          aggregate: {
            args: Prisma.FooterAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateFooter>
          }
          groupBy: {
            args: Prisma.FooterGroupByArgs<ExtArgs>
            result: $Utils.Optional<FooterGroupByOutputType>[]
          }
          count: {
            args: Prisma.FooterCountArgs<ExtArgs>
            result: $Utils.Optional<FooterCountAggregateOutputType> | number
          }
        }
      }
      FooterItem: {
        payload: Prisma.$FooterItemPayload<ExtArgs>
        fields: Prisma.FooterItemFieldRefs
        operations: {
          findUnique: {
            args: Prisma.FooterItemFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FooterItemPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.FooterItemFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FooterItemPayload>
          }
          findFirst: {
            args: Prisma.FooterItemFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FooterItemPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.FooterItemFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FooterItemPayload>
          }
          findMany: {
            args: Prisma.FooterItemFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FooterItemPayload>[]
          }
          create: {
            args: Prisma.FooterItemCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FooterItemPayload>
          }
          createMany: {
            args: Prisma.FooterItemCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.FooterItemDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FooterItemPayload>
          }
          update: {
            args: Prisma.FooterItemUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FooterItemPayload>
          }
          deleteMany: {
            args: Prisma.FooterItemDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.FooterItemUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.FooterItemUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$FooterItemPayload>
          }
          aggregate: {
            args: Prisma.FooterItemAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateFooterItem>
          }
          groupBy: {
            args: Prisma.FooterItemGroupByArgs<ExtArgs>
            result: $Utils.Optional<FooterItemGroupByOutputType>[]
          }
          count: {
            args: Prisma.FooterItemCountArgs<ExtArgs>
            result: $Utils.Optional<FooterItemCountAggregateOutputType> | number
          }
        }
      }
      Color: {
        payload: Prisma.$ColorPayload<ExtArgs>
        fields: Prisma.ColorFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ColorFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ColorPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ColorFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ColorPayload>
          }
          findFirst: {
            args: Prisma.ColorFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ColorPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ColorFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ColorPayload>
          }
          findMany: {
            args: Prisma.ColorFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ColorPayload>[]
          }
          create: {
            args: Prisma.ColorCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ColorPayload>
          }
          createMany: {
            args: Prisma.ColorCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          delete: {
            args: Prisma.ColorDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ColorPayload>
          }
          update: {
            args: Prisma.ColorUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ColorPayload>
          }
          deleteMany: {
            args: Prisma.ColorDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ColorUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ColorUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ColorPayload>
          }
          aggregate: {
            args: Prisma.ColorAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateColor>
          }
          groupBy: {
            args: Prisma.ColorGroupByArgs<ExtArgs>
            result: $Utils.Optional<ColorGroupByOutputType>[]
          }
          count: {
            args: Prisma.ColorCountArgs<ExtArgs>
            result: $Utils.Optional<ColorCountAggregateOutputType> | number
          }
        }
      }
    }
  } & {
    other: {
      payload: any
      operations: {
        $executeRaw: {
          args: [query: TemplateStringsArray | Prisma.Sql, ...values: any[]],
          result: any
        }
        $executeRawUnsafe: {
          args: [query: string, ...values: any[]],
          result: any
        }
        $queryRaw: {
          args: [query: TemplateStringsArray | Prisma.Sql, ...values: any[]],
          result: any
        }
        $queryRawUnsafe: {
          args: [query: string, ...values: any[]],
          result: any
        }
      }
    }
  }
  export const defineExtension: $Extensions.ExtendsHook<"define", Prisma.TypeMapCb, $Extensions.DefaultArgs>
  export type DefaultPrismaClient = PrismaClient
  export type ErrorFormat = 'pretty' | 'colorless' | 'minimal'
  export interface PrismaClientOptions {
    /**
     * Overwrites the datasource url from your schema.prisma file
     */
    datasources?: Datasources
    /**
     * Overwrites the datasource url from your schema.prisma file
     */
    datasourceUrl?: string
    /**
     * @default "colorless"
     */
    errorFormat?: ErrorFormat
    /**
     * @example
     * ```
     * // Defaults to stdout
     * log: ['query', 'info', 'warn', 'error']
     * 
     * // Emit as events
     * log: [
     *   { emit: 'stdout', level: 'query' },
     *   { emit: 'stdout', level: 'info' },
     *   { emit: 'stdout', level: 'warn' }
     *   { emit: 'stdout', level: 'error' }
     * ]
     * ```
     * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/logging#the-log-option).
     */
    log?: (LogLevel | LogDefinition)[]
    /**
     * The default values for transactionOptions
     * maxWait ?= 2000
     * timeout ?= 5000
     */
    transactionOptions?: {
      maxWait?: number
      timeout?: number
      isolationLevel?: Prisma.TransactionIsolationLevel
    }
  }


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

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

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

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


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

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

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

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

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

  export type Datasource = {
    url?: string
  }

  /**
   * Count Types
   */


  /**
   * Count Type UserCountOutputType
   */

  export type UserCountOutputType = {
    ProductOrders: number
    MitraPackageOrder: number
    MitraRequest: number
  }

  export type UserCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    ProductOrders?: boolean | UserCountOutputTypeCountProductOrdersArgs
    MitraPackageOrder?: boolean | UserCountOutputTypeCountMitraPackageOrderArgs
    MitraRequest?: boolean | UserCountOutputTypeCountMitraRequestArgs
  }

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

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

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

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


  /**
   * Count Type UserPackageCountOutputType
   */

  export type UserPackageCountOutputType = {
    UserPackageOrders: number
  }

  export type UserPackageCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    UserPackageOrders?: boolean | UserPackageCountOutputTypeCountUserPackageOrdersArgs
  }

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

  /**
   * UserPackageCountOutputType without action
   */
  export type UserPackageCountOutputTypeCountUserPackageOrdersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: UserPackageOrderWhereInput
  }


  /**
   * Count Type PackageTypeCountOutputType
   */

  export type PackageTypeCountOutputType = {
    UserPackageOptions: number
  }

  export type PackageTypeCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    UserPackageOptions?: boolean | PackageTypeCountOutputTypeCountUserPackageOptionsArgs
  }

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

  /**
   * PackageTypeCountOutputType without action
   */
  export type PackageTypeCountOutputTypeCountUserPackageOptionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: UserPackageOptionWhereInput
  }


  /**
   * Count Type UserPackageOptionCountOutputType
   */

  export type UserPackageOptionCountOutputType = {
    transportations: number
    flights: number
    hotelMekkahs: number
    hotelMadinahs: number
    muthawifs: number
    handlings: number
  }

  export type UserPackageOptionCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    transportations?: boolean | UserPackageOptionCountOutputTypeCountTransportationsArgs
    flights?: boolean | UserPackageOptionCountOutputTypeCountFlightsArgs
    hotelMekkahs?: boolean | UserPackageOptionCountOutputTypeCountHotelMekkahsArgs
    hotelMadinahs?: boolean | UserPackageOptionCountOutputTypeCountHotelMadinahsArgs
    muthawifs?: boolean | UserPackageOptionCountOutputTypeCountMuthawifsArgs
    handlings?: boolean | UserPackageOptionCountOutputTypeCountHandlingsArgs
  }

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

  /**
   * UserPackageOptionCountOutputType without action
   */
  export type UserPackageOptionCountOutputTypeCountTransportationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: UserPackageWhereInput
  }

  /**
   * UserPackageOptionCountOutputType without action
   */
  export type UserPackageOptionCountOutputTypeCountFlightsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: UserPackageWhereInput
  }

  /**
   * UserPackageOptionCountOutputType without action
   */
  export type UserPackageOptionCountOutputTypeCountHotelMekkahsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: UserPackageWhereInput
  }

  /**
   * UserPackageOptionCountOutputType without action
   */
  export type UserPackageOptionCountOutputTypeCountHotelMadinahsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: UserPackageWhereInput
  }

  /**
   * UserPackageOptionCountOutputType without action
   */
  export type UserPackageOptionCountOutputTypeCountMuthawifsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: UserPackageWhereInput
  }

  /**
   * UserPackageOptionCountOutputType without action
   */
  export type UserPackageOptionCountOutputTypeCountHandlingsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: UserPackageWhereInput
  }


  /**
   * Count Type CategoryCountOutputType
   */

  export type CategoryCountOutputType = {
    ProductCategories: number
  }

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

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

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


  /**
   * Count Type ProductCountOutputType
   */

  export type ProductCountOutputType = {
    ProductThumbnails: number
    ProductCategories: number
    ProductVariations: number
    ProductIncludes: number
    ProductExcludes: number
    ProductOrders: number
  }

  export type ProductCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    ProductThumbnails?: boolean | ProductCountOutputTypeCountProductThumbnailsArgs
    ProductCategories?: boolean | ProductCountOutputTypeCountProductCategoriesArgs
    ProductVariations?: boolean | ProductCountOutputTypeCountProductVariationsArgs
    ProductIncludes?: boolean | ProductCountOutputTypeCountProductIncludesArgs
    ProductExcludes?: boolean | ProductCountOutputTypeCountProductExcludesArgs
    ProductOrders?: boolean | ProductCountOutputTypeCountProductOrdersArgs
  }

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

  /**
   * ProductCountOutputType without action
   */
  export type ProductCountOutputTypeCountProductThumbnailsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ProductThumbnailWhereInput
  }

  /**
   * ProductCountOutputType without action
   */
  export type ProductCountOutputTypeCountProductCategoriesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ProductCategoryWhereInput
  }

  /**
   * ProductCountOutputType without action
   */
  export type ProductCountOutputTypeCountProductVariationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ProductVariationWhereInput
  }

  /**
   * ProductCountOutputType without action
   */
  export type ProductCountOutputTypeCountProductIncludesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ProductIncludeWhereInput
  }

  /**
   * ProductCountOutputType without action
   */
  export type ProductCountOutputTypeCountProductExcludesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ProductExcludeWhereInput
  }

  /**
   * ProductCountOutputType without action
   */
  export type ProductCountOutputTypeCountProductOrdersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ProductOrderWhereInput
  }


  /**
   * Count Type ProductVariationCountOutputType
   */

  export type ProductVariationCountOutputType = {
    ProductOrders: number
  }

  export type ProductVariationCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    ProductOrders?: boolean | ProductVariationCountOutputTypeCountProductOrdersArgs
  }

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

  /**
   * ProductVariationCountOutputType without action
   */
  export type ProductVariationCountOutputTypeCountProductOrdersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ProductOrderWhereInput
  }


  /**
   * Count Type VendorCountOutputType
   */

  export type VendorCountOutputType = {
    Hotels: number
    MitraPackages: number
  }

  export type VendorCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Hotels?: boolean | VendorCountOutputTypeCountHotelsArgs
    MitraPackages?: boolean | VendorCountOutputTypeCountMitraPackagesArgs
  }

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

  /**
   * VendorCountOutputType without action
   */
  export type VendorCountOutputTypeCountHotelsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: HotelWhereInput
  }

  /**
   * VendorCountOutputType without action
   */
  export type VendorCountOutputTypeCountMitraPackagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MitraPackageWhereInput
  }


  /**
   * Count Type HotelCountOutputType
   */

  export type HotelCountOutputType = {
    HotelPeriodPrices: number
    MitraPackagesMekkah: number
    MitraPackagesMadinah: number
  }

  export type HotelCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    HotelPeriodPrices?: boolean | HotelCountOutputTypeCountHotelPeriodPricesArgs
    MitraPackagesMekkah?: boolean | HotelCountOutputTypeCountMitraPackagesMekkahArgs
    MitraPackagesMadinah?: boolean | HotelCountOutputTypeCountMitraPackagesMadinahArgs
  }

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

  /**
   * HotelCountOutputType without action
   */
  export type HotelCountOutputTypeCountHotelPeriodPricesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: HotelPeriodPriceWhereInput
  }

  /**
   * HotelCountOutputType without action
   */
  export type HotelCountOutputTypeCountMitraPackagesMekkahArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MitraPackageWhereInput
  }

  /**
   * HotelCountOutputType without action
   */
  export type HotelCountOutputTypeCountMitraPackagesMadinahArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MitraPackageWhereInput
  }


  /**
   * Count Type PeriodCountOutputType
   */

  export type PeriodCountOutputType = {
    HotelPeriodPrices: number
    MitraPackages: number
  }

  export type PeriodCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    HotelPeriodPrices?: boolean | PeriodCountOutputTypeCountHotelPeriodPricesArgs
    MitraPackages?: boolean | PeriodCountOutputTypeCountMitraPackagesArgs
  }

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

  /**
   * PeriodCountOutputType without action
   */
  export type PeriodCountOutputTypeCountHotelPeriodPricesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: HotelPeriodPriceWhereInput
  }

  /**
   * PeriodCountOutputType without action
   */
  export type PeriodCountOutputTypeCountMitraPackagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MitraPackageWhereInput
  }


  /**
   * Count Type AirlineCountOutputType
   */

  export type AirlineCountOutputType = {
    MitraPackages: number
  }

  export type AirlineCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    MitraPackages?: boolean | AirlineCountOutputTypeCountMitraPackagesArgs
  }

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

  /**
   * AirlineCountOutputType without action
   */
  export type AirlineCountOutputTypeCountMitraPackagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MitraPackageWhereInput
  }


  /**
   * Count Type VisaCountOutputType
   */

  export type VisaCountOutputType = {
    MitraPackages: number
  }

  export type VisaCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    MitraPackages?: boolean | VisaCountOutputTypeCountMitraPackagesArgs
  }

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

  /**
   * VisaCountOutputType without action
   */
  export type VisaCountOutputTypeCountMitraPackagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MitraPackageWhereInput
  }


  /**
   * Count Type TransportationCountOutputType
   */

  export type TransportationCountOutputType = {
    MitraPackage: number
  }

  export type TransportationCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    MitraPackage?: boolean | TransportationCountOutputTypeCountMitraPackageArgs
  }

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

  /**
   * TransportationCountOutputType without action
   */
  export type TransportationCountOutputTypeCountMitraPackageArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MitraPackageWhereInput
  }


  /**
   * Count Type MuthawifCountOutputType
   */

  export type MuthawifCountOutputType = {
    MitraPackages: number
  }

  export type MuthawifCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    MitraPackages?: boolean | MuthawifCountOutputTypeCountMitraPackagesArgs
  }

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

  /**
   * MuthawifCountOutputType without action
   */
  export type MuthawifCountOutputTypeCountMitraPackagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MitraPackageWhereInput
  }


  /**
   * Count Type HandlingSaudiCountOutputType
   */

  export type HandlingSaudiCountOutputType = {
    MitraPackages: number
  }

  export type HandlingSaudiCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    MitraPackages?: boolean | HandlingSaudiCountOutputTypeCountMitraPackagesArgs
  }

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

  /**
   * HandlingSaudiCountOutputType without action
   */
  export type HandlingSaudiCountOutputTypeCountMitraPackagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MitraPackageWhereInput
  }


  /**
   * Count Type HandlingDomesticCountOutputType
   */

  export type HandlingDomesticCountOutputType = {
    MitraPackages: number
  }

  export type HandlingDomesticCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    MitraPackages?: boolean | HandlingDomesticCountOutputTypeCountMitraPackagesArgs
  }

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

  /**
   * HandlingDomesticCountOutputType without action
   */
  export type HandlingDomesticCountOutputTypeCountMitraPackagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MitraPackageWhereInput
  }


  /**
   * Count Type SiskopatuhCountOutputType
   */

  export type SiskopatuhCountOutputType = {
    MitraPackages: number
  }

  export type SiskopatuhCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    MitraPackages?: boolean | SiskopatuhCountOutputTypeCountMitraPackagesArgs
  }

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

  /**
   * SiskopatuhCountOutputType without action
   */
  export type SiskopatuhCountOutputTypeCountMitraPackagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MitraPackageWhereInput
  }


  /**
   * Count Type EquipmentCountOutputType
   */

  export type EquipmentCountOutputType = {
    MitraPackages: number
  }

  export type EquipmentCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    MitraPackages?: boolean | EquipmentCountOutputTypeCountMitraPackagesArgs
  }

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

  /**
   * EquipmentCountOutputType without action
   */
  export type EquipmentCountOutputTypeCountMitraPackagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MitraPackageWhereInput
  }


  /**
   * Count Type TourPlusCountOutputType
   */

  export type TourPlusCountOutputType = {
    MitraPackages: number
  }

  export type TourPlusCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    MitraPackages?: boolean | TourPlusCountOutputTypeCountMitraPackagesArgs
  }

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

  /**
   * TourPlusCountOutputType without action
   */
  export type TourPlusCountOutputTypeCountMitraPackagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MitraPackageWhereInput
  }


  /**
   * Count Type ManasikCountOutputType
   */

  export type ManasikCountOutputType = {
    MitraPackages: number
  }

  export type ManasikCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    MitraPackages?: boolean | ManasikCountOutputTypeCountMitraPackagesArgs
  }

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

  /**
   * ManasikCountOutputType without action
   */
  export type ManasikCountOutputTypeCountMitraPackagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MitraPackageWhereInput
  }


  /**
   * Count Type MitraPackageCountOutputType
   */

  export type MitraPackageCountOutputType = {
    MitraPackageOrders: number
  }

  export type MitraPackageCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    MitraPackageOrders?: boolean | MitraPackageCountOutputTypeCountMitraPackageOrdersArgs
  }

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

  /**
   * MitraPackageCountOutputType without action
   */
  export type MitraPackageCountOutputTypeCountMitraPackageOrdersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MitraPackageOrderWhereInput
  }


  /**
   * Count Type FooterCountOutputType
   */

  export type FooterCountOutputType = {
    FooterItem: number
  }

  export type FooterCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    FooterItem?: boolean | FooterCountOutputTypeCountFooterItemArgs
  }

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

  /**
   * FooterCountOutputType without action
   */
  export type FooterCountOutputTypeCountFooterItemArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: FooterItemWhereInput
  }


  /**
   * Models
   */

  /**
   * Model User
   */

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

  export type UserMinAggregateOutputType = {
    id: string | null
    email: string | null
    full_name: string | null
    password: string | null
    whatsapp_number: string | null
    role: $Enums.Role | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type UserMaxAggregateOutputType = {
    id: string | null
    email: string | null
    full_name: string | null
    password: string | null
    whatsapp_number: string | null
    role: $Enums.Role | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type UserCountAggregateOutputType = {
    id: number
    email: number
    full_name: number
    password: number
    whatsapp_number: number
    role: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type UserMinAggregateInputType = {
    id?: true
    email?: true
    full_name?: true
    password?: true
    whatsapp_number?: true
    role?: true
    created_at?: true
    updated_at?: true
  }

  export type UserMaxAggregateInputType = {
    id?: true
    email?: true
    full_name?: true
    password?: true
    whatsapp_number?: true
    role?: true
    created_at?: true
    updated_at?: true
  }

  export type UserCountAggregateInputType = {
    id?: true
    email?: true
    full_name?: true
    password?: true
    whatsapp_number?: true
    role?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

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

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




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

  export type UserGroupByOutputType = {
    id: string
    email: string
    full_name: string
    password: string
    whatsapp_number: string
    role: $Enums.Role
    created_at: Date
    updated_at: Date
    _count: UserCountAggregateOutputType | null
    _min: UserMinAggregateOutputType | null
    _max: UserMaxAggregateOutputType | null
  }

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


  export type UserSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    email?: boolean
    full_name?: boolean
    password?: boolean
    whatsapp_number?: boolean
    role?: boolean
    created_at?: boolean
    updated_at?: boolean
    ProductOrders?: boolean | User$ProductOrdersArgs<ExtArgs>
    MitraPackageOrder?: boolean | User$MitraPackageOrderArgs<ExtArgs>
    MitraRequest?: boolean | User$MitraRequestArgs<ExtArgs>
    _count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["user"]>


  export type UserSelectScalar = {
    id?: boolean
    email?: boolean
    full_name?: boolean
    password?: boolean
    whatsapp_number?: boolean
    role?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type UserInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    ProductOrders?: boolean | User$ProductOrdersArgs<ExtArgs>
    MitraPackageOrder?: boolean | User$MitraPackageOrderArgs<ExtArgs>
    MitraRequest?: boolean | User$MitraRequestArgs<ExtArgs>
    _count?: boolean | UserCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $UserPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "User"
    objects: {
      ProductOrders: Prisma.$ProductOrderPayload<ExtArgs>[]
      MitraPackageOrder: Prisma.$MitraPackageOrderPayload<ExtArgs>[]
      MitraRequest: Prisma.$MitraRequestPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      email: string
      full_name: string
      password: string
      whatsapp_number: string
      role: $Enums.Role
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["user"]>
    composites: {}
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the User model
   */ 
  interface UserFieldRefs {
    readonly id: FieldRef<"User", 'String'>
    readonly email: FieldRef<"User", 'String'>
    readonly full_name: FieldRef<"User", 'String'>
    readonly password: FieldRef<"User", 'String'>
    readonly whatsapp_number: FieldRef<"User", 'String'>
    readonly role: FieldRef<"User", 'Role'>
    readonly created_at: FieldRef<"User", 'DateTime'>
    readonly updated_at: FieldRef<"User", 'DateTime'>
  }
    

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

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

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

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

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

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

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

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

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

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

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

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

  /**
   * User.ProductOrders
   */
  export type User$ProductOrdersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductOrder
     */
    select?: ProductOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductOrderInclude<ExtArgs> | null
    where?: ProductOrderWhereInput
    orderBy?: ProductOrderOrderByWithRelationInput | ProductOrderOrderByWithRelationInput[]
    cursor?: ProductOrderWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ProductOrderScalarFieldEnum | ProductOrderScalarFieldEnum[]
  }

  /**
   * User.MitraPackageOrder
   */
  export type User$MitraPackageOrderArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackageOrder
     */
    select?: MitraPackageOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageOrderInclude<ExtArgs> | null
    where?: MitraPackageOrderWhereInput
    orderBy?: MitraPackageOrderOrderByWithRelationInput | MitraPackageOrderOrderByWithRelationInput[]
    cursor?: MitraPackageOrderWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MitraPackageOrderScalarFieldEnum | MitraPackageOrderScalarFieldEnum[]
  }

  /**
   * User.MitraRequest
   */
  export type User$MitraRequestArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraRequest
     */
    select?: MitraRequestSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraRequestInclude<ExtArgs> | null
    where?: MitraRequestWhereInput
    orderBy?: MitraRequestOrderByWithRelationInput | MitraRequestOrderByWithRelationInput[]
    cursor?: MitraRequestWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MitraRequestScalarFieldEnum | MitraRequestScalarFieldEnum[]
  }

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


  /**
   * Model MitraRequest
   */

  export type AggregateMitraRequest = {
    _count: MitraRequestCountAggregateOutputType | null
    _avg: MitraRequestAvgAggregateOutputType | null
    _sum: MitraRequestSumAggregateOutputType | null
    _min: MitraRequestMinAggregateOutputType | null
    _max: MitraRequestMaxAggregateOutputType | null
  }

  export type MitraRequestAvgAggregateOutputType = {
    upgrade_amount: Decimal | null
  }

  export type MitraRequestSumAggregateOutputType = {
    upgrade_amount: Decimal | null
  }

  export type MitraRequestMinAggregateOutputType = {
    id: string | null
    user_id: string | null
    ktp: string | null
    upgrade_amount: Decimal | null
    payment_proof: string | null
    status: $Enums.RequestStatus | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type MitraRequestMaxAggregateOutputType = {
    id: string | null
    user_id: string | null
    ktp: string | null
    upgrade_amount: Decimal | null
    payment_proof: string | null
    status: $Enums.RequestStatus | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type MitraRequestCountAggregateOutputType = {
    id: number
    user_id: number
    ktp: number
    upgrade_amount: number
    payment_proof: number
    status: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type MitraRequestAvgAggregateInputType = {
    upgrade_amount?: true
  }

  export type MitraRequestSumAggregateInputType = {
    upgrade_amount?: true
  }

  export type MitraRequestMinAggregateInputType = {
    id?: true
    user_id?: true
    ktp?: true
    upgrade_amount?: true
    payment_proof?: true
    status?: true
    created_at?: true
    updated_at?: true
  }

  export type MitraRequestMaxAggregateInputType = {
    id?: true
    user_id?: true
    ktp?: true
    upgrade_amount?: true
    payment_proof?: true
    status?: true
    created_at?: true
    updated_at?: true
  }

  export type MitraRequestCountAggregateInputType = {
    id?: true
    user_id?: true
    ktp?: true
    upgrade_amount?: true
    payment_proof?: true
    status?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type MitraRequestAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which MitraRequest to aggregate.
     */
    where?: MitraRequestWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MitraRequests to fetch.
     */
    orderBy?: MitraRequestOrderByWithRelationInput | MitraRequestOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: MitraRequestWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MitraRequests from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` MitraRequests.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned MitraRequests
    **/
    _count?: true | MitraRequestCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: MitraRequestAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: MitraRequestSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: MitraRequestMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: MitraRequestMaxAggregateInputType
  }

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




  export type MitraRequestGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MitraRequestWhereInput
    orderBy?: MitraRequestOrderByWithAggregationInput | MitraRequestOrderByWithAggregationInput[]
    by: MitraRequestScalarFieldEnum[] | MitraRequestScalarFieldEnum
    having?: MitraRequestScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: MitraRequestCountAggregateInputType | true
    _avg?: MitraRequestAvgAggregateInputType
    _sum?: MitraRequestSumAggregateInputType
    _min?: MitraRequestMinAggregateInputType
    _max?: MitraRequestMaxAggregateInputType
  }

  export type MitraRequestGroupByOutputType = {
    id: string
    user_id: string
    ktp: string
    upgrade_amount: Decimal
    payment_proof: string
    status: $Enums.RequestStatus
    created_at: Date
    updated_at: Date
    _count: MitraRequestCountAggregateOutputType | null
    _avg: MitraRequestAvgAggregateOutputType | null
    _sum: MitraRequestSumAggregateOutputType | null
    _min: MitraRequestMinAggregateOutputType | null
    _max: MitraRequestMaxAggregateOutputType | null
  }

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


  export type MitraRequestSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    user_id?: boolean
    ktp?: boolean
    upgrade_amount?: boolean
    payment_proof?: boolean
    status?: boolean
    created_at?: boolean
    updated_at?: boolean
    User?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["mitraRequest"]>


  export type MitraRequestSelectScalar = {
    id?: boolean
    user_id?: boolean
    ktp?: boolean
    upgrade_amount?: boolean
    payment_proof?: boolean
    status?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type MitraRequestInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    User?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $MitraRequestPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "MitraRequest"
    objects: {
      User: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      user_id: string
      ktp: string
      upgrade_amount: Prisma.Decimal
      payment_proof: string
      status: $Enums.RequestStatus
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["mitraRequest"]>
    composites: {}
  }

  type MitraRequestGetPayload<S extends boolean | null | undefined | MitraRequestDefaultArgs> = $Result.GetResult<Prisma.$MitraRequestPayload, S>

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

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

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

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

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

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

    /**
     * Create a MitraRequest.
     * @param {MitraRequestCreateArgs} args - Arguments to create a MitraRequest.
     * @example
     * // Create one MitraRequest
     * const MitraRequest = await prisma.mitraRequest.create({
     *   data: {
     *     // ... data to create a MitraRequest
     *   }
     * })
     * 
     */
    create<T extends MitraRequestCreateArgs>(args: SelectSubset<T, MitraRequestCreateArgs<ExtArgs>>): Prisma__MitraRequestClient<$Result.GetResult<Prisma.$MitraRequestPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Delete a MitraRequest.
     * @param {MitraRequestDeleteArgs} args - Arguments to delete one MitraRequest.
     * @example
     * // Delete one MitraRequest
     * const MitraRequest = await prisma.mitraRequest.delete({
     *   where: {
     *     // ... filter to delete one MitraRequest
     *   }
     * })
     * 
     */
    delete<T extends MitraRequestDeleteArgs>(args: SelectSubset<T, MitraRequestDeleteArgs<ExtArgs>>): Prisma__MitraRequestClient<$Result.GetResult<Prisma.$MitraRequestPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

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




  /**
   * Fields of the MitraRequest model
   */ 
  interface MitraRequestFieldRefs {
    readonly id: FieldRef<"MitraRequest", 'String'>
    readonly user_id: FieldRef<"MitraRequest", 'String'>
    readonly ktp: FieldRef<"MitraRequest", 'String'>
    readonly upgrade_amount: FieldRef<"MitraRequest", 'Decimal'>
    readonly payment_proof: FieldRef<"MitraRequest", 'String'>
    readonly status: FieldRef<"MitraRequest", 'RequestStatus'>
    readonly created_at: FieldRef<"MitraRequest", 'DateTime'>
    readonly updated_at: FieldRef<"MitraRequest", 'DateTime'>
  }
    

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

  /**
   * MitraRequest findUniqueOrThrow
   */
  export type MitraRequestFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraRequest
     */
    select?: MitraRequestSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraRequestInclude<ExtArgs> | null
    /**
     * Filter, which MitraRequest to fetch.
     */
    where: MitraRequestWhereUniqueInput
  }

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

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

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

  /**
   * MitraRequest create
   */
  export type MitraRequestCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraRequest
     */
    select?: MitraRequestSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraRequestInclude<ExtArgs> | null
    /**
     * The data needed to create a MitraRequest.
     */
    data: XOR<MitraRequestCreateInput, MitraRequestUncheckedCreateInput>
  }

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

  /**
   * MitraRequest update
   */
  export type MitraRequestUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraRequest
     */
    select?: MitraRequestSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraRequestInclude<ExtArgs> | null
    /**
     * The data needed to update a MitraRequest.
     */
    data: XOR<MitraRequestUpdateInput, MitraRequestUncheckedUpdateInput>
    /**
     * Choose, which MitraRequest to update.
     */
    where: MitraRequestWhereUniqueInput
  }

  /**
   * MitraRequest updateMany
   */
  export type MitraRequestUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update MitraRequests.
     */
    data: XOR<MitraRequestUpdateManyMutationInput, MitraRequestUncheckedUpdateManyInput>
    /**
     * Filter which MitraRequests to update
     */
    where?: MitraRequestWhereInput
  }

  /**
   * MitraRequest upsert
   */
  export type MitraRequestUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraRequest
     */
    select?: MitraRequestSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraRequestInclude<ExtArgs> | null
    /**
     * The filter to search for the MitraRequest to update in case it exists.
     */
    where: MitraRequestWhereUniqueInput
    /**
     * In case the MitraRequest found by the `where` argument doesn't exist, create a new MitraRequest with this data.
     */
    create: XOR<MitraRequestCreateInput, MitraRequestUncheckedCreateInput>
    /**
     * In case the MitraRequest was found with the provided `where` argument, update it with this data.
     */
    update: XOR<MitraRequestUpdateInput, MitraRequestUncheckedUpdateInput>
  }

  /**
   * MitraRequest delete
   */
  export type MitraRequestDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraRequest
     */
    select?: MitraRequestSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraRequestInclude<ExtArgs> | null
    /**
     * Filter which MitraRequest to delete.
     */
    where: MitraRequestWhereUniqueInput
  }

  /**
   * MitraRequest deleteMany
   */
  export type MitraRequestDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which MitraRequests to delete
     */
    where?: MitraRequestWhereInput
  }

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


  /**
   * Model UserPackage
   */

  export type AggregateUserPackage = {
    _count: UserPackageCountAggregateOutputType | null
    _avg: UserPackageAvgAggregateOutputType | null
    _sum: UserPackageSumAggregateOutputType | null
    _min: UserPackageMinAggregateOutputType | null
    _max: UserPackageMaxAggregateOutputType | null
  }

  export type UserPackageAvgAggregateOutputType = {
    number_of_pax: number | null
    travel_duration: number | null
    mekkah_duration: number | null
    madinah_duration: number | null
    per_pax_price: Decimal | null
    total_price: Decimal | null
  }

  export type UserPackageSumAggregateOutputType = {
    number_of_pax: number | null
    travel_duration: number | null
    mekkah_duration: number | null
    madinah_duration: number | null
    per_pax_price: Decimal | null
    total_price: Decimal | null
  }

  export type UserPackageMinAggregateOutputType = {
    id: string | null
    transportation_id: string | null
    flight_id: string | null
    hotel_mekkah_id: string | null
    hotel_madinah_id: string | null
    muthawif_id: string | null
    handling_id: string | null
    number_of_pax: number | null
    travel_duration: number | null
    mekkah_duration: number | null
    madinah_duration: number | null
    per_pax_price: Decimal | null
    total_price: Decimal | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type UserPackageMaxAggregateOutputType = {
    id: string | null
    transportation_id: string | null
    flight_id: string | null
    hotel_mekkah_id: string | null
    hotel_madinah_id: string | null
    muthawif_id: string | null
    handling_id: string | null
    number_of_pax: number | null
    travel_duration: number | null
    mekkah_duration: number | null
    madinah_duration: number | null
    per_pax_price: Decimal | null
    total_price: Decimal | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type UserPackageCountAggregateOutputType = {
    id: number
    transportation_id: number
    flight_id: number
    hotel_mekkah_id: number
    hotel_madinah_id: number
    muthawif_id: number
    handling_id: number
    number_of_pax: number
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    per_pax_price: number
    total_price: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type UserPackageAvgAggregateInputType = {
    number_of_pax?: true
    travel_duration?: true
    mekkah_duration?: true
    madinah_duration?: true
    per_pax_price?: true
    total_price?: true
  }

  export type UserPackageSumAggregateInputType = {
    number_of_pax?: true
    travel_duration?: true
    mekkah_duration?: true
    madinah_duration?: true
    per_pax_price?: true
    total_price?: true
  }

  export type UserPackageMinAggregateInputType = {
    id?: true
    transportation_id?: true
    flight_id?: true
    hotel_mekkah_id?: true
    hotel_madinah_id?: true
    muthawif_id?: true
    handling_id?: true
    number_of_pax?: true
    travel_duration?: true
    mekkah_duration?: true
    madinah_duration?: true
    per_pax_price?: true
    total_price?: true
    created_at?: true
    updated_at?: true
  }

  export type UserPackageMaxAggregateInputType = {
    id?: true
    transportation_id?: true
    flight_id?: true
    hotel_mekkah_id?: true
    hotel_madinah_id?: true
    muthawif_id?: true
    handling_id?: true
    number_of_pax?: true
    travel_duration?: true
    mekkah_duration?: true
    madinah_duration?: true
    per_pax_price?: true
    total_price?: true
    created_at?: true
    updated_at?: true
  }

  export type UserPackageCountAggregateInputType = {
    id?: true
    transportation_id?: true
    flight_id?: true
    hotel_mekkah_id?: true
    hotel_madinah_id?: true
    muthawif_id?: true
    handling_id?: true
    number_of_pax?: true
    travel_duration?: true
    mekkah_duration?: true
    madinah_duration?: true
    per_pax_price?: true
    total_price?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type UserPackageAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which UserPackage to aggregate.
     */
    where?: UserPackageWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of UserPackages to fetch.
     */
    orderBy?: UserPackageOrderByWithRelationInput | UserPackageOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: UserPackageWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` UserPackages from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` UserPackages.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned UserPackages
    **/
    _count?: true | UserPackageCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: UserPackageAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: UserPackageSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: UserPackageMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: UserPackageMaxAggregateInputType
  }

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




  export type UserPackageGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: UserPackageWhereInput
    orderBy?: UserPackageOrderByWithAggregationInput | UserPackageOrderByWithAggregationInput[]
    by: UserPackageScalarFieldEnum[] | UserPackageScalarFieldEnum
    having?: UserPackageScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: UserPackageCountAggregateInputType | true
    _avg?: UserPackageAvgAggregateInputType
    _sum?: UserPackageSumAggregateInputType
    _min?: UserPackageMinAggregateInputType
    _max?: UserPackageMaxAggregateInputType
  }

  export type UserPackageGroupByOutputType = {
    id: string
    transportation_id: string | null
    flight_id: string | null
    hotel_mekkah_id: string | null
    hotel_madinah_id: string | null
    muthawif_id: string | null
    handling_id: string | null
    number_of_pax: number
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    per_pax_price: Decimal
    total_price: Decimal
    created_at: Date
    updated_at: Date
    _count: UserPackageCountAggregateOutputType | null
    _avg: UserPackageAvgAggregateOutputType | null
    _sum: UserPackageSumAggregateOutputType | null
    _min: UserPackageMinAggregateOutputType | null
    _max: UserPackageMaxAggregateOutputType | null
  }

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


  export type UserPackageSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    transportation_id?: boolean
    flight_id?: boolean
    hotel_mekkah_id?: boolean
    hotel_madinah_id?: boolean
    muthawif_id?: boolean
    handling_id?: boolean
    number_of_pax?: boolean
    travel_duration?: boolean
    mekkah_duration?: boolean
    madinah_duration?: boolean
    per_pax_price?: boolean
    total_price?: boolean
    created_at?: boolean
    updated_at?: boolean
    UserPackageOrders?: boolean | UserPackage$UserPackageOrdersArgs<ExtArgs>
    transportation?: boolean | UserPackage$transportationArgs<ExtArgs>
    flight?: boolean | UserPackage$flightArgs<ExtArgs>
    hotelMekkah?: boolean | UserPackage$hotelMekkahArgs<ExtArgs>
    hotelMadinah?: boolean | UserPackage$hotelMadinahArgs<ExtArgs>
    muthawif?: boolean | UserPackage$muthawifArgs<ExtArgs>
    handling?: boolean | UserPackage$handlingArgs<ExtArgs>
    _count?: boolean | UserPackageCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["userPackage"]>


  export type UserPackageSelectScalar = {
    id?: boolean
    transportation_id?: boolean
    flight_id?: boolean
    hotel_mekkah_id?: boolean
    hotel_madinah_id?: boolean
    muthawif_id?: boolean
    handling_id?: boolean
    number_of_pax?: boolean
    travel_duration?: boolean
    mekkah_duration?: boolean
    madinah_duration?: boolean
    per_pax_price?: boolean
    total_price?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type UserPackageInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    UserPackageOrders?: boolean | UserPackage$UserPackageOrdersArgs<ExtArgs>
    transportation?: boolean | UserPackage$transportationArgs<ExtArgs>
    flight?: boolean | UserPackage$flightArgs<ExtArgs>
    hotelMekkah?: boolean | UserPackage$hotelMekkahArgs<ExtArgs>
    hotelMadinah?: boolean | UserPackage$hotelMadinahArgs<ExtArgs>
    muthawif?: boolean | UserPackage$muthawifArgs<ExtArgs>
    handling?: boolean | UserPackage$handlingArgs<ExtArgs>
    _count?: boolean | UserPackageCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $UserPackagePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "UserPackage"
    objects: {
      UserPackageOrders: Prisma.$UserPackageOrderPayload<ExtArgs>[]
      transportation: Prisma.$UserPackageOptionPayload<ExtArgs> | null
      flight: Prisma.$UserPackageOptionPayload<ExtArgs> | null
      hotelMekkah: Prisma.$UserPackageOptionPayload<ExtArgs> | null
      hotelMadinah: Prisma.$UserPackageOptionPayload<ExtArgs> | null
      muthawif: Prisma.$UserPackageOptionPayload<ExtArgs> | null
      handling: Prisma.$UserPackageOptionPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      transportation_id: string | null
      flight_id: string | null
      hotel_mekkah_id: string | null
      hotel_madinah_id: string | null
      muthawif_id: string | null
      handling_id: string | null
      number_of_pax: number
      travel_duration: number
      mekkah_duration: number
      madinah_duration: number
      per_pax_price: Prisma.Decimal
      total_price: Prisma.Decimal
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["userPackage"]>
    composites: {}
  }

  type UserPackageGetPayload<S extends boolean | null | undefined | UserPackageDefaultArgs> = $Result.GetResult<Prisma.$UserPackagePayload, S>

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

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

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

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

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

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

    /**
     * Create a UserPackage.
     * @param {UserPackageCreateArgs} args - Arguments to create a UserPackage.
     * @example
     * // Create one UserPackage
     * const UserPackage = await prisma.userPackage.create({
     *   data: {
     *     // ... data to create a UserPackage
     *   }
     * })
     * 
     */
    create<T extends UserPackageCreateArgs>(args: SelectSubset<T, UserPackageCreateArgs<ExtArgs>>): Prisma__UserPackageClient<$Result.GetResult<Prisma.$UserPackagePayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Delete a UserPackage.
     * @param {UserPackageDeleteArgs} args - Arguments to delete one UserPackage.
     * @example
     * // Delete one UserPackage
     * const UserPackage = await prisma.userPackage.delete({
     *   where: {
     *     // ... filter to delete one UserPackage
     *   }
     * })
     * 
     */
    delete<T extends UserPackageDeleteArgs>(args: SelectSubset<T, UserPackageDeleteArgs<ExtArgs>>): Prisma__UserPackageClient<$Result.GetResult<Prisma.$UserPackagePayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for UserPackage.
   * 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__UserPackageClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    UserPackageOrders<T extends UserPackage$UserPackageOrdersArgs<ExtArgs> = {}>(args?: Subset<T, UserPackage$UserPackageOrdersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPackageOrderPayload<ExtArgs>, T, "findMany"> | Null>
    transportation<T extends UserPackage$transportationArgs<ExtArgs> = {}>(args?: Subset<T, UserPackage$transportationArgs<ExtArgs>>): Prisma__UserPackageOptionClient<$Result.GetResult<Prisma.$UserPackageOptionPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    flight<T extends UserPackage$flightArgs<ExtArgs> = {}>(args?: Subset<T, UserPackage$flightArgs<ExtArgs>>): Prisma__UserPackageOptionClient<$Result.GetResult<Prisma.$UserPackageOptionPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    hotelMekkah<T extends UserPackage$hotelMekkahArgs<ExtArgs> = {}>(args?: Subset<T, UserPackage$hotelMekkahArgs<ExtArgs>>): Prisma__UserPackageOptionClient<$Result.GetResult<Prisma.$UserPackageOptionPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    hotelMadinah<T extends UserPackage$hotelMadinahArgs<ExtArgs> = {}>(args?: Subset<T, UserPackage$hotelMadinahArgs<ExtArgs>>): Prisma__UserPackageOptionClient<$Result.GetResult<Prisma.$UserPackageOptionPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    muthawif<T extends UserPackage$muthawifArgs<ExtArgs> = {}>(args?: Subset<T, UserPackage$muthawifArgs<ExtArgs>>): Prisma__UserPackageOptionClient<$Result.GetResult<Prisma.$UserPackageOptionPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    handling<T extends UserPackage$handlingArgs<ExtArgs> = {}>(args?: Subset<T, UserPackage$handlingArgs<ExtArgs>>): Prisma__UserPackageOptionClient<$Result.GetResult<Prisma.$UserPackageOptionPayload<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 UserPackage model
   */ 
  interface UserPackageFieldRefs {
    readonly id: FieldRef<"UserPackage", 'String'>
    readonly transportation_id: FieldRef<"UserPackage", 'String'>
    readonly flight_id: FieldRef<"UserPackage", 'String'>
    readonly hotel_mekkah_id: FieldRef<"UserPackage", 'String'>
    readonly hotel_madinah_id: FieldRef<"UserPackage", 'String'>
    readonly muthawif_id: FieldRef<"UserPackage", 'String'>
    readonly handling_id: FieldRef<"UserPackage", 'String'>
    readonly number_of_pax: FieldRef<"UserPackage", 'Int'>
    readonly travel_duration: FieldRef<"UserPackage", 'Int'>
    readonly mekkah_duration: FieldRef<"UserPackage", 'Int'>
    readonly madinah_duration: FieldRef<"UserPackage", 'Int'>
    readonly per_pax_price: FieldRef<"UserPackage", 'Decimal'>
    readonly total_price: FieldRef<"UserPackage", 'Decimal'>
    readonly created_at: FieldRef<"UserPackage", 'DateTime'>
    readonly updated_at: FieldRef<"UserPackage", 'DateTime'>
  }
    

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

  /**
   * UserPackage findUniqueOrThrow
   */
  export type UserPackageFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackage
     */
    select?: UserPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageInclude<ExtArgs> | null
    /**
     * Filter, which UserPackage to fetch.
     */
    where: UserPackageWhereUniqueInput
  }

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

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

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

  /**
   * UserPackage create
   */
  export type UserPackageCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackage
     */
    select?: UserPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageInclude<ExtArgs> | null
    /**
     * The data needed to create a UserPackage.
     */
    data: XOR<UserPackageCreateInput, UserPackageUncheckedCreateInput>
  }

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

  /**
   * UserPackage update
   */
  export type UserPackageUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackage
     */
    select?: UserPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageInclude<ExtArgs> | null
    /**
     * The data needed to update a UserPackage.
     */
    data: XOR<UserPackageUpdateInput, UserPackageUncheckedUpdateInput>
    /**
     * Choose, which UserPackage to update.
     */
    where: UserPackageWhereUniqueInput
  }

  /**
   * UserPackage updateMany
   */
  export type UserPackageUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update UserPackages.
     */
    data: XOR<UserPackageUpdateManyMutationInput, UserPackageUncheckedUpdateManyInput>
    /**
     * Filter which UserPackages to update
     */
    where?: UserPackageWhereInput
  }

  /**
   * UserPackage upsert
   */
  export type UserPackageUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackage
     */
    select?: UserPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageInclude<ExtArgs> | null
    /**
     * The filter to search for the UserPackage to update in case it exists.
     */
    where: UserPackageWhereUniqueInput
    /**
     * In case the UserPackage found by the `where` argument doesn't exist, create a new UserPackage with this data.
     */
    create: XOR<UserPackageCreateInput, UserPackageUncheckedCreateInput>
    /**
     * In case the UserPackage was found with the provided `where` argument, update it with this data.
     */
    update: XOR<UserPackageUpdateInput, UserPackageUncheckedUpdateInput>
  }

  /**
   * UserPackage delete
   */
  export type UserPackageDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackage
     */
    select?: UserPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageInclude<ExtArgs> | null
    /**
     * Filter which UserPackage to delete.
     */
    where: UserPackageWhereUniqueInput
  }

  /**
   * UserPackage deleteMany
   */
  export type UserPackageDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which UserPackages to delete
     */
    where?: UserPackageWhereInput
  }

  /**
   * UserPackage.UserPackageOrders
   */
  export type UserPackage$UserPackageOrdersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackageOrder
     */
    select?: UserPackageOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageOrderInclude<ExtArgs> | null
    where?: UserPackageOrderWhereInput
    orderBy?: UserPackageOrderOrderByWithRelationInput | UserPackageOrderOrderByWithRelationInput[]
    cursor?: UserPackageOrderWhereUniqueInput
    take?: number
    skip?: number
    distinct?: UserPackageOrderScalarFieldEnum | UserPackageOrderScalarFieldEnum[]
  }

  /**
   * UserPackage.transportation
   */
  export type UserPackage$transportationArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackageOption
     */
    select?: UserPackageOptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageOptionInclude<ExtArgs> | null
    where?: UserPackageOptionWhereInput
  }

  /**
   * UserPackage.flight
   */
  export type UserPackage$flightArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackageOption
     */
    select?: UserPackageOptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageOptionInclude<ExtArgs> | null
    where?: UserPackageOptionWhereInput
  }

  /**
   * UserPackage.hotelMekkah
   */
  export type UserPackage$hotelMekkahArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackageOption
     */
    select?: UserPackageOptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageOptionInclude<ExtArgs> | null
    where?: UserPackageOptionWhereInput
  }

  /**
   * UserPackage.hotelMadinah
   */
  export type UserPackage$hotelMadinahArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackageOption
     */
    select?: UserPackageOptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageOptionInclude<ExtArgs> | null
    where?: UserPackageOptionWhereInput
  }

  /**
   * UserPackage.muthawif
   */
  export type UserPackage$muthawifArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackageOption
     */
    select?: UserPackageOptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageOptionInclude<ExtArgs> | null
    where?: UserPackageOptionWhereInput
  }

  /**
   * UserPackage.handling
   */
  export type UserPackage$handlingArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackageOption
     */
    select?: UserPackageOptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageOptionInclude<ExtArgs> | null
    where?: UserPackageOptionWhereInput
  }

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


  /**
   * Model PackageType
   */

  export type AggregatePackageType = {
    _count: PackageTypeCountAggregateOutputType | null
    _min: PackageTypeMinAggregateOutputType | null
    _max: PackageTypeMaxAggregateOutputType | null
  }

  export type PackageTypeMinAggregateOutputType = {
    id: string | null
    name: string | null
    is_public: boolean | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type PackageTypeMaxAggregateOutputType = {
    id: string | null
    name: string | null
    is_public: boolean | null
    created_at: Date | null
    updated_at: Date | null
  }

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


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

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

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

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

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




  export type PackageTypeGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PackageTypeWhereInput
    orderBy?: PackageTypeOrderByWithAggregationInput | PackageTypeOrderByWithAggregationInput[]
    by: PackageTypeScalarFieldEnum[] | PackageTypeScalarFieldEnum
    having?: PackageTypeScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: PackageTypeCountAggregateInputType | true
    _min?: PackageTypeMinAggregateInputType
    _max?: PackageTypeMaxAggregateInputType
  }

  export type PackageTypeGroupByOutputType = {
    id: string
    name: string
    is_public: boolean
    created_at: Date
    updated_at: Date
    _count: PackageTypeCountAggregateOutputType | null
    _min: PackageTypeMinAggregateOutputType | null
    _max: PackageTypeMaxAggregateOutputType | null
  }

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


  export type PackageTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    is_public?: boolean
    created_at?: boolean
    updated_at?: boolean
    UserPackageOptions?: boolean | PackageType$UserPackageOptionsArgs<ExtArgs>
    _count?: boolean | PackageTypeCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["packageType"]>


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

  export type PackageTypeInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    UserPackageOptions?: boolean | PackageType$UserPackageOptionsArgs<ExtArgs>
    _count?: boolean | PackageTypeCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $PackageTypePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "PackageType"
    objects: {
      UserPackageOptions: Prisma.$UserPackageOptionPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      is_public: boolean
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["packageType"]>
    composites: {}
  }

  type PackageTypeGetPayload<S extends boolean | null | undefined | PackageTypeDefaultArgs> = $Result.GetResult<Prisma.$PackageTypePayload, S>

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

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

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

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

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

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

    /**
     * Create a PackageType.
     * @param {PackageTypeCreateArgs} args - Arguments to create a PackageType.
     * @example
     * // Create one PackageType
     * const PackageType = await prisma.packageType.create({
     *   data: {
     *     // ... data to create a PackageType
     *   }
     * })
     * 
     */
    create<T extends PackageTypeCreateArgs>(args: SelectSubset<T, PackageTypeCreateArgs<ExtArgs>>): Prisma__PackageTypeClient<$Result.GetResult<Prisma.$PackageTypePayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Delete a PackageType.
     * @param {PackageTypeDeleteArgs} args - Arguments to delete one PackageType.
     * @example
     * // Delete one PackageType
     * const PackageType = await prisma.packageType.delete({
     *   where: {
     *     // ... filter to delete one PackageType
     *   }
     * })
     * 
     */
    delete<T extends PackageTypeDeleteArgs>(args: SelectSubset<T, PackageTypeDeleteArgs<ExtArgs>>): Prisma__PackageTypeClient<$Result.GetResult<Prisma.$PackageTypePayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for PackageType.
   * 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__PackageTypeClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    UserPackageOptions<T extends PackageType$UserPackageOptionsArgs<ExtArgs> = {}>(args?: Subset<T, PackageType$UserPackageOptionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPackageOptionPayload<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 PackageType model
   */ 
  interface PackageTypeFieldRefs {
    readonly id: FieldRef<"PackageType", 'String'>
    readonly name: FieldRef<"PackageType", 'String'>
    readonly is_public: FieldRef<"PackageType", 'Boolean'>
    readonly created_at: FieldRef<"PackageType", 'DateTime'>
    readonly updated_at: FieldRef<"PackageType", 'DateTime'>
  }
    

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

  /**
   * PackageType findUniqueOrThrow
   */
  export type PackageTypeFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PackageType
     */
    select?: PackageTypeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PackageTypeInclude<ExtArgs> | null
    /**
     * Filter, which PackageType to fetch.
     */
    where: PackageTypeWhereUniqueInput
  }

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

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

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

  /**
   * PackageType create
   */
  export type PackageTypeCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PackageType
     */
    select?: PackageTypeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PackageTypeInclude<ExtArgs> | null
    /**
     * The data needed to create a PackageType.
     */
    data: XOR<PackageTypeCreateInput, PackageTypeUncheckedCreateInput>
  }

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

  /**
   * PackageType update
   */
  export type PackageTypeUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PackageType
     */
    select?: PackageTypeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PackageTypeInclude<ExtArgs> | null
    /**
     * The data needed to update a PackageType.
     */
    data: XOR<PackageTypeUpdateInput, PackageTypeUncheckedUpdateInput>
    /**
     * Choose, which PackageType to update.
     */
    where: PackageTypeWhereUniqueInput
  }

  /**
   * PackageType updateMany
   */
  export type PackageTypeUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update PackageTypes.
     */
    data: XOR<PackageTypeUpdateManyMutationInput, PackageTypeUncheckedUpdateManyInput>
    /**
     * Filter which PackageTypes to update
     */
    where?: PackageTypeWhereInput
  }

  /**
   * PackageType upsert
   */
  export type PackageTypeUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PackageType
     */
    select?: PackageTypeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PackageTypeInclude<ExtArgs> | null
    /**
     * The filter to search for the PackageType to update in case it exists.
     */
    where: PackageTypeWhereUniqueInput
    /**
     * In case the PackageType found by the `where` argument doesn't exist, create a new PackageType with this data.
     */
    create: XOR<PackageTypeCreateInput, PackageTypeUncheckedCreateInput>
    /**
     * In case the PackageType was found with the provided `where` argument, update it with this data.
     */
    update: XOR<PackageTypeUpdateInput, PackageTypeUncheckedUpdateInput>
  }

  /**
   * PackageType delete
   */
  export type PackageTypeDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PackageType
     */
    select?: PackageTypeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PackageTypeInclude<ExtArgs> | null
    /**
     * Filter which PackageType to delete.
     */
    where: PackageTypeWhereUniqueInput
  }

  /**
   * PackageType deleteMany
   */
  export type PackageTypeDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which PackageTypes to delete
     */
    where?: PackageTypeWhereInput
  }

  /**
   * PackageType.UserPackageOptions
   */
  export type PackageType$UserPackageOptionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackageOption
     */
    select?: UserPackageOptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageOptionInclude<ExtArgs> | null
    where?: UserPackageOptionWhereInput
    orderBy?: UserPackageOptionOrderByWithRelationInput | UserPackageOptionOrderByWithRelationInput[]
    cursor?: UserPackageOptionWhereUniqueInput
    take?: number
    skip?: number
    distinct?: UserPackageOptionScalarFieldEnum | UserPackageOptionScalarFieldEnum[]
  }

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


  /**
   * Model UserPackageOption
   */

  export type AggregateUserPackageOption = {
    _count: UserPackageOptionCountAggregateOutputType | null
    _avg: UserPackageOptionAvgAggregateOutputType | null
    _sum: UserPackageOptionSumAggregateOutputType | null
    _min: UserPackageOptionMinAggregateOutputType | null
    _max: UserPackageOptionMaxAggregateOutputType | null
  }

  export type UserPackageOptionAvgAggregateOutputType = {
    price: Decimal | null
    order_number: number | null
  }

  export type UserPackageOptionSumAggregateOutputType = {
    price: Decimal | null
    order_number: number | null
  }

  export type UserPackageOptionMinAggregateOutputType = {
    id: string | null
    package_type_id: string | null
    name: string | null
    price: Decimal | null
    order_number: number | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type UserPackageOptionMaxAggregateOutputType = {
    id: string | null
    package_type_id: string | null
    name: string | null
    price: Decimal | null
    order_number: number | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type UserPackageOptionCountAggregateOutputType = {
    id: number
    package_type_id: number
    name: number
    price: number
    order_number: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type UserPackageOptionAvgAggregateInputType = {
    price?: true
    order_number?: true
  }

  export type UserPackageOptionSumAggregateInputType = {
    price?: true
    order_number?: true
  }

  export type UserPackageOptionMinAggregateInputType = {
    id?: true
    package_type_id?: true
    name?: true
    price?: true
    order_number?: true
    created_at?: true
    updated_at?: true
  }

  export type UserPackageOptionMaxAggregateInputType = {
    id?: true
    package_type_id?: true
    name?: true
    price?: true
    order_number?: true
    created_at?: true
    updated_at?: true
  }

  export type UserPackageOptionCountAggregateInputType = {
    id?: true
    package_type_id?: true
    name?: true
    price?: true
    order_number?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type UserPackageOptionAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which UserPackageOption to aggregate.
     */
    where?: UserPackageOptionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of UserPackageOptions to fetch.
     */
    orderBy?: UserPackageOptionOrderByWithRelationInput | UserPackageOptionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: UserPackageOptionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` UserPackageOptions from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` UserPackageOptions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned UserPackageOptions
    **/
    _count?: true | UserPackageOptionCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: UserPackageOptionAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: UserPackageOptionSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: UserPackageOptionMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: UserPackageOptionMaxAggregateInputType
  }

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




  export type UserPackageOptionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: UserPackageOptionWhereInput
    orderBy?: UserPackageOptionOrderByWithAggregationInput | UserPackageOptionOrderByWithAggregationInput[]
    by: UserPackageOptionScalarFieldEnum[] | UserPackageOptionScalarFieldEnum
    having?: UserPackageOptionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: UserPackageOptionCountAggregateInputType | true
    _avg?: UserPackageOptionAvgAggregateInputType
    _sum?: UserPackageOptionSumAggregateInputType
    _min?: UserPackageOptionMinAggregateInputType
    _max?: UserPackageOptionMaxAggregateInputType
  }

  export type UserPackageOptionGroupByOutputType = {
    id: string
    package_type_id: string
    name: string
    price: Decimal
    order_number: number
    created_at: Date
    updated_at: Date
    _count: UserPackageOptionCountAggregateOutputType | null
    _avg: UserPackageOptionAvgAggregateOutputType | null
    _sum: UserPackageOptionSumAggregateOutputType | null
    _min: UserPackageOptionMinAggregateOutputType | null
    _max: UserPackageOptionMaxAggregateOutputType | null
  }

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


  export type UserPackageOptionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    package_type_id?: boolean
    name?: boolean
    price?: boolean
    order_number?: boolean
    created_at?: boolean
    updated_at?: boolean
    transportations?: boolean | UserPackageOption$transportationsArgs<ExtArgs>
    flights?: boolean | UserPackageOption$flightsArgs<ExtArgs>
    hotelMekkahs?: boolean | UserPackageOption$hotelMekkahsArgs<ExtArgs>
    hotelMadinahs?: boolean | UserPackageOption$hotelMadinahsArgs<ExtArgs>
    muthawifs?: boolean | UserPackageOption$muthawifsArgs<ExtArgs>
    handlings?: boolean | UserPackageOption$handlingsArgs<ExtArgs>
    PackageType?: boolean | PackageTypeDefaultArgs<ExtArgs>
    _count?: boolean | UserPackageOptionCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["userPackageOption"]>


  export type UserPackageOptionSelectScalar = {
    id?: boolean
    package_type_id?: boolean
    name?: boolean
    price?: boolean
    order_number?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type UserPackageOptionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    transportations?: boolean | UserPackageOption$transportationsArgs<ExtArgs>
    flights?: boolean | UserPackageOption$flightsArgs<ExtArgs>
    hotelMekkahs?: boolean | UserPackageOption$hotelMekkahsArgs<ExtArgs>
    hotelMadinahs?: boolean | UserPackageOption$hotelMadinahsArgs<ExtArgs>
    muthawifs?: boolean | UserPackageOption$muthawifsArgs<ExtArgs>
    handlings?: boolean | UserPackageOption$handlingsArgs<ExtArgs>
    PackageType?: boolean | PackageTypeDefaultArgs<ExtArgs>
    _count?: boolean | UserPackageOptionCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $UserPackageOptionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "UserPackageOption"
    objects: {
      transportations: Prisma.$UserPackagePayload<ExtArgs>[]
      flights: Prisma.$UserPackagePayload<ExtArgs>[]
      hotelMekkahs: Prisma.$UserPackagePayload<ExtArgs>[]
      hotelMadinahs: Prisma.$UserPackagePayload<ExtArgs>[]
      muthawifs: Prisma.$UserPackagePayload<ExtArgs>[]
      handlings: Prisma.$UserPackagePayload<ExtArgs>[]
      PackageType: Prisma.$PackageTypePayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      package_type_id: string
      name: string
      price: Prisma.Decimal
      order_number: number
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["userPackageOption"]>
    composites: {}
  }

  type UserPackageOptionGetPayload<S extends boolean | null | undefined | UserPackageOptionDefaultArgs> = $Result.GetResult<Prisma.$UserPackageOptionPayload, S>

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

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

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

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

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

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

    /**
     * Create a UserPackageOption.
     * @param {UserPackageOptionCreateArgs} args - Arguments to create a UserPackageOption.
     * @example
     * // Create one UserPackageOption
     * const UserPackageOption = await prisma.userPackageOption.create({
     *   data: {
     *     // ... data to create a UserPackageOption
     *   }
     * })
     * 
     */
    create<T extends UserPackageOptionCreateArgs>(args: SelectSubset<T, UserPackageOptionCreateArgs<ExtArgs>>): Prisma__UserPackageOptionClient<$Result.GetResult<Prisma.$UserPackageOptionPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Delete a UserPackageOption.
     * @param {UserPackageOptionDeleteArgs} args - Arguments to delete one UserPackageOption.
     * @example
     * // Delete one UserPackageOption
     * const UserPackageOption = await prisma.userPackageOption.delete({
     *   where: {
     *     // ... filter to delete one UserPackageOption
     *   }
     * })
     * 
     */
    delete<T extends UserPackageOptionDeleteArgs>(args: SelectSubset<T, UserPackageOptionDeleteArgs<ExtArgs>>): Prisma__UserPackageOptionClient<$Result.GetResult<Prisma.$UserPackageOptionPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for UserPackageOption.
   * 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__UserPackageOptionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    transportations<T extends UserPackageOption$transportationsArgs<ExtArgs> = {}>(args?: Subset<T, UserPackageOption$transportationsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPackagePayload<ExtArgs>, T, "findMany"> | Null>
    flights<T extends UserPackageOption$flightsArgs<ExtArgs> = {}>(args?: Subset<T, UserPackageOption$flightsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPackagePayload<ExtArgs>, T, "findMany"> | Null>
    hotelMekkahs<T extends UserPackageOption$hotelMekkahsArgs<ExtArgs> = {}>(args?: Subset<T, UserPackageOption$hotelMekkahsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPackagePayload<ExtArgs>, T, "findMany"> | Null>
    hotelMadinahs<T extends UserPackageOption$hotelMadinahsArgs<ExtArgs> = {}>(args?: Subset<T, UserPackageOption$hotelMadinahsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPackagePayload<ExtArgs>, T, "findMany"> | Null>
    muthawifs<T extends UserPackageOption$muthawifsArgs<ExtArgs> = {}>(args?: Subset<T, UserPackageOption$muthawifsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPackagePayload<ExtArgs>, T, "findMany"> | Null>
    handlings<T extends UserPackageOption$handlingsArgs<ExtArgs> = {}>(args?: Subset<T, UserPackageOption$handlingsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UserPackagePayload<ExtArgs>, T, "findMany"> | Null>
    PackageType<T extends PackageTypeDefaultArgs<ExtArgs> = {}>(args?: Subset<T, PackageTypeDefaultArgs<ExtArgs>>): Prisma__PackageTypeClient<$Result.GetResult<Prisma.$PackageTypePayload<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 UserPackageOption model
   */ 
  interface UserPackageOptionFieldRefs {
    readonly id: FieldRef<"UserPackageOption", 'String'>
    readonly package_type_id: FieldRef<"UserPackageOption", 'String'>
    readonly name: FieldRef<"UserPackageOption", 'String'>
    readonly price: FieldRef<"UserPackageOption", 'Decimal'>
    readonly order_number: FieldRef<"UserPackageOption", 'Int'>
    readonly created_at: FieldRef<"UserPackageOption", 'DateTime'>
    readonly updated_at: FieldRef<"UserPackageOption", 'DateTime'>
  }
    

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

  /**
   * UserPackageOption findUniqueOrThrow
   */
  export type UserPackageOptionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackageOption
     */
    select?: UserPackageOptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageOptionInclude<ExtArgs> | null
    /**
     * Filter, which UserPackageOption to fetch.
     */
    where: UserPackageOptionWhereUniqueInput
  }

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

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

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

  /**
   * UserPackageOption create
   */
  export type UserPackageOptionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackageOption
     */
    select?: UserPackageOptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageOptionInclude<ExtArgs> | null
    /**
     * The data needed to create a UserPackageOption.
     */
    data: XOR<UserPackageOptionCreateInput, UserPackageOptionUncheckedCreateInput>
  }

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

  /**
   * UserPackageOption update
   */
  export type UserPackageOptionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackageOption
     */
    select?: UserPackageOptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageOptionInclude<ExtArgs> | null
    /**
     * The data needed to update a UserPackageOption.
     */
    data: XOR<UserPackageOptionUpdateInput, UserPackageOptionUncheckedUpdateInput>
    /**
     * Choose, which UserPackageOption to update.
     */
    where: UserPackageOptionWhereUniqueInput
  }

  /**
   * UserPackageOption updateMany
   */
  export type UserPackageOptionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update UserPackageOptions.
     */
    data: XOR<UserPackageOptionUpdateManyMutationInput, UserPackageOptionUncheckedUpdateManyInput>
    /**
     * Filter which UserPackageOptions to update
     */
    where?: UserPackageOptionWhereInput
  }

  /**
   * UserPackageOption upsert
   */
  export type UserPackageOptionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackageOption
     */
    select?: UserPackageOptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageOptionInclude<ExtArgs> | null
    /**
     * The filter to search for the UserPackageOption to update in case it exists.
     */
    where: UserPackageOptionWhereUniqueInput
    /**
     * In case the UserPackageOption found by the `where` argument doesn't exist, create a new UserPackageOption with this data.
     */
    create: XOR<UserPackageOptionCreateInput, UserPackageOptionUncheckedCreateInput>
    /**
     * In case the UserPackageOption was found with the provided `where` argument, update it with this data.
     */
    update: XOR<UserPackageOptionUpdateInput, UserPackageOptionUncheckedUpdateInput>
  }

  /**
   * UserPackageOption delete
   */
  export type UserPackageOptionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackageOption
     */
    select?: UserPackageOptionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageOptionInclude<ExtArgs> | null
    /**
     * Filter which UserPackageOption to delete.
     */
    where: UserPackageOptionWhereUniqueInput
  }

  /**
   * UserPackageOption deleteMany
   */
  export type UserPackageOptionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which UserPackageOptions to delete
     */
    where?: UserPackageOptionWhereInput
  }

  /**
   * UserPackageOption.transportations
   */
  export type UserPackageOption$transportationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackage
     */
    select?: UserPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageInclude<ExtArgs> | null
    where?: UserPackageWhereInput
    orderBy?: UserPackageOrderByWithRelationInput | UserPackageOrderByWithRelationInput[]
    cursor?: UserPackageWhereUniqueInput
    take?: number
    skip?: number
    distinct?: UserPackageScalarFieldEnum | UserPackageScalarFieldEnum[]
  }

  /**
   * UserPackageOption.flights
   */
  export type UserPackageOption$flightsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackage
     */
    select?: UserPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageInclude<ExtArgs> | null
    where?: UserPackageWhereInput
    orderBy?: UserPackageOrderByWithRelationInput | UserPackageOrderByWithRelationInput[]
    cursor?: UserPackageWhereUniqueInput
    take?: number
    skip?: number
    distinct?: UserPackageScalarFieldEnum | UserPackageScalarFieldEnum[]
  }

  /**
   * UserPackageOption.hotelMekkahs
   */
  export type UserPackageOption$hotelMekkahsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackage
     */
    select?: UserPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageInclude<ExtArgs> | null
    where?: UserPackageWhereInput
    orderBy?: UserPackageOrderByWithRelationInput | UserPackageOrderByWithRelationInput[]
    cursor?: UserPackageWhereUniqueInput
    take?: number
    skip?: number
    distinct?: UserPackageScalarFieldEnum | UserPackageScalarFieldEnum[]
  }

  /**
   * UserPackageOption.hotelMadinahs
   */
  export type UserPackageOption$hotelMadinahsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackage
     */
    select?: UserPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageInclude<ExtArgs> | null
    where?: UserPackageWhereInput
    orderBy?: UserPackageOrderByWithRelationInput | UserPackageOrderByWithRelationInput[]
    cursor?: UserPackageWhereUniqueInput
    take?: number
    skip?: number
    distinct?: UserPackageScalarFieldEnum | UserPackageScalarFieldEnum[]
  }

  /**
   * UserPackageOption.muthawifs
   */
  export type UserPackageOption$muthawifsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackage
     */
    select?: UserPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageInclude<ExtArgs> | null
    where?: UserPackageWhereInput
    orderBy?: UserPackageOrderByWithRelationInput | UserPackageOrderByWithRelationInput[]
    cursor?: UserPackageWhereUniqueInput
    take?: number
    skip?: number
    distinct?: UserPackageScalarFieldEnum | UserPackageScalarFieldEnum[]
  }

  /**
   * UserPackageOption.handlings
   */
  export type UserPackageOption$handlingsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackage
     */
    select?: UserPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageInclude<ExtArgs> | null
    where?: UserPackageWhereInput
    orderBy?: UserPackageOrderByWithRelationInput | UserPackageOrderByWithRelationInput[]
    cursor?: UserPackageWhereUniqueInput
    take?: number
    skip?: number
    distinct?: UserPackageScalarFieldEnum | UserPackageScalarFieldEnum[]
  }

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


  /**
   * Model UserPackageOrder
   */

  export type AggregateUserPackageOrder = {
    _count: UserPackageOrderCountAggregateOutputType | null
    _min: UserPackageOrderMinAggregateOutputType | null
    _max: UserPackageOrderMaxAggregateOutputType | null
  }

  export type UserPackageOrderMinAggregateOutputType = {
    id: string | null
    full_name: string | null
    email: string | null
    whatsapp_number: string | null
    user_package_id: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type UserPackageOrderMaxAggregateOutputType = {
    id: string | null
    full_name: string | null
    email: string | null
    whatsapp_number: string | null
    user_package_id: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type UserPackageOrderCountAggregateOutputType = {
    id: number
    full_name: number
    email: number
    whatsapp_number: number
    user_package_id: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type UserPackageOrderMinAggregateInputType = {
    id?: true
    full_name?: true
    email?: true
    whatsapp_number?: true
    user_package_id?: true
    created_at?: true
    updated_at?: true
  }

  export type UserPackageOrderMaxAggregateInputType = {
    id?: true
    full_name?: true
    email?: true
    whatsapp_number?: true
    user_package_id?: true
    created_at?: true
    updated_at?: true
  }

  export type UserPackageOrderCountAggregateInputType = {
    id?: true
    full_name?: true
    email?: true
    whatsapp_number?: true
    user_package_id?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

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

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




  export type UserPackageOrderGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: UserPackageOrderWhereInput
    orderBy?: UserPackageOrderOrderByWithAggregationInput | UserPackageOrderOrderByWithAggregationInput[]
    by: UserPackageOrderScalarFieldEnum[] | UserPackageOrderScalarFieldEnum
    having?: UserPackageOrderScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: UserPackageOrderCountAggregateInputType | true
    _min?: UserPackageOrderMinAggregateInputType
    _max?: UserPackageOrderMaxAggregateInputType
  }

  export type UserPackageOrderGroupByOutputType = {
    id: string
    full_name: string
    email: string
    whatsapp_number: string
    user_package_id: string
    created_at: Date
    updated_at: Date
    _count: UserPackageOrderCountAggregateOutputType | null
    _min: UserPackageOrderMinAggregateOutputType | null
    _max: UserPackageOrderMaxAggregateOutputType | null
  }

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


  export type UserPackageOrderSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    full_name?: boolean
    email?: boolean
    whatsapp_number?: boolean
    user_package_id?: boolean
    created_at?: boolean
    updated_at?: boolean
    UserPackage?: boolean | UserPackageDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["userPackageOrder"]>


  export type UserPackageOrderSelectScalar = {
    id?: boolean
    full_name?: boolean
    email?: boolean
    whatsapp_number?: boolean
    user_package_id?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type UserPackageOrderInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    UserPackage?: boolean | UserPackageDefaultArgs<ExtArgs>
  }

  export type $UserPackageOrderPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "UserPackageOrder"
    objects: {
      UserPackage: Prisma.$UserPackagePayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      full_name: string
      email: string
      whatsapp_number: string
      user_package_id: string
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["userPackageOrder"]>
    composites: {}
  }

  type UserPackageOrderGetPayload<S extends boolean | null | undefined | UserPackageOrderDefaultArgs> = $Result.GetResult<Prisma.$UserPackageOrderPayload, S>

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

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

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

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

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

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

    /**
     * Create a UserPackageOrder.
     * @param {UserPackageOrderCreateArgs} args - Arguments to create a UserPackageOrder.
     * @example
     * // Create one UserPackageOrder
     * const UserPackageOrder = await prisma.userPackageOrder.create({
     *   data: {
     *     // ... data to create a UserPackageOrder
     *   }
     * })
     * 
     */
    create<T extends UserPackageOrderCreateArgs>(args: SelectSubset<T, UserPackageOrderCreateArgs<ExtArgs>>): Prisma__UserPackageOrderClient<$Result.GetResult<Prisma.$UserPackageOrderPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Delete a UserPackageOrder.
     * @param {UserPackageOrderDeleteArgs} args - Arguments to delete one UserPackageOrder.
     * @example
     * // Delete one UserPackageOrder
     * const UserPackageOrder = await prisma.userPackageOrder.delete({
     *   where: {
     *     // ... filter to delete one UserPackageOrder
     *   }
     * })
     * 
     */
    delete<T extends UserPackageOrderDeleteArgs>(args: SelectSubset<T, UserPackageOrderDeleteArgs<ExtArgs>>): Prisma__UserPackageOrderClient<$Result.GetResult<Prisma.$UserPackageOrderPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for UserPackageOrder.
   * 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__UserPackageOrderClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    UserPackage<T extends UserPackageDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserPackageDefaultArgs<ExtArgs>>): Prisma__UserPackageClient<$Result.GetResult<Prisma.$UserPackagePayload<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 UserPackageOrder model
   */ 
  interface UserPackageOrderFieldRefs {
    readonly id: FieldRef<"UserPackageOrder", 'String'>
    readonly full_name: FieldRef<"UserPackageOrder", 'String'>
    readonly email: FieldRef<"UserPackageOrder", 'String'>
    readonly whatsapp_number: FieldRef<"UserPackageOrder", 'String'>
    readonly user_package_id: FieldRef<"UserPackageOrder", 'String'>
    readonly created_at: FieldRef<"UserPackageOrder", 'DateTime'>
    readonly updated_at: FieldRef<"UserPackageOrder", 'DateTime'>
  }
    

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

  /**
   * UserPackageOrder findUniqueOrThrow
   */
  export type UserPackageOrderFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackageOrder
     */
    select?: UserPackageOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageOrderInclude<ExtArgs> | null
    /**
     * Filter, which UserPackageOrder to fetch.
     */
    where: UserPackageOrderWhereUniqueInput
  }

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

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

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

  /**
   * UserPackageOrder create
   */
  export type UserPackageOrderCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackageOrder
     */
    select?: UserPackageOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageOrderInclude<ExtArgs> | null
    /**
     * The data needed to create a UserPackageOrder.
     */
    data: XOR<UserPackageOrderCreateInput, UserPackageOrderUncheckedCreateInput>
  }

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

  /**
   * UserPackageOrder update
   */
  export type UserPackageOrderUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackageOrder
     */
    select?: UserPackageOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageOrderInclude<ExtArgs> | null
    /**
     * The data needed to update a UserPackageOrder.
     */
    data: XOR<UserPackageOrderUpdateInput, UserPackageOrderUncheckedUpdateInput>
    /**
     * Choose, which UserPackageOrder to update.
     */
    where: UserPackageOrderWhereUniqueInput
  }

  /**
   * UserPackageOrder updateMany
   */
  export type UserPackageOrderUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update UserPackageOrders.
     */
    data: XOR<UserPackageOrderUpdateManyMutationInput, UserPackageOrderUncheckedUpdateManyInput>
    /**
     * Filter which UserPackageOrders to update
     */
    where?: UserPackageOrderWhereInput
  }

  /**
   * UserPackageOrder upsert
   */
  export type UserPackageOrderUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackageOrder
     */
    select?: UserPackageOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageOrderInclude<ExtArgs> | null
    /**
     * The filter to search for the UserPackageOrder to update in case it exists.
     */
    where: UserPackageOrderWhereUniqueInput
    /**
     * In case the UserPackageOrder found by the `where` argument doesn't exist, create a new UserPackageOrder with this data.
     */
    create: XOR<UserPackageOrderCreateInput, UserPackageOrderUncheckedCreateInput>
    /**
     * In case the UserPackageOrder was found with the provided `where` argument, update it with this data.
     */
    update: XOR<UserPackageOrderUpdateInput, UserPackageOrderUncheckedUpdateInput>
  }

  /**
   * UserPackageOrder delete
   */
  export type UserPackageOrderDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserPackageOrder
     */
    select?: UserPackageOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserPackageOrderInclude<ExtArgs> | null
    /**
     * Filter which UserPackageOrder to delete.
     */
    where: UserPackageOrderWhereUniqueInput
  }

  /**
   * UserPackageOrder deleteMany
   */
  export type UserPackageOrderDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which UserPackageOrders to delete
     */
    where?: UserPackageOrderWhereInput
  }

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


  /**
   * Model Category
   */

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

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

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

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


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

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

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

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

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




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

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

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


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


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

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

  export type $CategoryPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Category"
    objects: {
      ProductCategories: Prisma.$ProductCategoryPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["category"]>
    composites: {}
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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




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

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

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

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

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

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

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

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

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

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

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

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

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

  /**
   * Category.ProductCategories
   */
  export type Category$ProductCategoriesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductCategory
     */
    select?: ProductCategorySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductCategoryInclude<ExtArgs> | null
    where?: ProductCategoryWhereInput
    orderBy?: ProductCategoryOrderByWithRelationInput | ProductCategoryOrderByWithRelationInput[]
    cursor?: ProductCategoryWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ProductCategoryScalarFieldEnum | ProductCategoryScalarFieldEnum[]
  }

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


  /**
   * Model Product
   */

  export type AggregateProduct = {
    _count: ProductCountAggregateOutputType | null
    _avg: ProductAvgAggregateOutputType | null
    _sum: ProductSumAggregateOutputType | null
    _min: ProductMinAggregateOutputType | null
    _max: ProductMaxAggregateOutputType | null
  }

  export type ProductAvgAggregateOutputType = {
    price: Decimal | null
  }

  export type ProductSumAggregateOutputType = {
    price: Decimal | null
  }

  export type ProductMinAggregateOutputType = {
    id: string | null
    name: string | null
    description: string | null
    price: Decimal | null
    has_variation: boolean | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type ProductMaxAggregateOutputType = {
    id: string | null
    name: string | null
    description: string | null
    price: Decimal | null
    has_variation: boolean | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type ProductCountAggregateOutputType = {
    id: number
    name: number
    description: number
    price: number
    has_variation: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type ProductAvgAggregateInputType = {
    price?: true
  }

  export type ProductSumAggregateInputType = {
    price?: true
  }

  export type ProductMinAggregateInputType = {
    id?: true
    name?: true
    description?: true
    price?: true
    has_variation?: true
    created_at?: true
    updated_at?: true
  }

  export type ProductMaxAggregateInputType = {
    id?: true
    name?: true
    description?: true
    price?: true
    has_variation?: true
    created_at?: true
    updated_at?: true
  }

  export type ProductCountAggregateInputType = {
    id?: true
    name?: true
    description?: true
    price?: true
    has_variation?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type ProductAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Product to aggregate.
     */
    where?: ProductWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Products to fetch.
     */
    orderBy?: ProductOrderByWithRelationInput | ProductOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ProductWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Products from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Products.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Products
    **/
    _count?: true | ProductCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ProductAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ProductSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ProductMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ProductMaxAggregateInputType
  }

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




  export type ProductGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ProductWhereInput
    orderBy?: ProductOrderByWithAggregationInput | ProductOrderByWithAggregationInput[]
    by: ProductScalarFieldEnum[] | ProductScalarFieldEnum
    having?: ProductScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ProductCountAggregateInputType | true
    _avg?: ProductAvgAggregateInputType
    _sum?: ProductSumAggregateInputType
    _min?: ProductMinAggregateInputType
    _max?: ProductMaxAggregateInputType
  }

  export type ProductGroupByOutputType = {
    id: string
    name: string
    description: string | null
    price: Decimal
    has_variation: boolean
    created_at: Date
    updated_at: Date
    _count: ProductCountAggregateOutputType | null
    _avg: ProductAvgAggregateOutputType | null
    _sum: ProductSumAggregateOutputType | null
    _min: ProductMinAggregateOutputType | null
    _max: ProductMaxAggregateOutputType | null
  }

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


  export type ProductSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    description?: boolean
    price?: boolean
    has_variation?: boolean
    created_at?: boolean
    updated_at?: boolean
    ProductThumbnails?: boolean | Product$ProductThumbnailsArgs<ExtArgs>
    ProductCategories?: boolean | Product$ProductCategoriesArgs<ExtArgs>
    ProductVariations?: boolean | Product$ProductVariationsArgs<ExtArgs>
    ProductIncludes?: boolean | Product$ProductIncludesArgs<ExtArgs>
    ProductExcludes?: boolean | Product$ProductExcludesArgs<ExtArgs>
    ProductOrders?: boolean | Product$ProductOrdersArgs<ExtArgs>
    _count?: boolean | ProductCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["product"]>


  export type ProductSelectScalar = {
    id?: boolean
    name?: boolean
    description?: boolean
    price?: boolean
    has_variation?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type ProductInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    ProductThumbnails?: boolean | Product$ProductThumbnailsArgs<ExtArgs>
    ProductCategories?: boolean | Product$ProductCategoriesArgs<ExtArgs>
    ProductVariations?: boolean | Product$ProductVariationsArgs<ExtArgs>
    ProductIncludes?: boolean | Product$ProductIncludesArgs<ExtArgs>
    ProductExcludes?: boolean | Product$ProductExcludesArgs<ExtArgs>
    ProductOrders?: boolean | Product$ProductOrdersArgs<ExtArgs>
    _count?: boolean | ProductCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $ProductPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Product"
    objects: {
      ProductThumbnails: Prisma.$ProductThumbnailPayload<ExtArgs>[]
      ProductCategories: Prisma.$ProductCategoryPayload<ExtArgs>[]
      ProductVariations: Prisma.$ProductVariationPayload<ExtArgs>[]
      ProductIncludes: Prisma.$ProductIncludePayload<ExtArgs>[]
      ProductExcludes: Prisma.$ProductExcludePayload<ExtArgs>[]
      ProductOrders: Prisma.$ProductOrderPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      description: string | null
      price: Prisma.Decimal
      has_variation: boolean
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["product"]>
    composites: {}
  }

  type ProductGetPayload<S extends boolean | null | undefined | ProductDefaultArgs> = $Result.GetResult<Prisma.$ProductPayload, S>

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

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

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

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

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

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

    /**
     * Create a Product.
     * @param {ProductCreateArgs} args - Arguments to create a Product.
     * @example
     * // Create one Product
     * const Product = await prisma.product.create({
     *   data: {
     *     // ... data to create a Product
     *   }
     * })
     * 
     */
    create<T extends ProductCreateArgs>(args: SelectSubset<T, ProductCreateArgs<ExtArgs>>): Prisma__ProductClient<$Result.GetResult<Prisma.$ProductPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Delete a Product.
     * @param {ProductDeleteArgs} args - Arguments to delete one Product.
     * @example
     * // Delete one Product
     * const Product = await prisma.product.delete({
     *   where: {
     *     // ... filter to delete one Product
     *   }
     * })
     * 
     */
    delete<T extends ProductDeleteArgs>(args: SelectSubset<T, ProductDeleteArgs<ExtArgs>>): Prisma__ProductClient<$Result.GetResult<Prisma.$ProductPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Product.
   * 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__ProductClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    ProductThumbnails<T extends Product$ProductThumbnailsArgs<ExtArgs> = {}>(args?: Subset<T, Product$ProductThumbnailsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ProductThumbnailPayload<ExtArgs>, T, "findMany"> | Null>
    ProductCategories<T extends Product$ProductCategoriesArgs<ExtArgs> = {}>(args?: Subset<T, Product$ProductCategoriesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ProductCategoryPayload<ExtArgs>, T, "findMany"> | Null>
    ProductVariations<T extends Product$ProductVariationsArgs<ExtArgs> = {}>(args?: Subset<T, Product$ProductVariationsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ProductVariationPayload<ExtArgs>, T, "findMany"> | Null>
    ProductIncludes<T extends Product$ProductIncludesArgs<ExtArgs> = {}>(args?: Subset<T, Product$ProductIncludesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ProductIncludePayload<ExtArgs>, T, "findMany"> | Null>
    ProductExcludes<T extends Product$ProductExcludesArgs<ExtArgs> = {}>(args?: Subset<T, Product$ProductExcludesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ProductExcludePayload<ExtArgs>, T, "findMany"> | Null>
    ProductOrders<T extends Product$ProductOrdersArgs<ExtArgs> = {}>(args?: Subset<T, Product$ProductOrdersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ProductOrderPayload<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 Product model
   */ 
  interface ProductFieldRefs {
    readonly id: FieldRef<"Product", 'String'>
    readonly name: FieldRef<"Product", 'String'>
    readonly description: FieldRef<"Product", 'String'>
    readonly price: FieldRef<"Product", 'Decimal'>
    readonly has_variation: FieldRef<"Product", 'Boolean'>
    readonly created_at: FieldRef<"Product", 'DateTime'>
    readonly updated_at: FieldRef<"Product", 'DateTime'>
  }
    

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

  /**
   * Product findUniqueOrThrow
   */
  export type ProductFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Product
     */
    select?: ProductSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductInclude<ExtArgs> | null
    /**
     * Filter, which Product to fetch.
     */
    where: ProductWhereUniqueInput
  }

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

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

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

  /**
   * Product create
   */
  export type ProductCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Product
     */
    select?: ProductSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductInclude<ExtArgs> | null
    /**
     * The data needed to create a Product.
     */
    data: XOR<ProductCreateInput, ProductUncheckedCreateInput>
  }

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

  /**
   * Product update
   */
  export type ProductUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Product
     */
    select?: ProductSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductInclude<ExtArgs> | null
    /**
     * The data needed to update a Product.
     */
    data: XOR<ProductUpdateInput, ProductUncheckedUpdateInput>
    /**
     * Choose, which Product to update.
     */
    where: ProductWhereUniqueInput
  }

  /**
   * Product updateMany
   */
  export type ProductUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Products.
     */
    data: XOR<ProductUpdateManyMutationInput, ProductUncheckedUpdateManyInput>
    /**
     * Filter which Products to update
     */
    where?: ProductWhereInput
  }

  /**
   * Product upsert
   */
  export type ProductUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Product
     */
    select?: ProductSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductInclude<ExtArgs> | null
    /**
     * The filter to search for the Product to update in case it exists.
     */
    where: ProductWhereUniqueInput
    /**
     * In case the Product found by the `where` argument doesn't exist, create a new Product with this data.
     */
    create: XOR<ProductCreateInput, ProductUncheckedCreateInput>
    /**
     * In case the Product was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ProductUpdateInput, ProductUncheckedUpdateInput>
  }

  /**
   * Product delete
   */
  export type ProductDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Product
     */
    select?: ProductSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductInclude<ExtArgs> | null
    /**
     * Filter which Product to delete.
     */
    where: ProductWhereUniqueInput
  }

  /**
   * Product deleteMany
   */
  export type ProductDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Products to delete
     */
    where?: ProductWhereInput
  }

  /**
   * Product.ProductThumbnails
   */
  export type Product$ProductThumbnailsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductThumbnail
     */
    select?: ProductThumbnailSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductThumbnailInclude<ExtArgs> | null
    where?: ProductThumbnailWhereInput
    orderBy?: ProductThumbnailOrderByWithRelationInput | ProductThumbnailOrderByWithRelationInput[]
    cursor?: ProductThumbnailWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ProductThumbnailScalarFieldEnum | ProductThumbnailScalarFieldEnum[]
  }

  /**
   * Product.ProductCategories
   */
  export type Product$ProductCategoriesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductCategory
     */
    select?: ProductCategorySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductCategoryInclude<ExtArgs> | null
    where?: ProductCategoryWhereInput
    orderBy?: ProductCategoryOrderByWithRelationInput | ProductCategoryOrderByWithRelationInput[]
    cursor?: ProductCategoryWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ProductCategoryScalarFieldEnum | ProductCategoryScalarFieldEnum[]
  }

  /**
   * Product.ProductVariations
   */
  export type Product$ProductVariationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductVariation
     */
    select?: ProductVariationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductVariationInclude<ExtArgs> | null
    where?: ProductVariationWhereInput
    orderBy?: ProductVariationOrderByWithRelationInput | ProductVariationOrderByWithRelationInput[]
    cursor?: ProductVariationWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ProductVariationScalarFieldEnum | ProductVariationScalarFieldEnum[]
  }

  /**
   * Product.ProductIncludes
   */
  export type Product$ProductIncludesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductInclude
     */
    select?: ProductIncludeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductIncludeInclude<ExtArgs> | null
    where?: ProductIncludeWhereInput
    orderBy?: ProductIncludeOrderByWithRelationInput | ProductIncludeOrderByWithRelationInput[]
    cursor?: ProductIncludeWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ProductIncludeScalarFieldEnum | ProductIncludeScalarFieldEnum[]
  }

  /**
   * Product.ProductExcludes
   */
  export type Product$ProductExcludesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductExclude
     */
    select?: ProductExcludeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductExcludeInclude<ExtArgs> | null
    where?: ProductExcludeWhereInput
    orderBy?: ProductExcludeOrderByWithRelationInput | ProductExcludeOrderByWithRelationInput[]
    cursor?: ProductExcludeWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ProductExcludeScalarFieldEnum | ProductExcludeScalarFieldEnum[]
  }

  /**
   * Product.ProductOrders
   */
  export type Product$ProductOrdersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductOrder
     */
    select?: ProductOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductOrderInclude<ExtArgs> | null
    where?: ProductOrderWhereInput
    orderBy?: ProductOrderOrderByWithRelationInput | ProductOrderOrderByWithRelationInput[]
    cursor?: ProductOrderWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ProductOrderScalarFieldEnum | ProductOrderScalarFieldEnum[]
  }

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


  /**
   * Model ProductThumbnail
   */

  export type AggregateProductThumbnail = {
    _count: ProductThumbnailCountAggregateOutputType | null
    _avg: ProductThumbnailAvgAggregateOutputType | null
    _sum: ProductThumbnailSumAggregateOutputType | null
    _min: ProductThumbnailMinAggregateOutputType | null
    _max: ProductThumbnailMaxAggregateOutputType | null
  }

  export type ProductThumbnailAvgAggregateOutputType = {
    increment: number | null
  }

  export type ProductThumbnailSumAggregateOutputType = {
    increment: number | null
  }

  export type ProductThumbnailMinAggregateOutputType = {
    id: string | null
    increment: number | null
    product_id: string | null
    image_url: string | null
  }

  export type ProductThumbnailMaxAggregateOutputType = {
    id: string | null
    increment: number | null
    product_id: string | null
    image_url: string | null
  }

  export type ProductThumbnailCountAggregateOutputType = {
    id: number
    increment: number
    product_id: number
    image_url: number
    _all: number
  }


  export type ProductThumbnailAvgAggregateInputType = {
    increment?: true
  }

  export type ProductThumbnailSumAggregateInputType = {
    increment?: true
  }

  export type ProductThumbnailMinAggregateInputType = {
    id?: true
    increment?: true
    product_id?: true
    image_url?: true
  }

  export type ProductThumbnailMaxAggregateInputType = {
    id?: true
    increment?: true
    product_id?: true
    image_url?: true
  }

  export type ProductThumbnailCountAggregateInputType = {
    id?: true
    increment?: true
    product_id?: true
    image_url?: true
    _all?: true
  }

  export type ProductThumbnailAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ProductThumbnail to aggregate.
     */
    where?: ProductThumbnailWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ProductThumbnails to fetch.
     */
    orderBy?: ProductThumbnailOrderByWithRelationInput | ProductThumbnailOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ProductThumbnailWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ProductThumbnails from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` ProductThumbnails.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ProductThumbnails
    **/
    _count?: true | ProductThumbnailCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ProductThumbnailAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ProductThumbnailSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ProductThumbnailMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ProductThumbnailMaxAggregateInputType
  }

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




  export type ProductThumbnailGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ProductThumbnailWhereInput
    orderBy?: ProductThumbnailOrderByWithAggregationInput | ProductThumbnailOrderByWithAggregationInput[]
    by: ProductThumbnailScalarFieldEnum[] | ProductThumbnailScalarFieldEnum
    having?: ProductThumbnailScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ProductThumbnailCountAggregateInputType | true
    _avg?: ProductThumbnailAvgAggregateInputType
    _sum?: ProductThumbnailSumAggregateInputType
    _min?: ProductThumbnailMinAggregateInputType
    _max?: ProductThumbnailMaxAggregateInputType
  }

  export type ProductThumbnailGroupByOutputType = {
    id: string
    increment: number
    product_id: string
    image_url: string
    _count: ProductThumbnailCountAggregateOutputType | null
    _avg: ProductThumbnailAvgAggregateOutputType | null
    _sum: ProductThumbnailSumAggregateOutputType | null
    _min: ProductThumbnailMinAggregateOutputType | null
    _max: ProductThumbnailMaxAggregateOutputType | null
  }

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


  export type ProductThumbnailSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    increment?: boolean
    product_id?: boolean
    image_url?: boolean
    Product?: boolean | ProductDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["productThumbnail"]>


  export type ProductThumbnailSelectScalar = {
    id?: boolean
    increment?: boolean
    product_id?: boolean
    image_url?: boolean
  }

  export type ProductThumbnailInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Product?: boolean | ProductDefaultArgs<ExtArgs>
  }

  export type $ProductThumbnailPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ProductThumbnail"
    objects: {
      Product: Prisma.$ProductPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      increment: number
      product_id: string
      image_url: string
    }, ExtArgs["result"]["productThumbnail"]>
    composites: {}
  }

  type ProductThumbnailGetPayload<S extends boolean | null | undefined | ProductThumbnailDefaultArgs> = $Result.GetResult<Prisma.$ProductThumbnailPayload, S>

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

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

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

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

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

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

    /**
     * Create a ProductThumbnail.
     * @param {ProductThumbnailCreateArgs} args - Arguments to create a ProductThumbnail.
     * @example
     * // Create one ProductThumbnail
     * const ProductThumbnail = await prisma.productThumbnail.create({
     *   data: {
     *     // ... data to create a ProductThumbnail
     *   }
     * })
     * 
     */
    create<T extends ProductThumbnailCreateArgs>(args: SelectSubset<T, ProductThumbnailCreateArgs<ExtArgs>>): Prisma__ProductThumbnailClient<$Result.GetResult<Prisma.$ProductThumbnailPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Delete a ProductThumbnail.
     * @param {ProductThumbnailDeleteArgs} args - Arguments to delete one ProductThumbnail.
     * @example
     * // Delete one ProductThumbnail
     * const ProductThumbnail = await prisma.productThumbnail.delete({
     *   where: {
     *     // ... filter to delete one ProductThumbnail
     *   }
     * })
     * 
     */
    delete<T extends ProductThumbnailDeleteArgs>(args: SelectSubset<T, ProductThumbnailDeleteArgs<ExtArgs>>): Prisma__ProductThumbnailClient<$Result.GetResult<Prisma.$ProductThumbnailPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for ProductThumbnail.
   * 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__ProductThumbnailClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    Product<T extends ProductDefaultArgs<ExtArgs> = {}>(args?: Subset<T, ProductDefaultArgs<ExtArgs>>): Prisma__ProductClient<$Result.GetResult<Prisma.$ProductPayload<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 ProductThumbnail model
   */ 
  interface ProductThumbnailFieldRefs {
    readonly id: FieldRef<"ProductThumbnail", 'String'>
    readonly increment: FieldRef<"ProductThumbnail", 'Int'>
    readonly product_id: FieldRef<"ProductThumbnail", 'String'>
    readonly image_url: FieldRef<"ProductThumbnail", 'String'>
  }
    

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

  /**
   * ProductThumbnail findUniqueOrThrow
   */
  export type ProductThumbnailFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductThumbnail
     */
    select?: ProductThumbnailSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductThumbnailInclude<ExtArgs> | null
    /**
     * Filter, which ProductThumbnail to fetch.
     */
    where: ProductThumbnailWhereUniqueInput
  }

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

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

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

  /**
   * ProductThumbnail create
   */
  export type ProductThumbnailCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductThumbnail
     */
    select?: ProductThumbnailSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductThumbnailInclude<ExtArgs> | null
    /**
     * The data needed to create a ProductThumbnail.
     */
    data: XOR<ProductThumbnailCreateInput, ProductThumbnailUncheckedCreateInput>
  }

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

  /**
   * ProductThumbnail update
   */
  export type ProductThumbnailUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductThumbnail
     */
    select?: ProductThumbnailSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductThumbnailInclude<ExtArgs> | null
    /**
     * The data needed to update a ProductThumbnail.
     */
    data: XOR<ProductThumbnailUpdateInput, ProductThumbnailUncheckedUpdateInput>
    /**
     * Choose, which ProductThumbnail to update.
     */
    where: ProductThumbnailWhereUniqueInput
  }

  /**
   * ProductThumbnail updateMany
   */
  export type ProductThumbnailUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ProductThumbnails.
     */
    data: XOR<ProductThumbnailUpdateManyMutationInput, ProductThumbnailUncheckedUpdateManyInput>
    /**
     * Filter which ProductThumbnails to update
     */
    where?: ProductThumbnailWhereInput
  }

  /**
   * ProductThumbnail upsert
   */
  export type ProductThumbnailUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductThumbnail
     */
    select?: ProductThumbnailSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductThumbnailInclude<ExtArgs> | null
    /**
     * The filter to search for the ProductThumbnail to update in case it exists.
     */
    where: ProductThumbnailWhereUniqueInput
    /**
     * In case the ProductThumbnail found by the `where` argument doesn't exist, create a new ProductThumbnail with this data.
     */
    create: XOR<ProductThumbnailCreateInput, ProductThumbnailUncheckedCreateInput>
    /**
     * In case the ProductThumbnail was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ProductThumbnailUpdateInput, ProductThumbnailUncheckedUpdateInput>
  }

  /**
   * ProductThumbnail delete
   */
  export type ProductThumbnailDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductThumbnail
     */
    select?: ProductThumbnailSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductThumbnailInclude<ExtArgs> | null
    /**
     * Filter which ProductThumbnail to delete.
     */
    where: ProductThumbnailWhereUniqueInput
  }

  /**
   * ProductThumbnail deleteMany
   */
  export type ProductThumbnailDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ProductThumbnails to delete
     */
    where?: ProductThumbnailWhereInput
  }

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


  /**
   * Model ProductCategory
   */

  export type AggregateProductCategory = {
    _count: ProductCategoryCountAggregateOutputType | null
    _min: ProductCategoryMinAggregateOutputType | null
    _max: ProductCategoryMaxAggregateOutputType | null
  }

  export type ProductCategoryMinAggregateOutputType = {
    id: string | null
    product_id: string | null
    category_id: string | null
  }

  export type ProductCategoryMaxAggregateOutputType = {
    id: string | null
    product_id: string | null
    category_id: string | null
  }

  export type ProductCategoryCountAggregateOutputType = {
    id: number
    product_id: number
    category_id: number
    _all: number
  }


  export type ProductCategoryMinAggregateInputType = {
    id?: true
    product_id?: true
    category_id?: true
  }

  export type ProductCategoryMaxAggregateInputType = {
    id?: true
    product_id?: true
    category_id?: true
  }

  export type ProductCategoryCountAggregateInputType = {
    id?: true
    product_id?: true
    category_id?: true
    _all?: true
  }

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

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




  export type ProductCategoryGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ProductCategoryWhereInput
    orderBy?: ProductCategoryOrderByWithAggregationInput | ProductCategoryOrderByWithAggregationInput[]
    by: ProductCategoryScalarFieldEnum[] | ProductCategoryScalarFieldEnum
    having?: ProductCategoryScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ProductCategoryCountAggregateInputType | true
    _min?: ProductCategoryMinAggregateInputType
    _max?: ProductCategoryMaxAggregateInputType
  }

  export type ProductCategoryGroupByOutputType = {
    id: string
    product_id: string
    category_id: string
    _count: ProductCategoryCountAggregateOutputType | null
    _min: ProductCategoryMinAggregateOutputType | null
    _max: ProductCategoryMaxAggregateOutputType | null
  }

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


  export type ProductCategorySelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    product_id?: boolean
    category_id?: boolean
    Product?: boolean | ProductDefaultArgs<ExtArgs>
    Category?: boolean | CategoryDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["productCategory"]>


  export type ProductCategorySelectScalar = {
    id?: boolean
    product_id?: boolean
    category_id?: boolean
  }

  export type ProductCategoryInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Product?: boolean | ProductDefaultArgs<ExtArgs>
    Category?: boolean | CategoryDefaultArgs<ExtArgs>
  }

  export type $ProductCategoryPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ProductCategory"
    objects: {
      Product: Prisma.$ProductPayload<ExtArgs>
      Category: Prisma.$CategoryPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      product_id: string
      category_id: string
    }, ExtArgs["result"]["productCategory"]>
    composites: {}
  }

  type ProductCategoryGetPayload<S extends boolean | null | undefined | ProductCategoryDefaultArgs> = $Result.GetResult<Prisma.$ProductCategoryPayload, S>

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

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

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

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

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

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

    /**
     * Create a ProductCategory.
     * @param {ProductCategoryCreateArgs} args - Arguments to create a ProductCategory.
     * @example
     * // Create one ProductCategory
     * const ProductCategory = await prisma.productCategory.create({
     *   data: {
     *     // ... data to create a ProductCategory
     *   }
     * })
     * 
     */
    create<T extends ProductCategoryCreateArgs>(args: SelectSubset<T, ProductCategoryCreateArgs<ExtArgs>>): Prisma__ProductCategoryClient<$Result.GetResult<Prisma.$ProductCategoryPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Delete a ProductCategory.
     * @param {ProductCategoryDeleteArgs} args - Arguments to delete one ProductCategory.
     * @example
     * // Delete one ProductCategory
     * const ProductCategory = await prisma.productCategory.delete({
     *   where: {
     *     // ... filter to delete one ProductCategory
     *   }
     * })
     * 
     */
    delete<T extends ProductCategoryDeleteArgs>(args: SelectSubset<T, ProductCategoryDeleteArgs<ExtArgs>>): Prisma__ProductCategoryClient<$Result.GetResult<Prisma.$ProductCategoryPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

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




  /**
   * Fields of the ProductCategory model
   */ 
  interface ProductCategoryFieldRefs {
    readonly id: FieldRef<"ProductCategory", 'String'>
    readonly product_id: FieldRef<"ProductCategory", 'String'>
    readonly category_id: FieldRef<"ProductCategory", 'String'>
  }
    

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

  /**
   * ProductCategory findUniqueOrThrow
   */
  export type ProductCategoryFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductCategory
     */
    select?: ProductCategorySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductCategoryInclude<ExtArgs> | null
    /**
     * Filter, which ProductCategory to fetch.
     */
    where: ProductCategoryWhereUniqueInput
  }

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

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

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

  /**
   * ProductCategory create
   */
  export type ProductCategoryCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductCategory
     */
    select?: ProductCategorySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductCategoryInclude<ExtArgs> | null
    /**
     * The data needed to create a ProductCategory.
     */
    data: XOR<ProductCategoryCreateInput, ProductCategoryUncheckedCreateInput>
  }

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

  /**
   * ProductCategory update
   */
  export type ProductCategoryUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductCategory
     */
    select?: ProductCategorySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductCategoryInclude<ExtArgs> | null
    /**
     * The data needed to update a ProductCategory.
     */
    data: XOR<ProductCategoryUpdateInput, ProductCategoryUncheckedUpdateInput>
    /**
     * Choose, which ProductCategory to update.
     */
    where: ProductCategoryWhereUniqueInput
  }

  /**
   * ProductCategory updateMany
   */
  export type ProductCategoryUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ProductCategories.
     */
    data: XOR<ProductCategoryUpdateManyMutationInput, ProductCategoryUncheckedUpdateManyInput>
    /**
     * Filter which ProductCategories to update
     */
    where?: ProductCategoryWhereInput
  }

  /**
   * ProductCategory upsert
   */
  export type ProductCategoryUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductCategory
     */
    select?: ProductCategorySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductCategoryInclude<ExtArgs> | null
    /**
     * The filter to search for the ProductCategory to update in case it exists.
     */
    where: ProductCategoryWhereUniqueInput
    /**
     * In case the ProductCategory found by the `where` argument doesn't exist, create a new ProductCategory with this data.
     */
    create: XOR<ProductCategoryCreateInput, ProductCategoryUncheckedCreateInput>
    /**
     * In case the ProductCategory was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ProductCategoryUpdateInput, ProductCategoryUncheckedUpdateInput>
  }

  /**
   * ProductCategory delete
   */
  export type ProductCategoryDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductCategory
     */
    select?: ProductCategorySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductCategoryInclude<ExtArgs> | null
    /**
     * Filter which ProductCategory to delete.
     */
    where: ProductCategoryWhereUniqueInput
  }

  /**
   * ProductCategory deleteMany
   */
  export type ProductCategoryDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ProductCategories to delete
     */
    where?: ProductCategoryWhereInput
  }

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


  /**
   * Model ProductVariation
   */

  export type AggregateProductVariation = {
    _count: ProductVariationCountAggregateOutputType | null
    _avg: ProductVariationAvgAggregateOutputType | null
    _sum: ProductVariationSumAggregateOutputType | null
    _min: ProductVariationMinAggregateOutputType | null
    _max: ProductVariationMaxAggregateOutputType | null
  }

  export type ProductVariationAvgAggregateOutputType = {
    increment: number | null
    price: Decimal | null
  }

  export type ProductVariationSumAggregateOutputType = {
    increment: number | null
    price: Decimal | null
  }

  export type ProductVariationMinAggregateOutputType = {
    id: string | null
    increment: number | null
    product_id: string | null
    name: string | null
    price: Decimal | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type ProductVariationMaxAggregateOutputType = {
    id: string | null
    increment: number | null
    product_id: string | null
    name: string | null
    price: Decimal | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type ProductVariationCountAggregateOutputType = {
    id: number
    increment: number
    product_id: number
    name: number
    price: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type ProductVariationAvgAggregateInputType = {
    increment?: true
    price?: true
  }

  export type ProductVariationSumAggregateInputType = {
    increment?: true
    price?: true
  }

  export type ProductVariationMinAggregateInputType = {
    id?: true
    increment?: true
    product_id?: true
    name?: true
    price?: true
    created_at?: true
    updated_at?: true
  }

  export type ProductVariationMaxAggregateInputType = {
    id?: true
    increment?: true
    product_id?: true
    name?: true
    price?: true
    created_at?: true
    updated_at?: true
  }

  export type ProductVariationCountAggregateInputType = {
    id?: true
    increment?: true
    product_id?: true
    name?: true
    price?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type ProductVariationAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ProductVariation to aggregate.
     */
    where?: ProductVariationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ProductVariations to fetch.
     */
    orderBy?: ProductVariationOrderByWithRelationInput | ProductVariationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ProductVariationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ProductVariations from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` ProductVariations.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ProductVariations
    **/
    _count?: true | ProductVariationCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ProductVariationAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ProductVariationSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ProductVariationMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ProductVariationMaxAggregateInputType
  }

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




  export type ProductVariationGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ProductVariationWhereInput
    orderBy?: ProductVariationOrderByWithAggregationInput | ProductVariationOrderByWithAggregationInput[]
    by: ProductVariationScalarFieldEnum[] | ProductVariationScalarFieldEnum
    having?: ProductVariationScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ProductVariationCountAggregateInputType | true
    _avg?: ProductVariationAvgAggregateInputType
    _sum?: ProductVariationSumAggregateInputType
    _min?: ProductVariationMinAggregateInputType
    _max?: ProductVariationMaxAggregateInputType
  }

  export type ProductVariationGroupByOutputType = {
    id: string
    increment: number
    product_id: string
    name: string
    price: Decimal
    created_at: Date
    updated_at: Date
    _count: ProductVariationCountAggregateOutputType | null
    _avg: ProductVariationAvgAggregateOutputType | null
    _sum: ProductVariationSumAggregateOutputType | null
    _min: ProductVariationMinAggregateOutputType | null
    _max: ProductVariationMaxAggregateOutputType | null
  }

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


  export type ProductVariationSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    increment?: boolean
    product_id?: boolean
    name?: boolean
    price?: boolean
    created_at?: boolean
    updated_at?: boolean
    ProductOrders?: boolean | ProductVariation$ProductOrdersArgs<ExtArgs>
    Product?: boolean | ProductDefaultArgs<ExtArgs>
    _count?: boolean | ProductVariationCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["productVariation"]>


  export type ProductVariationSelectScalar = {
    id?: boolean
    increment?: boolean
    product_id?: boolean
    name?: boolean
    price?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type ProductVariationInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    ProductOrders?: boolean | ProductVariation$ProductOrdersArgs<ExtArgs>
    Product?: boolean | ProductDefaultArgs<ExtArgs>
    _count?: boolean | ProductVariationCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $ProductVariationPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ProductVariation"
    objects: {
      ProductOrders: Prisma.$ProductOrderPayload<ExtArgs>[]
      Product: Prisma.$ProductPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      increment: number
      product_id: string
      name: string
      price: Prisma.Decimal
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["productVariation"]>
    composites: {}
  }

  type ProductVariationGetPayload<S extends boolean | null | undefined | ProductVariationDefaultArgs> = $Result.GetResult<Prisma.$ProductVariationPayload, S>

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

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

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

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

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

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

    /**
     * Create a ProductVariation.
     * @param {ProductVariationCreateArgs} args - Arguments to create a ProductVariation.
     * @example
     * // Create one ProductVariation
     * const ProductVariation = await prisma.productVariation.create({
     *   data: {
     *     // ... data to create a ProductVariation
     *   }
     * })
     * 
     */
    create<T extends ProductVariationCreateArgs>(args: SelectSubset<T, ProductVariationCreateArgs<ExtArgs>>): Prisma__ProductVariationClient<$Result.GetResult<Prisma.$ProductVariationPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Delete a ProductVariation.
     * @param {ProductVariationDeleteArgs} args - Arguments to delete one ProductVariation.
     * @example
     * // Delete one ProductVariation
     * const ProductVariation = await prisma.productVariation.delete({
     *   where: {
     *     // ... filter to delete one ProductVariation
     *   }
     * })
     * 
     */
    delete<T extends ProductVariationDeleteArgs>(args: SelectSubset<T, ProductVariationDeleteArgs<ExtArgs>>): Prisma__ProductVariationClient<$Result.GetResult<Prisma.$ProductVariationPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for ProductVariation.
   * 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__ProductVariationClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    ProductOrders<T extends ProductVariation$ProductOrdersArgs<ExtArgs> = {}>(args?: Subset<T, ProductVariation$ProductOrdersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ProductOrderPayload<ExtArgs>, T, "findMany"> | Null>
    Product<T extends ProductDefaultArgs<ExtArgs> = {}>(args?: Subset<T, ProductDefaultArgs<ExtArgs>>): Prisma__ProductClient<$Result.GetResult<Prisma.$ProductPayload<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 ProductVariation model
   */ 
  interface ProductVariationFieldRefs {
    readonly id: FieldRef<"ProductVariation", 'String'>
    readonly increment: FieldRef<"ProductVariation", 'Int'>
    readonly product_id: FieldRef<"ProductVariation", 'String'>
    readonly name: FieldRef<"ProductVariation", 'String'>
    readonly price: FieldRef<"ProductVariation", 'Decimal'>
    readonly created_at: FieldRef<"ProductVariation", 'DateTime'>
    readonly updated_at: FieldRef<"ProductVariation", 'DateTime'>
  }
    

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

  /**
   * ProductVariation findUniqueOrThrow
   */
  export type ProductVariationFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductVariation
     */
    select?: ProductVariationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductVariationInclude<ExtArgs> | null
    /**
     * Filter, which ProductVariation to fetch.
     */
    where: ProductVariationWhereUniqueInput
  }

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

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

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

  /**
   * ProductVariation create
   */
  export type ProductVariationCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductVariation
     */
    select?: ProductVariationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductVariationInclude<ExtArgs> | null
    /**
     * The data needed to create a ProductVariation.
     */
    data: XOR<ProductVariationCreateInput, ProductVariationUncheckedCreateInput>
  }

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

  /**
   * ProductVariation update
   */
  export type ProductVariationUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductVariation
     */
    select?: ProductVariationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductVariationInclude<ExtArgs> | null
    /**
     * The data needed to update a ProductVariation.
     */
    data: XOR<ProductVariationUpdateInput, ProductVariationUncheckedUpdateInput>
    /**
     * Choose, which ProductVariation to update.
     */
    where: ProductVariationWhereUniqueInput
  }

  /**
   * ProductVariation updateMany
   */
  export type ProductVariationUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ProductVariations.
     */
    data: XOR<ProductVariationUpdateManyMutationInput, ProductVariationUncheckedUpdateManyInput>
    /**
     * Filter which ProductVariations to update
     */
    where?: ProductVariationWhereInput
  }

  /**
   * ProductVariation upsert
   */
  export type ProductVariationUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductVariation
     */
    select?: ProductVariationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductVariationInclude<ExtArgs> | null
    /**
     * The filter to search for the ProductVariation to update in case it exists.
     */
    where: ProductVariationWhereUniqueInput
    /**
     * In case the ProductVariation found by the `where` argument doesn't exist, create a new ProductVariation with this data.
     */
    create: XOR<ProductVariationCreateInput, ProductVariationUncheckedCreateInput>
    /**
     * In case the ProductVariation was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ProductVariationUpdateInput, ProductVariationUncheckedUpdateInput>
  }

  /**
   * ProductVariation delete
   */
  export type ProductVariationDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductVariation
     */
    select?: ProductVariationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductVariationInclude<ExtArgs> | null
    /**
     * Filter which ProductVariation to delete.
     */
    where: ProductVariationWhereUniqueInput
  }

  /**
   * ProductVariation deleteMany
   */
  export type ProductVariationDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ProductVariations to delete
     */
    where?: ProductVariationWhereInput
  }

  /**
   * ProductVariation.ProductOrders
   */
  export type ProductVariation$ProductOrdersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductOrder
     */
    select?: ProductOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductOrderInclude<ExtArgs> | null
    where?: ProductOrderWhereInput
    orderBy?: ProductOrderOrderByWithRelationInput | ProductOrderOrderByWithRelationInput[]
    cursor?: ProductOrderWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ProductOrderScalarFieldEnum | ProductOrderScalarFieldEnum[]
  }

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


  /**
   * Model ProductInclude
   */

  export type AggregateProductInclude = {
    _count: ProductIncludeCountAggregateOutputType | null
    _avg: ProductIncludeAvgAggregateOutputType | null
    _sum: ProductIncludeSumAggregateOutputType | null
    _min: ProductIncludeMinAggregateOutputType | null
    _max: ProductIncludeMaxAggregateOutputType | null
  }

  export type ProductIncludeAvgAggregateOutputType = {
    increment: number | null
  }

  export type ProductIncludeSumAggregateOutputType = {
    increment: number | null
  }

  export type ProductIncludeMinAggregateOutputType = {
    id: string | null
    increment: number | null
    product_id: string | null
    description: string | null
  }

  export type ProductIncludeMaxAggregateOutputType = {
    id: string | null
    increment: number | null
    product_id: string | null
    description: string | null
  }

  export type ProductIncludeCountAggregateOutputType = {
    id: number
    increment: number
    product_id: number
    description: number
    _all: number
  }


  export type ProductIncludeAvgAggregateInputType = {
    increment?: true
  }

  export type ProductIncludeSumAggregateInputType = {
    increment?: true
  }

  export type ProductIncludeMinAggregateInputType = {
    id?: true
    increment?: true
    product_id?: true
    description?: true
  }

  export type ProductIncludeMaxAggregateInputType = {
    id?: true
    increment?: true
    product_id?: true
    description?: true
  }

  export type ProductIncludeCountAggregateInputType = {
    id?: true
    increment?: true
    product_id?: true
    description?: true
    _all?: true
  }

  export type ProductIncludeAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ProductInclude to aggregate.
     */
    where?: ProductIncludeWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ProductIncludes to fetch.
     */
    orderBy?: ProductIncludeOrderByWithRelationInput | ProductIncludeOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ProductIncludeWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ProductIncludes from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` ProductIncludes.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ProductIncludes
    **/
    _count?: true | ProductIncludeCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ProductIncludeAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ProductIncludeSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ProductIncludeMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ProductIncludeMaxAggregateInputType
  }

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




  export type ProductIncludeGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ProductIncludeWhereInput
    orderBy?: ProductIncludeOrderByWithAggregationInput | ProductIncludeOrderByWithAggregationInput[]
    by: ProductIncludeScalarFieldEnum[] | ProductIncludeScalarFieldEnum
    having?: ProductIncludeScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ProductIncludeCountAggregateInputType | true
    _avg?: ProductIncludeAvgAggregateInputType
    _sum?: ProductIncludeSumAggregateInputType
    _min?: ProductIncludeMinAggregateInputType
    _max?: ProductIncludeMaxAggregateInputType
  }

  export type ProductIncludeGroupByOutputType = {
    id: string
    increment: number
    product_id: string
    description: string
    _count: ProductIncludeCountAggregateOutputType | null
    _avg: ProductIncludeAvgAggregateOutputType | null
    _sum: ProductIncludeSumAggregateOutputType | null
    _min: ProductIncludeMinAggregateOutputType | null
    _max: ProductIncludeMaxAggregateOutputType | null
  }

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


  export type ProductIncludeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    increment?: boolean
    product_id?: boolean
    description?: boolean
    Product?: boolean | ProductDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["productInclude"]>


  export type ProductIncludeSelectScalar = {
    id?: boolean
    increment?: boolean
    product_id?: boolean
    description?: boolean
  }

  export type ProductIncludeInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Product?: boolean | ProductDefaultArgs<ExtArgs>
  }

  export type $ProductIncludePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ProductInclude"
    objects: {
      Product: Prisma.$ProductPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      increment: number
      product_id: string
      description: string
    }, ExtArgs["result"]["productInclude"]>
    composites: {}
  }

  type ProductIncludeGetPayload<S extends boolean | null | undefined | ProductIncludeDefaultArgs> = $Result.GetResult<Prisma.$ProductIncludePayload, S>

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

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

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

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

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

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

    /**
     * Create a ProductInclude.
     * @param {ProductIncludeCreateArgs} args - Arguments to create a ProductInclude.
     * @example
     * // Create one ProductInclude
     * const ProductInclude = await prisma.productInclude.create({
     *   data: {
     *     // ... data to create a ProductInclude
     *   }
     * })
     * 
     */
    create<T extends ProductIncludeCreateArgs>(args: SelectSubset<T, ProductIncludeCreateArgs<ExtArgs>>): Prisma__ProductIncludeClient<$Result.GetResult<Prisma.$ProductIncludePayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Delete a ProductInclude.
     * @param {ProductIncludeDeleteArgs} args - Arguments to delete one ProductInclude.
     * @example
     * // Delete one ProductInclude
     * const ProductInclude = await prisma.productInclude.delete({
     *   where: {
     *     // ... filter to delete one ProductInclude
     *   }
     * })
     * 
     */
    delete<T extends ProductIncludeDeleteArgs>(args: SelectSubset<T, ProductIncludeDeleteArgs<ExtArgs>>): Prisma__ProductIncludeClient<$Result.GetResult<Prisma.$ProductIncludePayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for ProductInclude.
   * 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__ProductIncludeClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    Product<T extends ProductDefaultArgs<ExtArgs> = {}>(args?: Subset<T, ProductDefaultArgs<ExtArgs>>): Prisma__ProductClient<$Result.GetResult<Prisma.$ProductPayload<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 ProductInclude model
   */ 
  interface ProductIncludeFieldRefs {
    readonly id: FieldRef<"ProductInclude", 'String'>
    readonly increment: FieldRef<"ProductInclude", 'Int'>
    readonly product_id: FieldRef<"ProductInclude", 'String'>
    readonly description: FieldRef<"ProductInclude", 'String'>
  }
    

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

  /**
   * ProductInclude findUniqueOrThrow
   */
  export type ProductIncludeFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductInclude
     */
    select?: ProductIncludeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductIncludeInclude<ExtArgs> | null
    /**
     * Filter, which ProductInclude to fetch.
     */
    where: ProductIncludeWhereUniqueInput
  }

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

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

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

  /**
   * ProductInclude create
   */
  export type ProductIncludeCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductInclude
     */
    select?: ProductIncludeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductIncludeInclude<ExtArgs> | null
    /**
     * The data needed to create a ProductInclude.
     */
    data: XOR<ProductIncludeCreateInput, ProductIncludeUncheckedCreateInput>
  }

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

  /**
   * ProductInclude update
   */
  export type ProductIncludeUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductInclude
     */
    select?: ProductIncludeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductIncludeInclude<ExtArgs> | null
    /**
     * The data needed to update a ProductInclude.
     */
    data: XOR<ProductIncludeUpdateInput, ProductIncludeUncheckedUpdateInput>
    /**
     * Choose, which ProductInclude to update.
     */
    where: ProductIncludeWhereUniqueInput
  }

  /**
   * ProductInclude updateMany
   */
  export type ProductIncludeUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ProductIncludes.
     */
    data: XOR<ProductIncludeUpdateManyMutationInput, ProductIncludeUncheckedUpdateManyInput>
    /**
     * Filter which ProductIncludes to update
     */
    where?: ProductIncludeWhereInput
  }

  /**
   * ProductInclude upsert
   */
  export type ProductIncludeUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductInclude
     */
    select?: ProductIncludeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductIncludeInclude<ExtArgs> | null
    /**
     * The filter to search for the ProductInclude to update in case it exists.
     */
    where: ProductIncludeWhereUniqueInput
    /**
     * In case the ProductInclude found by the `where` argument doesn't exist, create a new ProductInclude with this data.
     */
    create: XOR<ProductIncludeCreateInput, ProductIncludeUncheckedCreateInput>
    /**
     * In case the ProductInclude was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ProductIncludeUpdateInput, ProductIncludeUncheckedUpdateInput>
  }

  /**
   * ProductInclude delete
   */
  export type ProductIncludeDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductInclude
     */
    select?: ProductIncludeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductIncludeInclude<ExtArgs> | null
    /**
     * Filter which ProductInclude to delete.
     */
    where: ProductIncludeWhereUniqueInput
  }

  /**
   * ProductInclude deleteMany
   */
  export type ProductIncludeDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ProductIncludes to delete
     */
    where?: ProductIncludeWhereInput
  }

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


  /**
   * Model ProductExclude
   */

  export type AggregateProductExclude = {
    _count: ProductExcludeCountAggregateOutputType | null
    _avg: ProductExcludeAvgAggregateOutputType | null
    _sum: ProductExcludeSumAggregateOutputType | null
    _min: ProductExcludeMinAggregateOutputType | null
    _max: ProductExcludeMaxAggregateOutputType | null
  }

  export type ProductExcludeAvgAggregateOutputType = {
    increment: number | null
  }

  export type ProductExcludeSumAggregateOutputType = {
    increment: number | null
  }

  export type ProductExcludeMinAggregateOutputType = {
    id: string | null
    increment: number | null
    product_id: string | null
    description: string | null
  }

  export type ProductExcludeMaxAggregateOutputType = {
    id: string | null
    increment: number | null
    product_id: string | null
    description: string | null
  }

  export type ProductExcludeCountAggregateOutputType = {
    id: number
    increment: number
    product_id: number
    description: number
    _all: number
  }


  export type ProductExcludeAvgAggregateInputType = {
    increment?: true
  }

  export type ProductExcludeSumAggregateInputType = {
    increment?: true
  }

  export type ProductExcludeMinAggregateInputType = {
    id?: true
    increment?: true
    product_id?: true
    description?: true
  }

  export type ProductExcludeMaxAggregateInputType = {
    id?: true
    increment?: true
    product_id?: true
    description?: true
  }

  export type ProductExcludeCountAggregateInputType = {
    id?: true
    increment?: true
    product_id?: true
    description?: true
    _all?: true
  }

  export type ProductExcludeAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ProductExclude to aggregate.
     */
    where?: ProductExcludeWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ProductExcludes to fetch.
     */
    orderBy?: ProductExcludeOrderByWithRelationInput | ProductExcludeOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ProductExcludeWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ProductExcludes from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` ProductExcludes.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ProductExcludes
    **/
    _count?: true | ProductExcludeCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ProductExcludeAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ProductExcludeSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ProductExcludeMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ProductExcludeMaxAggregateInputType
  }

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




  export type ProductExcludeGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ProductExcludeWhereInput
    orderBy?: ProductExcludeOrderByWithAggregationInput | ProductExcludeOrderByWithAggregationInput[]
    by: ProductExcludeScalarFieldEnum[] | ProductExcludeScalarFieldEnum
    having?: ProductExcludeScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ProductExcludeCountAggregateInputType | true
    _avg?: ProductExcludeAvgAggregateInputType
    _sum?: ProductExcludeSumAggregateInputType
    _min?: ProductExcludeMinAggregateInputType
    _max?: ProductExcludeMaxAggregateInputType
  }

  export type ProductExcludeGroupByOutputType = {
    id: string
    increment: number
    product_id: string
    description: string
    _count: ProductExcludeCountAggregateOutputType | null
    _avg: ProductExcludeAvgAggregateOutputType | null
    _sum: ProductExcludeSumAggregateOutputType | null
    _min: ProductExcludeMinAggregateOutputType | null
    _max: ProductExcludeMaxAggregateOutputType | null
  }

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


  export type ProductExcludeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    increment?: boolean
    product_id?: boolean
    description?: boolean
    Product?: boolean | ProductDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["productExclude"]>


  export type ProductExcludeSelectScalar = {
    id?: boolean
    increment?: boolean
    product_id?: boolean
    description?: boolean
  }

  export type ProductExcludeInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Product?: boolean | ProductDefaultArgs<ExtArgs>
  }

  export type $ProductExcludePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ProductExclude"
    objects: {
      Product: Prisma.$ProductPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      increment: number
      product_id: string
      description: string
    }, ExtArgs["result"]["productExclude"]>
    composites: {}
  }

  type ProductExcludeGetPayload<S extends boolean | null | undefined | ProductExcludeDefaultArgs> = $Result.GetResult<Prisma.$ProductExcludePayload, S>

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

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

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

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

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

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

    /**
     * Create a ProductExclude.
     * @param {ProductExcludeCreateArgs} args - Arguments to create a ProductExclude.
     * @example
     * // Create one ProductExclude
     * const ProductExclude = await prisma.productExclude.create({
     *   data: {
     *     // ... data to create a ProductExclude
     *   }
     * })
     * 
     */
    create<T extends ProductExcludeCreateArgs>(args: SelectSubset<T, ProductExcludeCreateArgs<ExtArgs>>): Prisma__ProductExcludeClient<$Result.GetResult<Prisma.$ProductExcludePayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Delete a ProductExclude.
     * @param {ProductExcludeDeleteArgs} args - Arguments to delete one ProductExclude.
     * @example
     * // Delete one ProductExclude
     * const ProductExclude = await prisma.productExclude.delete({
     *   where: {
     *     // ... filter to delete one ProductExclude
     *   }
     * })
     * 
     */
    delete<T extends ProductExcludeDeleteArgs>(args: SelectSubset<T, ProductExcludeDeleteArgs<ExtArgs>>): Prisma__ProductExcludeClient<$Result.GetResult<Prisma.$ProductExcludePayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for ProductExclude.
   * 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__ProductExcludeClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    Product<T extends ProductDefaultArgs<ExtArgs> = {}>(args?: Subset<T, ProductDefaultArgs<ExtArgs>>): Prisma__ProductClient<$Result.GetResult<Prisma.$ProductPayload<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 ProductExclude model
   */ 
  interface ProductExcludeFieldRefs {
    readonly id: FieldRef<"ProductExclude", 'String'>
    readonly increment: FieldRef<"ProductExclude", 'Int'>
    readonly product_id: FieldRef<"ProductExclude", 'String'>
    readonly description: FieldRef<"ProductExclude", 'String'>
  }
    

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

  /**
   * ProductExclude findUniqueOrThrow
   */
  export type ProductExcludeFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductExclude
     */
    select?: ProductExcludeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductExcludeInclude<ExtArgs> | null
    /**
     * Filter, which ProductExclude to fetch.
     */
    where: ProductExcludeWhereUniqueInput
  }

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

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

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

  /**
   * ProductExclude create
   */
  export type ProductExcludeCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductExclude
     */
    select?: ProductExcludeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductExcludeInclude<ExtArgs> | null
    /**
     * The data needed to create a ProductExclude.
     */
    data: XOR<ProductExcludeCreateInput, ProductExcludeUncheckedCreateInput>
  }

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

  /**
   * ProductExclude update
   */
  export type ProductExcludeUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductExclude
     */
    select?: ProductExcludeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductExcludeInclude<ExtArgs> | null
    /**
     * The data needed to update a ProductExclude.
     */
    data: XOR<ProductExcludeUpdateInput, ProductExcludeUncheckedUpdateInput>
    /**
     * Choose, which ProductExclude to update.
     */
    where: ProductExcludeWhereUniqueInput
  }

  /**
   * ProductExclude updateMany
   */
  export type ProductExcludeUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ProductExcludes.
     */
    data: XOR<ProductExcludeUpdateManyMutationInput, ProductExcludeUncheckedUpdateManyInput>
    /**
     * Filter which ProductExcludes to update
     */
    where?: ProductExcludeWhereInput
  }

  /**
   * ProductExclude upsert
   */
  export type ProductExcludeUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductExclude
     */
    select?: ProductExcludeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductExcludeInclude<ExtArgs> | null
    /**
     * The filter to search for the ProductExclude to update in case it exists.
     */
    where: ProductExcludeWhereUniqueInput
    /**
     * In case the ProductExclude found by the `where` argument doesn't exist, create a new ProductExclude with this data.
     */
    create: XOR<ProductExcludeCreateInput, ProductExcludeUncheckedCreateInput>
    /**
     * In case the ProductExclude was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ProductExcludeUpdateInput, ProductExcludeUncheckedUpdateInput>
  }

  /**
   * ProductExclude delete
   */
  export type ProductExcludeDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductExclude
     */
    select?: ProductExcludeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductExcludeInclude<ExtArgs> | null
    /**
     * Filter which ProductExclude to delete.
     */
    where: ProductExcludeWhereUniqueInput
  }

  /**
   * ProductExclude deleteMany
   */
  export type ProductExcludeDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ProductExcludes to delete
     */
    where?: ProductExcludeWhereInput
  }

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


  /**
   * Model ProductOrder
   */

  export type AggregateProductOrder = {
    _count: ProductOrderCountAggregateOutputType | null
    _avg: ProductOrderAvgAggregateOutputType | null
    _sum: ProductOrderSumAggregateOutputType | null
    _min: ProductOrderMinAggregateOutputType | null
    _max: ProductOrderMaxAggregateOutputType | null
  }

  export type ProductOrderAvgAggregateOutputType = {
    number_of_pax: number | null
    per_pax_price: Decimal | null
    total_price: Decimal | null
  }

  export type ProductOrderSumAggregateOutputType = {
    number_of_pax: number | null
    per_pax_price: Decimal | null
    total_price: Decimal | null
  }

  export type ProductOrderMinAggregateOutputType = {
    id: string | null
    user_id: string | null
    product_id: string | null
    variation_id: string | null
    departure: Date | null
    number_of_pax: number | null
    per_pax_price: Decimal | null
    total_price: Decimal | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type ProductOrderMaxAggregateOutputType = {
    id: string | null
    user_id: string | null
    product_id: string | null
    variation_id: string | null
    departure: Date | null
    number_of_pax: number | null
    per_pax_price: Decimal | null
    total_price: Decimal | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type ProductOrderCountAggregateOutputType = {
    id: number
    user_id: number
    product_id: number
    variation_id: number
    departure: number
    number_of_pax: number
    per_pax_price: number
    total_price: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type ProductOrderAvgAggregateInputType = {
    number_of_pax?: true
    per_pax_price?: true
    total_price?: true
  }

  export type ProductOrderSumAggregateInputType = {
    number_of_pax?: true
    per_pax_price?: true
    total_price?: true
  }

  export type ProductOrderMinAggregateInputType = {
    id?: true
    user_id?: true
    product_id?: true
    variation_id?: true
    departure?: true
    number_of_pax?: true
    per_pax_price?: true
    total_price?: true
    created_at?: true
    updated_at?: true
  }

  export type ProductOrderMaxAggregateInputType = {
    id?: true
    user_id?: true
    product_id?: true
    variation_id?: true
    departure?: true
    number_of_pax?: true
    per_pax_price?: true
    total_price?: true
    created_at?: true
    updated_at?: true
  }

  export type ProductOrderCountAggregateInputType = {
    id?: true
    user_id?: true
    product_id?: true
    variation_id?: true
    departure?: true
    number_of_pax?: true
    per_pax_price?: true
    total_price?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type ProductOrderAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ProductOrder to aggregate.
     */
    where?: ProductOrderWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ProductOrders to fetch.
     */
    orderBy?: ProductOrderOrderByWithRelationInput | ProductOrderOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ProductOrderWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ProductOrders from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` ProductOrders.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ProductOrders
    **/
    _count?: true | ProductOrderCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ProductOrderAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ProductOrderSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ProductOrderMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ProductOrderMaxAggregateInputType
  }

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




  export type ProductOrderGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ProductOrderWhereInput
    orderBy?: ProductOrderOrderByWithAggregationInput | ProductOrderOrderByWithAggregationInput[]
    by: ProductOrderScalarFieldEnum[] | ProductOrderScalarFieldEnum
    having?: ProductOrderScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ProductOrderCountAggregateInputType | true
    _avg?: ProductOrderAvgAggregateInputType
    _sum?: ProductOrderSumAggregateInputType
    _min?: ProductOrderMinAggregateInputType
    _max?: ProductOrderMaxAggregateInputType
  }

  export type ProductOrderGroupByOutputType = {
    id: string
    user_id: string
    product_id: string
    variation_id: string | null
    departure: Date
    number_of_pax: number
    per_pax_price: Decimal
    total_price: Decimal
    created_at: Date
    updated_at: Date
    _count: ProductOrderCountAggregateOutputType | null
    _avg: ProductOrderAvgAggregateOutputType | null
    _sum: ProductOrderSumAggregateOutputType | null
    _min: ProductOrderMinAggregateOutputType | null
    _max: ProductOrderMaxAggregateOutputType | null
  }

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


  export type ProductOrderSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    user_id?: boolean
    product_id?: boolean
    variation_id?: boolean
    departure?: boolean
    number_of_pax?: boolean
    per_pax_price?: boolean
    total_price?: boolean
    created_at?: boolean
    updated_at?: boolean
    User?: boolean | UserDefaultArgs<ExtArgs>
    Product?: boolean | ProductDefaultArgs<ExtArgs>
    ProductVariation?: boolean | ProductOrder$ProductVariationArgs<ExtArgs>
  }, ExtArgs["result"]["productOrder"]>


  export type ProductOrderSelectScalar = {
    id?: boolean
    user_id?: boolean
    product_id?: boolean
    variation_id?: boolean
    departure?: boolean
    number_of_pax?: boolean
    per_pax_price?: boolean
    total_price?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type ProductOrderInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    User?: boolean | UserDefaultArgs<ExtArgs>
    Product?: boolean | ProductDefaultArgs<ExtArgs>
    ProductVariation?: boolean | ProductOrder$ProductVariationArgs<ExtArgs>
  }

  export type $ProductOrderPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ProductOrder"
    objects: {
      User: Prisma.$UserPayload<ExtArgs>
      Product: Prisma.$ProductPayload<ExtArgs>
      ProductVariation: Prisma.$ProductVariationPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      user_id: string
      product_id: string
      variation_id: string | null
      departure: Date
      number_of_pax: number
      per_pax_price: Prisma.Decimal
      total_price: Prisma.Decimal
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["productOrder"]>
    composites: {}
  }

  type ProductOrderGetPayload<S extends boolean | null | undefined | ProductOrderDefaultArgs> = $Result.GetResult<Prisma.$ProductOrderPayload, S>

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

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

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

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

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

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

    /**
     * Create a ProductOrder.
     * @param {ProductOrderCreateArgs} args - Arguments to create a ProductOrder.
     * @example
     * // Create one ProductOrder
     * const ProductOrder = await prisma.productOrder.create({
     *   data: {
     *     // ... data to create a ProductOrder
     *   }
     * })
     * 
     */
    create<T extends ProductOrderCreateArgs>(args: SelectSubset<T, ProductOrderCreateArgs<ExtArgs>>): Prisma__ProductOrderClient<$Result.GetResult<Prisma.$ProductOrderPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Delete a ProductOrder.
     * @param {ProductOrderDeleteArgs} args - Arguments to delete one ProductOrder.
     * @example
     * // Delete one ProductOrder
     * const ProductOrder = await prisma.productOrder.delete({
     *   where: {
     *     // ... filter to delete one ProductOrder
     *   }
     * })
     * 
     */
    delete<T extends ProductOrderDeleteArgs>(args: SelectSubset<T, ProductOrderDeleteArgs<ExtArgs>>): Prisma__ProductOrderClient<$Result.GetResult<Prisma.$ProductOrderPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for ProductOrder.
   * 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__ProductOrderClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    User<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    Product<T extends ProductDefaultArgs<ExtArgs> = {}>(args?: Subset<T, ProductDefaultArgs<ExtArgs>>): Prisma__ProductClient<$Result.GetResult<Prisma.$ProductPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    ProductVariation<T extends ProductOrder$ProductVariationArgs<ExtArgs> = {}>(args?: Subset<T, ProductOrder$ProductVariationArgs<ExtArgs>>): Prisma__ProductVariationClient<$Result.GetResult<Prisma.$ProductVariationPayload<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 ProductOrder model
   */ 
  interface ProductOrderFieldRefs {
    readonly id: FieldRef<"ProductOrder", 'String'>
    readonly user_id: FieldRef<"ProductOrder", 'String'>
    readonly product_id: FieldRef<"ProductOrder", 'String'>
    readonly variation_id: FieldRef<"ProductOrder", 'String'>
    readonly departure: FieldRef<"ProductOrder", 'DateTime'>
    readonly number_of_pax: FieldRef<"ProductOrder", 'Int'>
    readonly per_pax_price: FieldRef<"ProductOrder", 'Decimal'>
    readonly total_price: FieldRef<"ProductOrder", 'Decimal'>
    readonly created_at: FieldRef<"ProductOrder", 'DateTime'>
    readonly updated_at: FieldRef<"ProductOrder", 'DateTime'>
  }
    

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

  /**
   * ProductOrder findUniqueOrThrow
   */
  export type ProductOrderFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductOrder
     */
    select?: ProductOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductOrderInclude<ExtArgs> | null
    /**
     * Filter, which ProductOrder to fetch.
     */
    where: ProductOrderWhereUniqueInput
  }

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

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

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

  /**
   * ProductOrder create
   */
  export type ProductOrderCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductOrder
     */
    select?: ProductOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductOrderInclude<ExtArgs> | null
    /**
     * The data needed to create a ProductOrder.
     */
    data: XOR<ProductOrderCreateInput, ProductOrderUncheckedCreateInput>
  }

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

  /**
   * ProductOrder update
   */
  export type ProductOrderUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductOrder
     */
    select?: ProductOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductOrderInclude<ExtArgs> | null
    /**
     * The data needed to update a ProductOrder.
     */
    data: XOR<ProductOrderUpdateInput, ProductOrderUncheckedUpdateInput>
    /**
     * Choose, which ProductOrder to update.
     */
    where: ProductOrderWhereUniqueInput
  }

  /**
   * ProductOrder updateMany
   */
  export type ProductOrderUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ProductOrders.
     */
    data: XOR<ProductOrderUpdateManyMutationInput, ProductOrderUncheckedUpdateManyInput>
    /**
     * Filter which ProductOrders to update
     */
    where?: ProductOrderWhereInput
  }

  /**
   * ProductOrder upsert
   */
  export type ProductOrderUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductOrder
     */
    select?: ProductOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductOrderInclude<ExtArgs> | null
    /**
     * The filter to search for the ProductOrder to update in case it exists.
     */
    where: ProductOrderWhereUniqueInput
    /**
     * In case the ProductOrder found by the `where` argument doesn't exist, create a new ProductOrder with this data.
     */
    create: XOR<ProductOrderCreateInput, ProductOrderUncheckedCreateInput>
    /**
     * In case the ProductOrder was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ProductOrderUpdateInput, ProductOrderUncheckedUpdateInput>
  }

  /**
   * ProductOrder delete
   */
  export type ProductOrderDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductOrder
     */
    select?: ProductOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductOrderInclude<ExtArgs> | null
    /**
     * Filter which ProductOrder to delete.
     */
    where: ProductOrderWhereUniqueInput
  }

  /**
   * ProductOrder deleteMany
   */
  export type ProductOrderDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ProductOrders to delete
     */
    where?: ProductOrderWhereInput
  }

  /**
   * ProductOrder.ProductVariation
   */
  export type ProductOrder$ProductVariationArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductVariation
     */
    select?: ProductVariationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductVariationInclude<ExtArgs> | null
    where?: ProductVariationWhereInput
  }

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


  /**
   * Model Vendor
   */

  export type AggregateVendor = {
    _count: VendorCountAggregateOutputType | null
    _min: VendorMinAggregateOutputType | null
    _max: VendorMaxAggregateOutputType | null
  }

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

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

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


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

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

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

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

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




  export type VendorGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: VendorWhereInput
    orderBy?: VendorOrderByWithAggregationInput | VendorOrderByWithAggregationInput[]
    by: VendorScalarFieldEnum[] | VendorScalarFieldEnum
    having?: VendorScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: VendorCountAggregateInputType | true
    _min?: VendorMinAggregateInputType
    _max?: VendorMaxAggregateInputType
  }

  export type VendorGroupByOutputType = {
    id: string
    name: string
    created_at: Date
    updated_at: Date
    _count: VendorCountAggregateOutputType | null
    _min: VendorMinAggregateOutputType | null
    _max: VendorMaxAggregateOutputType | null
  }

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


  export type VendorSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    created_at?: boolean
    updated_at?: boolean
    Hotels?: boolean | Vendor$HotelsArgs<ExtArgs>
    MitraPackages?: boolean | Vendor$MitraPackagesArgs<ExtArgs>
    _count?: boolean | VendorCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["vendor"]>


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

  export type VendorInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Hotels?: boolean | Vendor$HotelsArgs<ExtArgs>
    MitraPackages?: boolean | Vendor$MitraPackagesArgs<ExtArgs>
    _count?: boolean | VendorCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $VendorPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Vendor"
    objects: {
      Hotels: Prisma.$HotelPayload<ExtArgs>[]
      MitraPackages: Prisma.$MitraPackagePayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["vendor"]>
    composites: {}
  }

  type VendorGetPayload<S extends boolean | null | undefined | VendorDefaultArgs> = $Result.GetResult<Prisma.$VendorPayload, S>

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

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

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

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

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

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

    /**
     * Create a Vendor.
     * @param {VendorCreateArgs} args - Arguments to create a Vendor.
     * @example
     * // Create one Vendor
     * const Vendor = await prisma.vendor.create({
     *   data: {
     *     // ... data to create a Vendor
     *   }
     * })
     * 
     */
    create<T extends VendorCreateArgs>(args: SelectSubset<T, VendorCreateArgs<ExtArgs>>): Prisma__VendorClient<$Result.GetResult<Prisma.$VendorPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Delete a Vendor.
     * @param {VendorDeleteArgs} args - Arguments to delete one Vendor.
     * @example
     * // Delete one Vendor
     * const Vendor = await prisma.vendor.delete({
     *   where: {
     *     // ... filter to delete one Vendor
     *   }
     * })
     * 
     */
    delete<T extends VendorDeleteArgs>(args: SelectSubset<T, VendorDeleteArgs<ExtArgs>>): Prisma__VendorClient<$Result.GetResult<Prisma.$VendorPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Vendor.
   * 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__VendorClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    Hotels<T extends Vendor$HotelsArgs<ExtArgs> = {}>(args?: Subset<T, Vendor$HotelsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$HotelPayload<ExtArgs>, T, "findMany"> | Null>
    MitraPackages<T extends Vendor$MitraPackagesArgs<ExtArgs> = {}>(args?: Subset<T, Vendor$MitraPackagesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MitraPackagePayload<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 Vendor model
   */ 
  interface VendorFieldRefs {
    readonly id: FieldRef<"Vendor", 'String'>
    readonly name: FieldRef<"Vendor", 'String'>
    readonly created_at: FieldRef<"Vendor", 'DateTime'>
    readonly updated_at: FieldRef<"Vendor", 'DateTime'>
  }
    

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

  /**
   * Vendor findUniqueOrThrow
   */
  export type VendorFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Vendor
     */
    select?: VendorSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VendorInclude<ExtArgs> | null
    /**
     * Filter, which Vendor to fetch.
     */
    where: VendorWhereUniqueInput
  }

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

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

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

  /**
   * Vendor create
   */
  export type VendorCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Vendor
     */
    select?: VendorSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VendorInclude<ExtArgs> | null
    /**
     * The data needed to create a Vendor.
     */
    data: XOR<VendorCreateInput, VendorUncheckedCreateInput>
  }

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

  /**
   * Vendor update
   */
  export type VendorUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Vendor
     */
    select?: VendorSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VendorInclude<ExtArgs> | null
    /**
     * The data needed to update a Vendor.
     */
    data: XOR<VendorUpdateInput, VendorUncheckedUpdateInput>
    /**
     * Choose, which Vendor to update.
     */
    where: VendorWhereUniqueInput
  }

  /**
   * Vendor updateMany
   */
  export type VendorUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Vendors.
     */
    data: XOR<VendorUpdateManyMutationInput, VendorUncheckedUpdateManyInput>
    /**
     * Filter which Vendors to update
     */
    where?: VendorWhereInput
  }

  /**
   * Vendor upsert
   */
  export type VendorUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Vendor
     */
    select?: VendorSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VendorInclude<ExtArgs> | null
    /**
     * The filter to search for the Vendor to update in case it exists.
     */
    where: VendorWhereUniqueInput
    /**
     * In case the Vendor found by the `where` argument doesn't exist, create a new Vendor with this data.
     */
    create: XOR<VendorCreateInput, VendorUncheckedCreateInput>
    /**
     * In case the Vendor was found with the provided `where` argument, update it with this data.
     */
    update: XOR<VendorUpdateInput, VendorUncheckedUpdateInput>
  }

  /**
   * Vendor delete
   */
  export type VendorDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Vendor
     */
    select?: VendorSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VendorInclude<ExtArgs> | null
    /**
     * Filter which Vendor to delete.
     */
    where: VendorWhereUniqueInput
  }

  /**
   * Vendor deleteMany
   */
  export type VendorDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Vendors to delete
     */
    where?: VendorWhereInput
  }

  /**
   * Vendor.Hotels
   */
  export type Vendor$HotelsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Hotel
     */
    select?: HotelSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: HotelInclude<ExtArgs> | null
    where?: HotelWhereInput
    orderBy?: HotelOrderByWithRelationInput | HotelOrderByWithRelationInput[]
    cursor?: HotelWhereUniqueInput
    take?: number
    skip?: number
    distinct?: HotelScalarFieldEnum | HotelScalarFieldEnum[]
  }

  /**
   * Vendor.MitraPackages
   */
  export type Vendor$MitraPackagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackage
     */
    select?: MitraPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageInclude<ExtArgs> | null
    where?: MitraPackageWhereInput
    orderBy?: MitraPackageOrderByWithRelationInput | MitraPackageOrderByWithRelationInput[]
    cursor?: MitraPackageWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MitraPackageScalarFieldEnum | MitraPackageScalarFieldEnum[]
  }

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


  /**
   * Model Hotel
   */

  export type AggregateHotel = {
    _count: HotelCountAggregateOutputType | null
    _avg: HotelAvgAggregateOutputType | null
    _sum: HotelSumAggregateOutputType | null
    _min: HotelMinAggregateOutputType | null
    _max: HotelMaxAggregateOutputType | null
  }

  export type HotelAvgAggregateOutputType = {
    order_number: number | null
  }

  export type HotelSumAggregateOutputType = {
    order_number: number | null
  }

  export type HotelMinAggregateOutputType = {
    id: string | null
    vendor_id: string | null
    name: string | null
    city: $Enums.City | null
    order_number: number | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type HotelMaxAggregateOutputType = {
    id: string | null
    vendor_id: string | null
    name: string | null
    city: $Enums.City | null
    order_number: number | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type HotelCountAggregateOutputType = {
    id: number
    vendor_id: number
    name: number
    city: number
    order_number: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type HotelAvgAggregateInputType = {
    order_number?: true
  }

  export type HotelSumAggregateInputType = {
    order_number?: true
  }

  export type HotelMinAggregateInputType = {
    id?: true
    vendor_id?: true
    name?: true
    city?: true
    order_number?: true
    created_at?: true
    updated_at?: true
  }

  export type HotelMaxAggregateInputType = {
    id?: true
    vendor_id?: true
    name?: true
    city?: true
    order_number?: true
    created_at?: true
    updated_at?: true
  }

  export type HotelCountAggregateInputType = {
    id?: true
    vendor_id?: true
    name?: true
    city?: true
    order_number?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type HotelAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Hotel to aggregate.
     */
    where?: HotelWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Hotels to fetch.
     */
    orderBy?: HotelOrderByWithRelationInput | HotelOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: HotelWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Hotels from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Hotels.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Hotels
    **/
    _count?: true | HotelCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: HotelAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: HotelSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: HotelMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: HotelMaxAggregateInputType
  }

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




  export type HotelGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: HotelWhereInput
    orderBy?: HotelOrderByWithAggregationInput | HotelOrderByWithAggregationInput[]
    by: HotelScalarFieldEnum[] | HotelScalarFieldEnum
    having?: HotelScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: HotelCountAggregateInputType | true
    _avg?: HotelAvgAggregateInputType
    _sum?: HotelSumAggregateInputType
    _min?: HotelMinAggregateInputType
    _max?: HotelMaxAggregateInputType
  }

  export type HotelGroupByOutputType = {
    id: string
    vendor_id: string
    name: string
    city: $Enums.City
    order_number: number
    created_at: Date
    updated_at: Date
    _count: HotelCountAggregateOutputType | null
    _avg: HotelAvgAggregateOutputType | null
    _sum: HotelSumAggregateOutputType | null
    _min: HotelMinAggregateOutputType | null
    _max: HotelMaxAggregateOutputType | null
  }

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


  export type HotelSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    vendor_id?: boolean
    name?: boolean
    city?: boolean
    order_number?: boolean
    created_at?: boolean
    updated_at?: boolean
    Vendor?: boolean | VendorDefaultArgs<ExtArgs>
    HotelPeriodPrices?: boolean | Hotel$HotelPeriodPricesArgs<ExtArgs>
    MitraPackagesMekkah?: boolean | Hotel$MitraPackagesMekkahArgs<ExtArgs>
    MitraPackagesMadinah?: boolean | Hotel$MitraPackagesMadinahArgs<ExtArgs>
    _count?: boolean | HotelCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["hotel"]>


  export type HotelSelectScalar = {
    id?: boolean
    vendor_id?: boolean
    name?: boolean
    city?: boolean
    order_number?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type HotelInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Vendor?: boolean | VendorDefaultArgs<ExtArgs>
    HotelPeriodPrices?: boolean | Hotel$HotelPeriodPricesArgs<ExtArgs>
    MitraPackagesMekkah?: boolean | Hotel$MitraPackagesMekkahArgs<ExtArgs>
    MitraPackagesMadinah?: boolean | Hotel$MitraPackagesMadinahArgs<ExtArgs>
    _count?: boolean | HotelCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $HotelPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Hotel"
    objects: {
      Vendor: Prisma.$VendorPayload<ExtArgs>
      HotelPeriodPrices: Prisma.$HotelPeriodPricePayload<ExtArgs>[]
      MitraPackagesMekkah: Prisma.$MitraPackagePayload<ExtArgs>[]
      MitraPackagesMadinah: Prisma.$MitraPackagePayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      vendor_id: string
      name: string
      city: $Enums.City
      order_number: number
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["hotel"]>
    composites: {}
  }

  type HotelGetPayload<S extends boolean | null | undefined | HotelDefaultArgs> = $Result.GetResult<Prisma.$HotelPayload, S>

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

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

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

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

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

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

    /**
     * Create a Hotel.
     * @param {HotelCreateArgs} args - Arguments to create a Hotel.
     * @example
     * // Create one Hotel
     * const Hotel = await prisma.hotel.create({
     *   data: {
     *     // ... data to create a Hotel
     *   }
     * })
     * 
     */
    create<T extends HotelCreateArgs>(args: SelectSubset<T, HotelCreateArgs<ExtArgs>>): Prisma__HotelClient<$Result.GetResult<Prisma.$HotelPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Delete a Hotel.
     * @param {HotelDeleteArgs} args - Arguments to delete one Hotel.
     * @example
     * // Delete one Hotel
     * const Hotel = await prisma.hotel.delete({
     *   where: {
     *     // ... filter to delete one Hotel
     *   }
     * })
     * 
     */
    delete<T extends HotelDeleteArgs>(args: SelectSubset<T, HotelDeleteArgs<ExtArgs>>): Prisma__HotelClient<$Result.GetResult<Prisma.$HotelPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Hotel.
   * 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__HotelClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    Vendor<T extends VendorDefaultArgs<ExtArgs> = {}>(args?: Subset<T, VendorDefaultArgs<ExtArgs>>): Prisma__VendorClient<$Result.GetResult<Prisma.$VendorPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    HotelPeriodPrices<T extends Hotel$HotelPeriodPricesArgs<ExtArgs> = {}>(args?: Subset<T, Hotel$HotelPeriodPricesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$HotelPeriodPricePayload<ExtArgs>, T, "findMany"> | Null>
    MitraPackagesMekkah<T extends Hotel$MitraPackagesMekkahArgs<ExtArgs> = {}>(args?: Subset<T, Hotel$MitraPackagesMekkahArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MitraPackagePayload<ExtArgs>, T, "findMany"> | Null>
    MitraPackagesMadinah<T extends Hotel$MitraPackagesMadinahArgs<ExtArgs> = {}>(args?: Subset<T, Hotel$MitraPackagesMadinahArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MitraPackagePayload<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 Hotel model
   */ 
  interface HotelFieldRefs {
    readonly id: FieldRef<"Hotel", 'String'>
    readonly vendor_id: FieldRef<"Hotel", 'String'>
    readonly name: FieldRef<"Hotel", 'String'>
    readonly city: FieldRef<"Hotel", 'City'>
    readonly order_number: FieldRef<"Hotel", 'Int'>
    readonly created_at: FieldRef<"Hotel", 'DateTime'>
    readonly updated_at: FieldRef<"Hotel", 'DateTime'>
  }
    

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

  /**
   * Hotel findUniqueOrThrow
   */
  export type HotelFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Hotel
     */
    select?: HotelSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: HotelInclude<ExtArgs> | null
    /**
     * Filter, which Hotel to fetch.
     */
    where: HotelWhereUniqueInput
  }

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

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

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

  /**
   * Hotel create
   */
  export type HotelCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Hotel
     */
    select?: HotelSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: HotelInclude<ExtArgs> | null
    /**
     * The data needed to create a Hotel.
     */
    data: XOR<HotelCreateInput, HotelUncheckedCreateInput>
  }

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

  /**
   * Hotel update
   */
  export type HotelUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Hotel
     */
    select?: HotelSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: HotelInclude<ExtArgs> | null
    /**
     * The data needed to update a Hotel.
     */
    data: XOR<HotelUpdateInput, HotelUncheckedUpdateInput>
    /**
     * Choose, which Hotel to update.
     */
    where: HotelWhereUniqueInput
  }

  /**
   * Hotel updateMany
   */
  export type HotelUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Hotels.
     */
    data: XOR<HotelUpdateManyMutationInput, HotelUncheckedUpdateManyInput>
    /**
     * Filter which Hotels to update
     */
    where?: HotelWhereInput
  }

  /**
   * Hotel upsert
   */
  export type HotelUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Hotel
     */
    select?: HotelSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: HotelInclude<ExtArgs> | null
    /**
     * The filter to search for the Hotel to update in case it exists.
     */
    where: HotelWhereUniqueInput
    /**
     * In case the Hotel found by the `where` argument doesn't exist, create a new Hotel with this data.
     */
    create: XOR<HotelCreateInput, HotelUncheckedCreateInput>
    /**
     * In case the Hotel was found with the provided `where` argument, update it with this data.
     */
    update: XOR<HotelUpdateInput, HotelUncheckedUpdateInput>
  }

  /**
   * Hotel delete
   */
  export type HotelDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Hotel
     */
    select?: HotelSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: HotelInclude<ExtArgs> | null
    /**
     * Filter which Hotel to delete.
     */
    where: HotelWhereUniqueInput
  }

  /**
   * Hotel deleteMany
   */
  export type HotelDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Hotels to delete
     */
    where?: HotelWhereInput
  }

  /**
   * Hotel.HotelPeriodPrices
   */
  export type Hotel$HotelPeriodPricesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HotelPeriodPrice
     */
    select?: HotelPeriodPriceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: HotelPeriodPriceInclude<ExtArgs> | null
    where?: HotelPeriodPriceWhereInput
    orderBy?: HotelPeriodPriceOrderByWithRelationInput | HotelPeriodPriceOrderByWithRelationInput[]
    cursor?: HotelPeriodPriceWhereUniqueInput
    take?: number
    skip?: number
    distinct?: HotelPeriodPriceScalarFieldEnum | HotelPeriodPriceScalarFieldEnum[]
  }

  /**
   * Hotel.MitraPackagesMekkah
   */
  export type Hotel$MitraPackagesMekkahArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackage
     */
    select?: MitraPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageInclude<ExtArgs> | null
    where?: MitraPackageWhereInput
    orderBy?: MitraPackageOrderByWithRelationInput | MitraPackageOrderByWithRelationInput[]
    cursor?: MitraPackageWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MitraPackageScalarFieldEnum | MitraPackageScalarFieldEnum[]
  }

  /**
   * Hotel.MitraPackagesMadinah
   */
  export type Hotel$MitraPackagesMadinahArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackage
     */
    select?: MitraPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageInclude<ExtArgs> | null
    where?: MitraPackageWhereInput
    orderBy?: MitraPackageOrderByWithRelationInput | MitraPackageOrderByWithRelationInput[]
    cursor?: MitraPackageWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MitraPackageScalarFieldEnum | MitraPackageScalarFieldEnum[]
  }

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


  /**
   * Model Period
   */

  export type AggregatePeriod = {
    _count: PeriodCountAggregateOutputType | null
    _min: PeriodMinAggregateOutputType | null
    _max: PeriodMaxAggregateOutputType | null
  }

  export type PeriodMinAggregateOutputType = {
    id: string | null
    category: $Enums.PeriodCategory | null
    start_date: Date | null
    end_date: Date | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type PeriodMaxAggregateOutputType = {
    id: string | null
    category: $Enums.PeriodCategory | null
    start_date: Date | null
    end_date: Date | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type PeriodCountAggregateOutputType = {
    id: number
    category: number
    start_date: number
    end_date: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type PeriodMinAggregateInputType = {
    id?: true
    category?: true
    start_date?: true
    end_date?: true
    created_at?: true
    updated_at?: true
  }

  export type PeriodMaxAggregateInputType = {
    id?: true
    category?: true
    start_date?: true
    end_date?: true
    created_at?: true
    updated_at?: true
  }

  export type PeriodCountAggregateInputType = {
    id?: true
    category?: true
    start_date?: true
    end_date?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

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

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




  export type PeriodGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PeriodWhereInput
    orderBy?: PeriodOrderByWithAggregationInput | PeriodOrderByWithAggregationInput[]
    by: PeriodScalarFieldEnum[] | PeriodScalarFieldEnum
    having?: PeriodScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: PeriodCountAggregateInputType | true
    _min?: PeriodMinAggregateInputType
    _max?: PeriodMaxAggregateInputType
  }

  export type PeriodGroupByOutputType = {
    id: string
    category: $Enums.PeriodCategory
    start_date: Date
    end_date: Date
    created_at: Date
    updated_at: Date
    _count: PeriodCountAggregateOutputType | null
    _min: PeriodMinAggregateOutputType | null
    _max: PeriodMaxAggregateOutputType | null
  }

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


  export type PeriodSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    category?: boolean
    start_date?: boolean
    end_date?: boolean
    created_at?: boolean
    updated_at?: boolean
    HotelPeriodPrices?: boolean | Period$HotelPeriodPricesArgs<ExtArgs>
    MitraPackages?: boolean | Period$MitraPackagesArgs<ExtArgs>
    _count?: boolean | PeriodCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["period"]>


  export type PeriodSelectScalar = {
    id?: boolean
    category?: boolean
    start_date?: boolean
    end_date?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type PeriodInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    HotelPeriodPrices?: boolean | Period$HotelPeriodPricesArgs<ExtArgs>
    MitraPackages?: boolean | Period$MitraPackagesArgs<ExtArgs>
    _count?: boolean | PeriodCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $PeriodPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Period"
    objects: {
      HotelPeriodPrices: Prisma.$HotelPeriodPricePayload<ExtArgs>[]
      MitraPackages: Prisma.$MitraPackagePayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      category: $Enums.PeriodCategory
      start_date: Date
      end_date: Date
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["period"]>
    composites: {}
  }

  type PeriodGetPayload<S extends boolean | null | undefined | PeriodDefaultArgs> = $Result.GetResult<Prisma.$PeriodPayload, S>

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

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

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

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

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

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

    /**
     * Create a Period.
     * @param {PeriodCreateArgs} args - Arguments to create a Period.
     * @example
     * // Create one Period
     * const Period = await prisma.period.create({
     *   data: {
     *     // ... data to create a Period
     *   }
     * })
     * 
     */
    create<T extends PeriodCreateArgs>(args: SelectSubset<T, PeriodCreateArgs<ExtArgs>>): Prisma__PeriodClient<$Result.GetResult<Prisma.$PeriodPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Delete a Period.
     * @param {PeriodDeleteArgs} args - Arguments to delete one Period.
     * @example
     * // Delete one Period
     * const Period = await prisma.period.delete({
     *   where: {
     *     // ... filter to delete one Period
     *   }
     * })
     * 
     */
    delete<T extends PeriodDeleteArgs>(args: SelectSubset<T, PeriodDeleteArgs<ExtArgs>>): Prisma__PeriodClient<$Result.GetResult<Prisma.$PeriodPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Period.
   * 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__PeriodClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    HotelPeriodPrices<T extends Period$HotelPeriodPricesArgs<ExtArgs> = {}>(args?: Subset<T, Period$HotelPeriodPricesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$HotelPeriodPricePayload<ExtArgs>, T, "findMany"> | Null>
    MitraPackages<T extends Period$MitraPackagesArgs<ExtArgs> = {}>(args?: Subset<T, Period$MitraPackagesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MitraPackagePayload<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 Period model
   */ 
  interface PeriodFieldRefs {
    readonly id: FieldRef<"Period", 'String'>
    readonly category: FieldRef<"Period", 'PeriodCategory'>
    readonly start_date: FieldRef<"Period", 'DateTime'>
    readonly end_date: FieldRef<"Period", 'DateTime'>
    readonly created_at: FieldRef<"Period", 'DateTime'>
    readonly updated_at: FieldRef<"Period", 'DateTime'>
  }
    

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

  /**
   * Period findUniqueOrThrow
   */
  export type PeriodFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Period
     */
    select?: PeriodSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PeriodInclude<ExtArgs> | null
    /**
     * Filter, which Period to fetch.
     */
    where: PeriodWhereUniqueInput
  }

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

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

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

  /**
   * Period create
   */
  export type PeriodCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Period
     */
    select?: PeriodSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PeriodInclude<ExtArgs> | null
    /**
     * The data needed to create a Period.
     */
    data: XOR<PeriodCreateInput, PeriodUncheckedCreateInput>
  }

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

  /**
   * Period update
   */
  export type PeriodUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Period
     */
    select?: PeriodSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PeriodInclude<ExtArgs> | null
    /**
     * The data needed to update a Period.
     */
    data: XOR<PeriodUpdateInput, PeriodUncheckedUpdateInput>
    /**
     * Choose, which Period to update.
     */
    where: PeriodWhereUniqueInput
  }

  /**
   * Period updateMany
   */
  export type PeriodUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Periods.
     */
    data: XOR<PeriodUpdateManyMutationInput, PeriodUncheckedUpdateManyInput>
    /**
     * Filter which Periods to update
     */
    where?: PeriodWhereInput
  }

  /**
   * Period upsert
   */
  export type PeriodUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Period
     */
    select?: PeriodSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PeriodInclude<ExtArgs> | null
    /**
     * The filter to search for the Period to update in case it exists.
     */
    where: PeriodWhereUniqueInput
    /**
     * In case the Period found by the `where` argument doesn't exist, create a new Period with this data.
     */
    create: XOR<PeriodCreateInput, PeriodUncheckedCreateInput>
    /**
     * In case the Period was found with the provided `where` argument, update it with this data.
     */
    update: XOR<PeriodUpdateInput, PeriodUncheckedUpdateInput>
  }

  /**
   * Period delete
   */
  export type PeriodDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Period
     */
    select?: PeriodSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PeriodInclude<ExtArgs> | null
    /**
     * Filter which Period to delete.
     */
    where: PeriodWhereUniqueInput
  }

  /**
   * Period deleteMany
   */
  export type PeriodDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Periods to delete
     */
    where?: PeriodWhereInput
  }

  /**
   * Period.HotelPeriodPrices
   */
  export type Period$HotelPeriodPricesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HotelPeriodPrice
     */
    select?: HotelPeriodPriceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: HotelPeriodPriceInclude<ExtArgs> | null
    where?: HotelPeriodPriceWhereInput
    orderBy?: HotelPeriodPriceOrderByWithRelationInput | HotelPeriodPriceOrderByWithRelationInput[]
    cursor?: HotelPeriodPriceWhereUniqueInput
    take?: number
    skip?: number
    distinct?: HotelPeriodPriceScalarFieldEnum | HotelPeriodPriceScalarFieldEnum[]
  }

  /**
   * Period.MitraPackages
   */
  export type Period$MitraPackagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackage
     */
    select?: MitraPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageInclude<ExtArgs> | null
    where?: MitraPackageWhereInput
    orderBy?: MitraPackageOrderByWithRelationInput | MitraPackageOrderByWithRelationInput[]
    cursor?: MitraPackageWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MitraPackageScalarFieldEnum | MitraPackageScalarFieldEnum[]
  }

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


  /**
   * Model HotelPeriodPrice
   */

  export type AggregateHotelPeriodPrice = {
    _count: HotelPeriodPriceCountAggregateOutputType | null
    _avg: HotelPeriodPriceAvgAggregateOutputType | null
    _sum: HotelPeriodPriceSumAggregateOutputType | null
    _min: HotelPeriodPriceMinAggregateOutputType | null
    _max: HotelPeriodPriceMaxAggregateOutputType | null
  }

  export type HotelPeriodPriceAvgAggregateOutputType = {
    price_double: Decimal | null
    price_triple: Decimal | null
    price_quad: Decimal | null
  }

  export type HotelPeriodPriceSumAggregateOutputType = {
    price_double: Decimal | null
    price_triple: Decimal | null
    price_quad: Decimal | null
  }

  export type HotelPeriodPriceMinAggregateOutputType = {
    id: string | null
    hotel_id: string | null
    period_id: string | null
    price_double: Decimal | null
    price_triple: Decimal | null
    price_quad: Decimal | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type HotelPeriodPriceMaxAggregateOutputType = {
    id: string | null
    hotel_id: string | null
    period_id: string | null
    price_double: Decimal | null
    price_triple: Decimal | null
    price_quad: Decimal | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type HotelPeriodPriceCountAggregateOutputType = {
    id: number
    hotel_id: number
    period_id: number
    price_double: number
    price_triple: number
    price_quad: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type HotelPeriodPriceAvgAggregateInputType = {
    price_double?: true
    price_triple?: true
    price_quad?: true
  }

  export type HotelPeriodPriceSumAggregateInputType = {
    price_double?: true
    price_triple?: true
    price_quad?: true
  }

  export type HotelPeriodPriceMinAggregateInputType = {
    id?: true
    hotel_id?: true
    period_id?: true
    price_double?: true
    price_triple?: true
    price_quad?: true
    created_at?: true
    updated_at?: true
  }

  export type HotelPeriodPriceMaxAggregateInputType = {
    id?: true
    hotel_id?: true
    period_id?: true
    price_double?: true
    price_triple?: true
    price_quad?: true
    created_at?: true
    updated_at?: true
  }

  export type HotelPeriodPriceCountAggregateInputType = {
    id?: true
    hotel_id?: true
    period_id?: true
    price_double?: true
    price_triple?: true
    price_quad?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type HotelPeriodPriceAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which HotelPeriodPrice to aggregate.
     */
    where?: HotelPeriodPriceWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of HotelPeriodPrices to fetch.
     */
    orderBy?: HotelPeriodPriceOrderByWithRelationInput | HotelPeriodPriceOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: HotelPeriodPriceWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` HotelPeriodPrices from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` HotelPeriodPrices.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned HotelPeriodPrices
    **/
    _count?: true | HotelPeriodPriceCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: HotelPeriodPriceAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: HotelPeriodPriceSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: HotelPeriodPriceMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: HotelPeriodPriceMaxAggregateInputType
  }

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




  export type HotelPeriodPriceGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: HotelPeriodPriceWhereInput
    orderBy?: HotelPeriodPriceOrderByWithAggregationInput | HotelPeriodPriceOrderByWithAggregationInput[]
    by: HotelPeriodPriceScalarFieldEnum[] | HotelPeriodPriceScalarFieldEnum
    having?: HotelPeriodPriceScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: HotelPeriodPriceCountAggregateInputType | true
    _avg?: HotelPeriodPriceAvgAggregateInputType
    _sum?: HotelPeriodPriceSumAggregateInputType
    _min?: HotelPeriodPriceMinAggregateInputType
    _max?: HotelPeriodPriceMaxAggregateInputType
  }

  export type HotelPeriodPriceGroupByOutputType = {
    id: string
    hotel_id: string
    period_id: string
    price_double: Decimal
    price_triple: Decimal
    price_quad: Decimal
    created_at: Date
    updated_at: Date
    _count: HotelPeriodPriceCountAggregateOutputType | null
    _avg: HotelPeriodPriceAvgAggregateOutputType | null
    _sum: HotelPeriodPriceSumAggregateOutputType | null
    _min: HotelPeriodPriceMinAggregateOutputType | null
    _max: HotelPeriodPriceMaxAggregateOutputType | null
  }

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


  export type HotelPeriodPriceSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    hotel_id?: boolean
    period_id?: boolean
    price_double?: boolean
    price_triple?: boolean
    price_quad?: boolean
    created_at?: boolean
    updated_at?: boolean
    Hotel?: boolean | HotelDefaultArgs<ExtArgs>
    Period?: boolean | PeriodDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["hotelPeriodPrice"]>


  export type HotelPeriodPriceSelectScalar = {
    id?: boolean
    hotel_id?: boolean
    period_id?: boolean
    price_double?: boolean
    price_triple?: boolean
    price_quad?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type HotelPeriodPriceInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Hotel?: boolean | HotelDefaultArgs<ExtArgs>
    Period?: boolean | PeriodDefaultArgs<ExtArgs>
  }

  export type $HotelPeriodPricePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "HotelPeriodPrice"
    objects: {
      Hotel: Prisma.$HotelPayload<ExtArgs>
      Period: Prisma.$PeriodPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      hotel_id: string
      period_id: string
      price_double: Prisma.Decimal
      price_triple: Prisma.Decimal
      price_quad: Prisma.Decimal
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["hotelPeriodPrice"]>
    composites: {}
  }

  type HotelPeriodPriceGetPayload<S extends boolean | null | undefined | HotelPeriodPriceDefaultArgs> = $Result.GetResult<Prisma.$HotelPeriodPricePayload, S>

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

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

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

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

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

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

    /**
     * Create a HotelPeriodPrice.
     * @param {HotelPeriodPriceCreateArgs} args - Arguments to create a HotelPeriodPrice.
     * @example
     * // Create one HotelPeriodPrice
     * const HotelPeriodPrice = await prisma.hotelPeriodPrice.create({
     *   data: {
     *     // ... data to create a HotelPeriodPrice
     *   }
     * })
     * 
     */
    create<T extends HotelPeriodPriceCreateArgs>(args: SelectSubset<T, HotelPeriodPriceCreateArgs<ExtArgs>>): Prisma__HotelPeriodPriceClient<$Result.GetResult<Prisma.$HotelPeriodPricePayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Delete a HotelPeriodPrice.
     * @param {HotelPeriodPriceDeleteArgs} args - Arguments to delete one HotelPeriodPrice.
     * @example
     * // Delete one HotelPeriodPrice
     * const HotelPeriodPrice = await prisma.hotelPeriodPrice.delete({
     *   where: {
     *     // ... filter to delete one HotelPeriodPrice
     *   }
     * })
     * 
     */
    delete<T extends HotelPeriodPriceDeleteArgs>(args: SelectSubset<T, HotelPeriodPriceDeleteArgs<ExtArgs>>): Prisma__HotelPeriodPriceClient<$Result.GetResult<Prisma.$HotelPeriodPricePayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for HotelPeriodPrice.
   * 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__HotelPeriodPriceClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    Hotel<T extends HotelDefaultArgs<ExtArgs> = {}>(args?: Subset<T, HotelDefaultArgs<ExtArgs>>): Prisma__HotelClient<$Result.GetResult<Prisma.$HotelPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    Period<T extends PeriodDefaultArgs<ExtArgs> = {}>(args?: Subset<T, PeriodDefaultArgs<ExtArgs>>): Prisma__PeriodClient<$Result.GetResult<Prisma.$PeriodPayload<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 HotelPeriodPrice model
   */ 
  interface HotelPeriodPriceFieldRefs {
    readonly id: FieldRef<"HotelPeriodPrice", 'String'>
    readonly hotel_id: FieldRef<"HotelPeriodPrice", 'String'>
    readonly period_id: FieldRef<"HotelPeriodPrice", 'String'>
    readonly price_double: FieldRef<"HotelPeriodPrice", 'Decimal'>
    readonly price_triple: FieldRef<"HotelPeriodPrice", 'Decimal'>
    readonly price_quad: FieldRef<"HotelPeriodPrice", 'Decimal'>
    readonly created_at: FieldRef<"HotelPeriodPrice", 'DateTime'>
    readonly updated_at: FieldRef<"HotelPeriodPrice", 'DateTime'>
  }
    

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

  /**
   * HotelPeriodPrice findUniqueOrThrow
   */
  export type HotelPeriodPriceFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HotelPeriodPrice
     */
    select?: HotelPeriodPriceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: HotelPeriodPriceInclude<ExtArgs> | null
    /**
     * Filter, which HotelPeriodPrice to fetch.
     */
    where: HotelPeriodPriceWhereUniqueInput
  }

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

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

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

  /**
   * HotelPeriodPrice create
   */
  export type HotelPeriodPriceCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HotelPeriodPrice
     */
    select?: HotelPeriodPriceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: HotelPeriodPriceInclude<ExtArgs> | null
    /**
     * The data needed to create a HotelPeriodPrice.
     */
    data: XOR<HotelPeriodPriceCreateInput, HotelPeriodPriceUncheckedCreateInput>
  }

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

  /**
   * HotelPeriodPrice update
   */
  export type HotelPeriodPriceUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HotelPeriodPrice
     */
    select?: HotelPeriodPriceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: HotelPeriodPriceInclude<ExtArgs> | null
    /**
     * The data needed to update a HotelPeriodPrice.
     */
    data: XOR<HotelPeriodPriceUpdateInput, HotelPeriodPriceUncheckedUpdateInput>
    /**
     * Choose, which HotelPeriodPrice to update.
     */
    where: HotelPeriodPriceWhereUniqueInput
  }

  /**
   * HotelPeriodPrice updateMany
   */
  export type HotelPeriodPriceUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update HotelPeriodPrices.
     */
    data: XOR<HotelPeriodPriceUpdateManyMutationInput, HotelPeriodPriceUncheckedUpdateManyInput>
    /**
     * Filter which HotelPeriodPrices to update
     */
    where?: HotelPeriodPriceWhereInput
  }

  /**
   * HotelPeriodPrice upsert
   */
  export type HotelPeriodPriceUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HotelPeriodPrice
     */
    select?: HotelPeriodPriceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: HotelPeriodPriceInclude<ExtArgs> | null
    /**
     * The filter to search for the HotelPeriodPrice to update in case it exists.
     */
    where: HotelPeriodPriceWhereUniqueInput
    /**
     * In case the HotelPeriodPrice found by the `where` argument doesn't exist, create a new HotelPeriodPrice with this data.
     */
    create: XOR<HotelPeriodPriceCreateInput, HotelPeriodPriceUncheckedCreateInput>
    /**
     * In case the HotelPeriodPrice was found with the provided `where` argument, update it with this data.
     */
    update: XOR<HotelPeriodPriceUpdateInput, HotelPeriodPriceUncheckedUpdateInput>
  }

  /**
   * HotelPeriodPrice delete
   */
  export type HotelPeriodPriceDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HotelPeriodPrice
     */
    select?: HotelPeriodPriceSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: HotelPeriodPriceInclude<ExtArgs> | null
    /**
     * Filter which HotelPeriodPrice to delete.
     */
    where: HotelPeriodPriceWhereUniqueInput
  }

  /**
   * HotelPeriodPrice deleteMany
   */
  export type HotelPeriodPriceDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which HotelPeriodPrices to delete
     */
    where?: HotelPeriodPriceWhereInput
  }

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


  /**
   * Model Airline
   */

  export type AggregateAirline = {
    _count: AirlineCountAggregateOutputType | null
    _avg: AirlineAvgAggregateOutputType | null
    _sum: AirlineSumAggregateOutputType | null
    _min: AirlineMinAggregateOutputType | null
    _max: AirlineMaxAggregateOutputType | null
  }

  export type AirlineAvgAggregateOutputType = {
    price_idr: Decimal | null
    order_number: number | null
  }

  export type AirlineSumAggregateOutputType = {
    price_idr: Decimal | null
    order_number: number | null
  }

  export type AirlineMinAggregateOutputType = {
    id: string | null
    name: string | null
    price_idr: Decimal | null
    order_number: number | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type AirlineMaxAggregateOutputType = {
    id: string | null
    name: string | null
    price_idr: Decimal | null
    order_number: number | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type AirlineCountAggregateOutputType = {
    id: number
    name: number
    price_idr: number
    order_number: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type AirlineAvgAggregateInputType = {
    price_idr?: true
    order_number?: true
  }

  export type AirlineSumAggregateInputType = {
    price_idr?: true
    order_number?: true
  }

  export type AirlineMinAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
  }

  export type AirlineMaxAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
  }

  export type AirlineCountAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type AirlineAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Airline to aggregate.
     */
    where?: AirlineWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Airlines to fetch.
     */
    orderBy?: AirlineOrderByWithRelationInput | AirlineOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: AirlineWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Airlines from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Airlines.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Airlines
    **/
    _count?: true | AirlineCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: AirlineAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: AirlineSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: AirlineMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: AirlineMaxAggregateInputType
  }

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




  export type AirlineGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AirlineWhereInput
    orderBy?: AirlineOrderByWithAggregationInput | AirlineOrderByWithAggregationInput[]
    by: AirlineScalarFieldEnum[] | AirlineScalarFieldEnum
    having?: AirlineScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AirlineCountAggregateInputType | true
    _avg?: AirlineAvgAggregateInputType
    _sum?: AirlineSumAggregateInputType
    _min?: AirlineMinAggregateInputType
    _max?: AirlineMaxAggregateInputType
  }

  export type AirlineGroupByOutputType = {
    id: string
    name: string
    price_idr: Decimal
    order_number: number
    created_at: Date
    updated_at: Date
    _count: AirlineCountAggregateOutputType | null
    _avg: AirlineAvgAggregateOutputType | null
    _sum: AirlineSumAggregateOutputType | null
    _min: AirlineMinAggregateOutputType | null
    _max: AirlineMaxAggregateOutputType | null
  }

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


  export type AirlineSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    price_idr?: boolean
    order_number?: boolean
    created_at?: boolean
    updated_at?: boolean
    MitraPackages?: boolean | Airline$MitraPackagesArgs<ExtArgs>
    _count?: boolean | AirlineCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["airline"]>


  export type AirlineSelectScalar = {
    id?: boolean
    name?: boolean
    price_idr?: boolean
    order_number?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type AirlineInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    MitraPackages?: boolean | Airline$MitraPackagesArgs<ExtArgs>
    _count?: boolean | AirlineCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $AirlinePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Airline"
    objects: {
      MitraPackages: Prisma.$MitraPackagePayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      price_idr: Prisma.Decimal
      order_number: number
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["airline"]>
    composites: {}
  }

  type AirlineGetPayload<S extends boolean | null | undefined | AirlineDefaultArgs> = $Result.GetResult<Prisma.$AirlinePayload, S>

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

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

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

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

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

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

    /**
     * Create a Airline.
     * @param {AirlineCreateArgs} args - Arguments to create a Airline.
     * @example
     * // Create one Airline
     * const Airline = await prisma.airline.create({
     *   data: {
     *     // ... data to create a Airline
     *   }
     * })
     * 
     */
    create<T extends AirlineCreateArgs>(args: SelectSubset<T, AirlineCreateArgs<ExtArgs>>): Prisma__AirlineClient<$Result.GetResult<Prisma.$AirlinePayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Delete a Airline.
     * @param {AirlineDeleteArgs} args - Arguments to delete one Airline.
     * @example
     * // Delete one Airline
     * const Airline = await prisma.airline.delete({
     *   where: {
     *     // ... filter to delete one Airline
     *   }
     * })
     * 
     */
    delete<T extends AirlineDeleteArgs>(args: SelectSubset<T, AirlineDeleteArgs<ExtArgs>>): Prisma__AirlineClient<$Result.GetResult<Prisma.$AirlinePayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Airline.
   * 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__AirlineClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    MitraPackages<T extends Airline$MitraPackagesArgs<ExtArgs> = {}>(args?: Subset<T, Airline$MitraPackagesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MitraPackagePayload<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 Airline model
   */ 
  interface AirlineFieldRefs {
    readonly id: FieldRef<"Airline", 'String'>
    readonly name: FieldRef<"Airline", 'String'>
    readonly price_idr: FieldRef<"Airline", 'Decimal'>
    readonly order_number: FieldRef<"Airline", 'Int'>
    readonly created_at: FieldRef<"Airline", 'DateTime'>
    readonly updated_at: FieldRef<"Airline", 'DateTime'>
  }
    

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

  /**
   * Airline findUniqueOrThrow
   */
  export type AirlineFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Airline
     */
    select?: AirlineSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AirlineInclude<ExtArgs> | null
    /**
     * Filter, which Airline to fetch.
     */
    where: AirlineWhereUniqueInput
  }

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

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

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

  /**
   * Airline create
   */
  export type AirlineCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Airline
     */
    select?: AirlineSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AirlineInclude<ExtArgs> | null
    /**
     * The data needed to create a Airline.
     */
    data: XOR<AirlineCreateInput, AirlineUncheckedCreateInput>
  }

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

  /**
   * Airline update
   */
  export type AirlineUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Airline
     */
    select?: AirlineSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AirlineInclude<ExtArgs> | null
    /**
     * The data needed to update a Airline.
     */
    data: XOR<AirlineUpdateInput, AirlineUncheckedUpdateInput>
    /**
     * Choose, which Airline to update.
     */
    where: AirlineWhereUniqueInput
  }

  /**
   * Airline updateMany
   */
  export type AirlineUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Airlines.
     */
    data: XOR<AirlineUpdateManyMutationInput, AirlineUncheckedUpdateManyInput>
    /**
     * Filter which Airlines to update
     */
    where?: AirlineWhereInput
  }

  /**
   * Airline upsert
   */
  export type AirlineUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Airline
     */
    select?: AirlineSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AirlineInclude<ExtArgs> | null
    /**
     * The filter to search for the Airline to update in case it exists.
     */
    where: AirlineWhereUniqueInput
    /**
     * In case the Airline found by the `where` argument doesn't exist, create a new Airline with this data.
     */
    create: XOR<AirlineCreateInput, AirlineUncheckedCreateInput>
    /**
     * In case the Airline was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AirlineUpdateInput, AirlineUncheckedUpdateInput>
  }

  /**
   * Airline delete
   */
  export type AirlineDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Airline
     */
    select?: AirlineSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AirlineInclude<ExtArgs> | null
    /**
     * Filter which Airline to delete.
     */
    where: AirlineWhereUniqueInput
  }

  /**
   * Airline deleteMany
   */
  export type AirlineDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Airlines to delete
     */
    where?: AirlineWhereInput
  }

  /**
   * Airline.MitraPackages
   */
  export type Airline$MitraPackagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackage
     */
    select?: MitraPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageInclude<ExtArgs> | null
    where?: MitraPackageWhereInput
    orderBy?: MitraPackageOrderByWithRelationInput | MitraPackageOrderByWithRelationInput[]
    cursor?: MitraPackageWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MitraPackageScalarFieldEnum | MitraPackageScalarFieldEnum[]
  }

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


  /**
   * Model Visa
   */

  export type AggregateVisa = {
    _count: VisaCountAggregateOutputType | null
    _avg: VisaAvgAggregateOutputType | null
    _sum: VisaSumAggregateOutputType | null
    _min: VisaMinAggregateOutputType | null
    _max: VisaMaxAggregateOutputType | null
  }

  export type VisaAvgAggregateOutputType = {
    price_idr: Decimal | null
    order_number: number | null
  }

  export type VisaSumAggregateOutputType = {
    price_idr: Decimal | null
    order_number: number | null
  }

  export type VisaMinAggregateOutputType = {
    id: string | null
    name: string | null
    price_idr: Decimal | null
    order_number: number | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type VisaMaxAggregateOutputType = {
    id: string | null
    name: string | null
    price_idr: Decimal | null
    order_number: number | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type VisaCountAggregateOutputType = {
    id: number
    name: number
    price_idr: number
    order_number: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type VisaAvgAggregateInputType = {
    price_idr?: true
    order_number?: true
  }

  export type VisaSumAggregateInputType = {
    price_idr?: true
    order_number?: true
  }

  export type VisaMinAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
  }

  export type VisaMaxAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
  }

  export type VisaCountAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type VisaAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Visa to aggregate.
     */
    where?: VisaWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Visas to fetch.
     */
    orderBy?: VisaOrderByWithRelationInput | VisaOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: VisaWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Visas from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Visas.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Visas
    **/
    _count?: true | VisaCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: VisaAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: VisaSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: VisaMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: VisaMaxAggregateInputType
  }

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




  export type VisaGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: VisaWhereInput
    orderBy?: VisaOrderByWithAggregationInput | VisaOrderByWithAggregationInput[]
    by: VisaScalarFieldEnum[] | VisaScalarFieldEnum
    having?: VisaScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: VisaCountAggregateInputType | true
    _avg?: VisaAvgAggregateInputType
    _sum?: VisaSumAggregateInputType
    _min?: VisaMinAggregateInputType
    _max?: VisaMaxAggregateInputType
  }

  export type VisaGroupByOutputType = {
    id: string
    name: string
    price_idr: Decimal
    order_number: number
    created_at: Date
    updated_at: Date
    _count: VisaCountAggregateOutputType | null
    _avg: VisaAvgAggregateOutputType | null
    _sum: VisaSumAggregateOutputType | null
    _min: VisaMinAggregateOutputType | null
    _max: VisaMaxAggregateOutputType | null
  }

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


  export type VisaSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    price_idr?: boolean
    order_number?: boolean
    created_at?: boolean
    updated_at?: boolean
    MitraPackages?: boolean | Visa$MitraPackagesArgs<ExtArgs>
    _count?: boolean | VisaCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["visa"]>


  export type VisaSelectScalar = {
    id?: boolean
    name?: boolean
    price_idr?: boolean
    order_number?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type VisaInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    MitraPackages?: boolean | Visa$MitraPackagesArgs<ExtArgs>
    _count?: boolean | VisaCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $VisaPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Visa"
    objects: {
      MitraPackages: Prisma.$MitraPackagePayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      price_idr: Prisma.Decimal
      order_number: number
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["visa"]>
    composites: {}
  }

  type VisaGetPayload<S extends boolean | null | undefined | VisaDefaultArgs> = $Result.GetResult<Prisma.$VisaPayload, S>

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

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

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

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

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

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

    /**
     * Create a Visa.
     * @param {VisaCreateArgs} args - Arguments to create a Visa.
     * @example
     * // Create one Visa
     * const Visa = await prisma.visa.create({
     *   data: {
     *     // ... data to create a Visa
     *   }
     * })
     * 
     */
    create<T extends VisaCreateArgs>(args: SelectSubset<T, VisaCreateArgs<ExtArgs>>): Prisma__VisaClient<$Result.GetResult<Prisma.$VisaPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Delete a Visa.
     * @param {VisaDeleteArgs} args - Arguments to delete one Visa.
     * @example
     * // Delete one Visa
     * const Visa = await prisma.visa.delete({
     *   where: {
     *     // ... filter to delete one Visa
     *   }
     * })
     * 
     */
    delete<T extends VisaDeleteArgs>(args: SelectSubset<T, VisaDeleteArgs<ExtArgs>>): Prisma__VisaClient<$Result.GetResult<Prisma.$VisaPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Visa.
   * 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__VisaClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    MitraPackages<T extends Visa$MitraPackagesArgs<ExtArgs> = {}>(args?: Subset<T, Visa$MitraPackagesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MitraPackagePayload<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 Visa model
   */ 
  interface VisaFieldRefs {
    readonly id: FieldRef<"Visa", 'String'>
    readonly name: FieldRef<"Visa", 'String'>
    readonly price_idr: FieldRef<"Visa", 'Decimal'>
    readonly order_number: FieldRef<"Visa", 'Int'>
    readonly created_at: FieldRef<"Visa", 'DateTime'>
    readonly updated_at: FieldRef<"Visa", 'DateTime'>
  }
    

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

  /**
   * Visa findUniqueOrThrow
   */
  export type VisaFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Visa
     */
    select?: VisaSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VisaInclude<ExtArgs> | null
    /**
     * Filter, which Visa to fetch.
     */
    where: VisaWhereUniqueInput
  }

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

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

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

  /**
   * Visa create
   */
  export type VisaCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Visa
     */
    select?: VisaSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VisaInclude<ExtArgs> | null
    /**
     * The data needed to create a Visa.
     */
    data: XOR<VisaCreateInput, VisaUncheckedCreateInput>
  }

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

  /**
   * Visa update
   */
  export type VisaUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Visa
     */
    select?: VisaSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VisaInclude<ExtArgs> | null
    /**
     * The data needed to update a Visa.
     */
    data: XOR<VisaUpdateInput, VisaUncheckedUpdateInput>
    /**
     * Choose, which Visa to update.
     */
    where: VisaWhereUniqueInput
  }

  /**
   * Visa updateMany
   */
  export type VisaUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Visas.
     */
    data: XOR<VisaUpdateManyMutationInput, VisaUncheckedUpdateManyInput>
    /**
     * Filter which Visas to update
     */
    where?: VisaWhereInput
  }

  /**
   * Visa upsert
   */
  export type VisaUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Visa
     */
    select?: VisaSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VisaInclude<ExtArgs> | null
    /**
     * The filter to search for the Visa to update in case it exists.
     */
    where: VisaWhereUniqueInput
    /**
     * In case the Visa found by the `where` argument doesn't exist, create a new Visa with this data.
     */
    create: XOR<VisaCreateInput, VisaUncheckedCreateInput>
    /**
     * In case the Visa was found with the provided `where` argument, update it with this data.
     */
    update: XOR<VisaUpdateInput, VisaUncheckedUpdateInput>
  }

  /**
   * Visa delete
   */
  export type VisaDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Visa
     */
    select?: VisaSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VisaInclude<ExtArgs> | null
    /**
     * Filter which Visa to delete.
     */
    where: VisaWhereUniqueInput
  }

  /**
   * Visa deleteMany
   */
  export type VisaDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Visas to delete
     */
    where?: VisaWhereInput
  }

  /**
   * Visa.MitraPackages
   */
  export type Visa$MitraPackagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackage
     */
    select?: MitraPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageInclude<ExtArgs> | null
    where?: MitraPackageWhereInput
    orderBy?: MitraPackageOrderByWithRelationInput | MitraPackageOrderByWithRelationInput[]
    cursor?: MitraPackageWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MitraPackageScalarFieldEnum | MitraPackageScalarFieldEnum[]
  }

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


  /**
   * Model Transportation
   */

  export type AggregateTransportation = {
    _count: TransportationCountAggregateOutputType | null
    _avg: TransportationAvgAggregateOutputType | null
    _sum: TransportationSumAggregateOutputType | null
    _min: TransportationMinAggregateOutputType | null
    _max: TransportationMaxAggregateOutputType | null
  }

  export type TransportationAvgAggregateOutputType = {
    price_idr: Decimal | null
    order_number: number | null
  }

  export type TransportationSumAggregateOutputType = {
    price_idr: Decimal | null
    order_number: number | null
  }

  export type TransportationMinAggregateOutputType = {
    id: string | null
    name: string | null
    price_idr: Decimal | null
    order_number: number | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type TransportationMaxAggregateOutputType = {
    id: string | null
    name: string | null
    price_idr: Decimal | null
    order_number: number | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type TransportationCountAggregateOutputType = {
    id: number
    name: number
    price_idr: number
    order_number: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type TransportationAvgAggregateInputType = {
    price_idr?: true
    order_number?: true
  }

  export type TransportationSumAggregateInputType = {
    price_idr?: true
    order_number?: true
  }

  export type TransportationMinAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
  }

  export type TransportationMaxAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
  }

  export type TransportationCountAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

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

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




  export type TransportationGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TransportationWhereInput
    orderBy?: TransportationOrderByWithAggregationInput | TransportationOrderByWithAggregationInput[]
    by: TransportationScalarFieldEnum[] | TransportationScalarFieldEnum
    having?: TransportationScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: TransportationCountAggregateInputType | true
    _avg?: TransportationAvgAggregateInputType
    _sum?: TransportationSumAggregateInputType
    _min?: TransportationMinAggregateInputType
    _max?: TransportationMaxAggregateInputType
  }

  export type TransportationGroupByOutputType = {
    id: string
    name: string
    price_idr: Decimal
    order_number: number
    created_at: Date
    updated_at: Date
    _count: TransportationCountAggregateOutputType | null
    _avg: TransportationAvgAggregateOutputType | null
    _sum: TransportationSumAggregateOutputType | null
    _min: TransportationMinAggregateOutputType | null
    _max: TransportationMaxAggregateOutputType | null
  }

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


  export type TransportationSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    price_idr?: boolean
    order_number?: boolean
    created_at?: boolean
    updated_at?: boolean
    MitraPackage?: boolean | Transportation$MitraPackageArgs<ExtArgs>
    _count?: boolean | TransportationCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["transportation"]>


  export type TransportationSelectScalar = {
    id?: boolean
    name?: boolean
    price_idr?: boolean
    order_number?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type TransportationInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    MitraPackage?: boolean | Transportation$MitraPackageArgs<ExtArgs>
    _count?: boolean | TransportationCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $TransportationPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Transportation"
    objects: {
      MitraPackage: Prisma.$MitraPackagePayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      price_idr: Prisma.Decimal
      order_number: number
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["transportation"]>
    composites: {}
  }

  type TransportationGetPayload<S extends boolean | null | undefined | TransportationDefaultArgs> = $Result.GetResult<Prisma.$TransportationPayload, S>

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

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

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

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

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

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

    /**
     * Create a Transportation.
     * @param {TransportationCreateArgs} args - Arguments to create a Transportation.
     * @example
     * // Create one Transportation
     * const Transportation = await prisma.transportation.create({
     *   data: {
     *     // ... data to create a Transportation
     *   }
     * })
     * 
     */
    create<T extends TransportationCreateArgs>(args: SelectSubset<T, TransportationCreateArgs<ExtArgs>>): Prisma__TransportationClient<$Result.GetResult<Prisma.$TransportationPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Delete a Transportation.
     * @param {TransportationDeleteArgs} args - Arguments to delete one Transportation.
     * @example
     * // Delete one Transportation
     * const Transportation = await prisma.transportation.delete({
     *   where: {
     *     // ... filter to delete one Transportation
     *   }
     * })
     * 
     */
    delete<T extends TransportationDeleteArgs>(args: SelectSubset<T, TransportationDeleteArgs<ExtArgs>>): Prisma__TransportationClient<$Result.GetResult<Prisma.$TransportationPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Transportation.
   * 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__TransportationClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    MitraPackage<T extends Transportation$MitraPackageArgs<ExtArgs> = {}>(args?: Subset<T, Transportation$MitraPackageArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MitraPackagePayload<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 Transportation model
   */ 
  interface TransportationFieldRefs {
    readonly id: FieldRef<"Transportation", 'String'>
    readonly name: FieldRef<"Transportation", 'String'>
    readonly price_idr: FieldRef<"Transportation", 'Decimal'>
    readonly order_number: FieldRef<"Transportation", 'Int'>
    readonly created_at: FieldRef<"Transportation", 'DateTime'>
    readonly updated_at: FieldRef<"Transportation", 'DateTime'>
  }
    

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

  /**
   * Transportation findUniqueOrThrow
   */
  export type TransportationFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Transportation
     */
    select?: TransportationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TransportationInclude<ExtArgs> | null
    /**
     * Filter, which Transportation to fetch.
     */
    where: TransportationWhereUniqueInput
  }

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

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

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

  /**
   * Transportation create
   */
  export type TransportationCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Transportation
     */
    select?: TransportationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TransportationInclude<ExtArgs> | null
    /**
     * The data needed to create a Transportation.
     */
    data: XOR<TransportationCreateInput, TransportationUncheckedCreateInput>
  }

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

  /**
   * Transportation update
   */
  export type TransportationUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Transportation
     */
    select?: TransportationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TransportationInclude<ExtArgs> | null
    /**
     * The data needed to update a Transportation.
     */
    data: XOR<TransportationUpdateInput, TransportationUncheckedUpdateInput>
    /**
     * Choose, which Transportation to update.
     */
    where: TransportationWhereUniqueInput
  }

  /**
   * Transportation updateMany
   */
  export type TransportationUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Transportation.
     */
    data: XOR<TransportationUpdateManyMutationInput, TransportationUncheckedUpdateManyInput>
    /**
     * Filter which Transportation to update
     */
    where?: TransportationWhereInput
  }

  /**
   * Transportation upsert
   */
  export type TransportationUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Transportation
     */
    select?: TransportationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TransportationInclude<ExtArgs> | null
    /**
     * The filter to search for the Transportation to update in case it exists.
     */
    where: TransportationWhereUniqueInput
    /**
     * In case the Transportation found by the `where` argument doesn't exist, create a new Transportation with this data.
     */
    create: XOR<TransportationCreateInput, TransportationUncheckedCreateInput>
    /**
     * In case the Transportation was found with the provided `where` argument, update it with this data.
     */
    update: XOR<TransportationUpdateInput, TransportationUncheckedUpdateInput>
  }

  /**
   * Transportation delete
   */
  export type TransportationDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Transportation
     */
    select?: TransportationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TransportationInclude<ExtArgs> | null
    /**
     * Filter which Transportation to delete.
     */
    where: TransportationWhereUniqueInput
  }

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

  /**
   * Transportation.MitraPackage
   */
  export type Transportation$MitraPackageArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackage
     */
    select?: MitraPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageInclude<ExtArgs> | null
    where?: MitraPackageWhereInput
    orderBy?: MitraPackageOrderByWithRelationInput | MitraPackageOrderByWithRelationInput[]
    cursor?: MitraPackageWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MitraPackageScalarFieldEnum | MitraPackageScalarFieldEnum[]
  }

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


  /**
   * Model Muthawif
   */

  export type AggregateMuthawif = {
    _count: MuthawifCountAggregateOutputType | null
    _avg: MuthawifAvgAggregateOutputType | null
    _sum: MuthawifSumAggregateOutputType | null
    _min: MuthawifMinAggregateOutputType | null
    _max: MuthawifMaxAggregateOutputType | null
  }

  export type MuthawifAvgAggregateOutputType = {
    price_idr: Decimal | null
    order_number: number | null
  }

  export type MuthawifSumAggregateOutputType = {
    price_idr: Decimal | null
    order_number: number | null
  }

  export type MuthawifMinAggregateOutputType = {
    id: string | null
    name: string | null
    price_idr: Decimal | null
    order_number: number | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type MuthawifMaxAggregateOutputType = {
    id: string | null
    name: string | null
    price_idr: Decimal | null
    order_number: number | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type MuthawifCountAggregateOutputType = {
    id: number
    name: number
    price_idr: number
    order_number: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type MuthawifAvgAggregateInputType = {
    price_idr?: true
    order_number?: true
  }

  export type MuthawifSumAggregateInputType = {
    price_idr?: true
    order_number?: true
  }

  export type MuthawifMinAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
  }

  export type MuthawifMaxAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
  }

  export type MuthawifCountAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type MuthawifAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Muthawif to aggregate.
     */
    where?: MuthawifWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Muthawifs to fetch.
     */
    orderBy?: MuthawifOrderByWithRelationInput | MuthawifOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: MuthawifWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Muthawifs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Muthawifs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Muthawifs
    **/
    _count?: true | MuthawifCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: MuthawifAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: MuthawifSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: MuthawifMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: MuthawifMaxAggregateInputType
  }

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




  export type MuthawifGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MuthawifWhereInput
    orderBy?: MuthawifOrderByWithAggregationInput | MuthawifOrderByWithAggregationInput[]
    by: MuthawifScalarFieldEnum[] | MuthawifScalarFieldEnum
    having?: MuthawifScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: MuthawifCountAggregateInputType | true
    _avg?: MuthawifAvgAggregateInputType
    _sum?: MuthawifSumAggregateInputType
    _min?: MuthawifMinAggregateInputType
    _max?: MuthawifMaxAggregateInputType
  }

  export type MuthawifGroupByOutputType = {
    id: string
    name: string
    price_idr: Decimal
    order_number: number
    created_at: Date
    updated_at: Date
    _count: MuthawifCountAggregateOutputType | null
    _avg: MuthawifAvgAggregateOutputType | null
    _sum: MuthawifSumAggregateOutputType | null
    _min: MuthawifMinAggregateOutputType | null
    _max: MuthawifMaxAggregateOutputType | null
  }

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


  export type MuthawifSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    price_idr?: boolean
    order_number?: boolean
    created_at?: boolean
    updated_at?: boolean
    MitraPackages?: boolean | Muthawif$MitraPackagesArgs<ExtArgs>
    _count?: boolean | MuthawifCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["muthawif"]>


  export type MuthawifSelectScalar = {
    id?: boolean
    name?: boolean
    price_idr?: boolean
    order_number?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type MuthawifInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    MitraPackages?: boolean | Muthawif$MitraPackagesArgs<ExtArgs>
    _count?: boolean | MuthawifCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $MuthawifPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Muthawif"
    objects: {
      MitraPackages: Prisma.$MitraPackagePayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      price_idr: Prisma.Decimal
      order_number: number
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["muthawif"]>
    composites: {}
  }

  type MuthawifGetPayload<S extends boolean | null | undefined | MuthawifDefaultArgs> = $Result.GetResult<Prisma.$MuthawifPayload, S>

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

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

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

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

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

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

    /**
     * Create a Muthawif.
     * @param {MuthawifCreateArgs} args - Arguments to create a Muthawif.
     * @example
     * // Create one Muthawif
     * const Muthawif = await prisma.muthawif.create({
     *   data: {
     *     // ... data to create a Muthawif
     *   }
     * })
     * 
     */
    create<T extends MuthawifCreateArgs>(args: SelectSubset<T, MuthawifCreateArgs<ExtArgs>>): Prisma__MuthawifClient<$Result.GetResult<Prisma.$MuthawifPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Delete a Muthawif.
     * @param {MuthawifDeleteArgs} args - Arguments to delete one Muthawif.
     * @example
     * // Delete one Muthawif
     * const Muthawif = await prisma.muthawif.delete({
     *   where: {
     *     // ... filter to delete one Muthawif
     *   }
     * })
     * 
     */
    delete<T extends MuthawifDeleteArgs>(args: SelectSubset<T, MuthawifDeleteArgs<ExtArgs>>): Prisma__MuthawifClient<$Result.GetResult<Prisma.$MuthawifPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Muthawif.
   * 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__MuthawifClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    MitraPackages<T extends Muthawif$MitraPackagesArgs<ExtArgs> = {}>(args?: Subset<T, Muthawif$MitraPackagesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MitraPackagePayload<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 Muthawif model
   */ 
  interface MuthawifFieldRefs {
    readonly id: FieldRef<"Muthawif", 'String'>
    readonly name: FieldRef<"Muthawif", 'String'>
    readonly price_idr: FieldRef<"Muthawif", 'Decimal'>
    readonly order_number: FieldRef<"Muthawif", 'Int'>
    readonly created_at: FieldRef<"Muthawif", 'DateTime'>
    readonly updated_at: FieldRef<"Muthawif", 'DateTime'>
  }
    

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

  /**
   * Muthawif findUniqueOrThrow
   */
  export type MuthawifFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Muthawif
     */
    select?: MuthawifSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MuthawifInclude<ExtArgs> | null
    /**
     * Filter, which Muthawif to fetch.
     */
    where: MuthawifWhereUniqueInput
  }

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

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

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

  /**
   * Muthawif create
   */
  export type MuthawifCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Muthawif
     */
    select?: MuthawifSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MuthawifInclude<ExtArgs> | null
    /**
     * The data needed to create a Muthawif.
     */
    data: XOR<MuthawifCreateInput, MuthawifUncheckedCreateInput>
  }

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

  /**
   * Muthawif update
   */
  export type MuthawifUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Muthawif
     */
    select?: MuthawifSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MuthawifInclude<ExtArgs> | null
    /**
     * The data needed to update a Muthawif.
     */
    data: XOR<MuthawifUpdateInput, MuthawifUncheckedUpdateInput>
    /**
     * Choose, which Muthawif to update.
     */
    where: MuthawifWhereUniqueInput
  }

  /**
   * Muthawif updateMany
   */
  export type MuthawifUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Muthawifs.
     */
    data: XOR<MuthawifUpdateManyMutationInput, MuthawifUncheckedUpdateManyInput>
    /**
     * Filter which Muthawifs to update
     */
    where?: MuthawifWhereInput
  }

  /**
   * Muthawif upsert
   */
  export type MuthawifUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Muthawif
     */
    select?: MuthawifSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MuthawifInclude<ExtArgs> | null
    /**
     * The filter to search for the Muthawif to update in case it exists.
     */
    where: MuthawifWhereUniqueInput
    /**
     * In case the Muthawif found by the `where` argument doesn't exist, create a new Muthawif with this data.
     */
    create: XOR<MuthawifCreateInput, MuthawifUncheckedCreateInput>
    /**
     * In case the Muthawif was found with the provided `where` argument, update it with this data.
     */
    update: XOR<MuthawifUpdateInput, MuthawifUncheckedUpdateInput>
  }

  /**
   * Muthawif delete
   */
  export type MuthawifDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Muthawif
     */
    select?: MuthawifSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MuthawifInclude<ExtArgs> | null
    /**
     * Filter which Muthawif to delete.
     */
    where: MuthawifWhereUniqueInput
  }

  /**
   * Muthawif deleteMany
   */
  export type MuthawifDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Muthawifs to delete
     */
    where?: MuthawifWhereInput
  }

  /**
   * Muthawif.MitraPackages
   */
  export type Muthawif$MitraPackagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackage
     */
    select?: MitraPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageInclude<ExtArgs> | null
    where?: MitraPackageWhereInput
    orderBy?: MitraPackageOrderByWithRelationInput | MitraPackageOrderByWithRelationInput[]
    cursor?: MitraPackageWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MitraPackageScalarFieldEnum | MitraPackageScalarFieldEnum[]
  }

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


  /**
   * Model HandlingSaudi
   */

  export type AggregateHandlingSaudi = {
    _count: HandlingSaudiCountAggregateOutputType | null
    _avg: HandlingSaudiAvgAggregateOutputType | null
    _sum: HandlingSaudiSumAggregateOutputType | null
    _min: HandlingSaudiMinAggregateOutputType | null
    _max: HandlingSaudiMaxAggregateOutputType | null
  }

  export type HandlingSaudiAvgAggregateOutputType = {
    price_idr: Decimal | null
    order_number: number | null
  }

  export type HandlingSaudiSumAggregateOutputType = {
    price_idr: Decimal | null
    order_number: number | null
  }

  export type HandlingSaudiMinAggregateOutputType = {
    id: string | null
    name: string | null
    price_idr: Decimal | null
    order_number: number | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type HandlingSaudiMaxAggregateOutputType = {
    id: string | null
    name: string | null
    price_idr: Decimal | null
    order_number: number | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type HandlingSaudiCountAggregateOutputType = {
    id: number
    name: number
    price_idr: number
    order_number: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type HandlingSaudiAvgAggregateInputType = {
    price_idr?: true
    order_number?: true
  }

  export type HandlingSaudiSumAggregateInputType = {
    price_idr?: true
    order_number?: true
  }

  export type HandlingSaudiMinAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
  }

  export type HandlingSaudiMaxAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
  }

  export type HandlingSaudiCountAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type HandlingSaudiAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which HandlingSaudi to aggregate.
     */
    where?: HandlingSaudiWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of HandlingSaudis to fetch.
     */
    orderBy?: HandlingSaudiOrderByWithRelationInput | HandlingSaudiOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: HandlingSaudiWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` HandlingSaudis from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` HandlingSaudis.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned HandlingSaudis
    **/
    _count?: true | HandlingSaudiCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: HandlingSaudiAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: HandlingSaudiSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: HandlingSaudiMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: HandlingSaudiMaxAggregateInputType
  }

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




  export type HandlingSaudiGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: HandlingSaudiWhereInput
    orderBy?: HandlingSaudiOrderByWithAggregationInput | HandlingSaudiOrderByWithAggregationInput[]
    by: HandlingSaudiScalarFieldEnum[] | HandlingSaudiScalarFieldEnum
    having?: HandlingSaudiScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: HandlingSaudiCountAggregateInputType | true
    _avg?: HandlingSaudiAvgAggregateInputType
    _sum?: HandlingSaudiSumAggregateInputType
    _min?: HandlingSaudiMinAggregateInputType
    _max?: HandlingSaudiMaxAggregateInputType
  }

  export type HandlingSaudiGroupByOutputType = {
    id: string
    name: string
    price_idr: Decimal
    order_number: number
    created_at: Date
    updated_at: Date
    _count: HandlingSaudiCountAggregateOutputType | null
    _avg: HandlingSaudiAvgAggregateOutputType | null
    _sum: HandlingSaudiSumAggregateOutputType | null
    _min: HandlingSaudiMinAggregateOutputType | null
    _max: HandlingSaudiMaxAggregateOutputType | null
  }

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


  export type HandlingSaudiSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    price_idr?: boolean
    order_number?: boolean
    created_at?: boolean
    updated_at?: boolean
    MitraPackages?: boolean | HandlingSaudi$MitraPackagesArgs<ExtArgs>
    _count?: boolean | HandlingSaudiCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["handlingSaudi"]>


  export type HandlingSaudiSelectScalar = {
    id?: boolean
    name?: boolean
    price_idr?: boolean
    order_number?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type HandlingSaudiInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    MitraPackages?: boolean | HandlingSaudi$MitraPackagesArgs<ExtArgs>
    _count?: boolean | HandlingSaudiCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $HandlingSaudiPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "HandlingSaudi"
    objects: {
      MitraPackages: Prisma.$MitraPackagePayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      price_idr: Prisma.Decimal
      order_number: number
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["handlingSaudi"]>
    composites: {}
  }

  type HandlingSaudiGetPayload<S extends boolean | null | undefined | HandlingSaudiDefaultArgs> = $Result.GetResult<Prisma.$HandlingSaudiPayload, S>

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

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

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

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

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

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

    /**
     * Create a HandlingSaudi.
     * @param {HandlingSaudiCreateArgs} args - Arguments to create a HandlingSaudi.
     * @example
     * // Create one HandlingSaudi
     * const HandlingSaudi = await prisma.handlingSaudi.create({
     *   data: {
     *     // ... data to create a HandlingSaudi
     *   }
     * })
     * 
     */
    create<T extends HandlingSaudiCreateArgs>(args: SelectSubset<T, HandlingSaudiCreateArgs<ExtArgs>>): Prisma__HandlingSaudiClient<$Result.GetResult<Prisma.$HandlingSaudiPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Delete a HandlingSaudi.
     * @param {HandlingSaudiDeleteArgs} args - Arguments to delete one HandlingSaudi.
     * @example
     * // Delete one HandlingSaudi
     * const HandlingSaudi = await prisma.handlingSaudi.delete({
     *   where: {
     *     // ... filter to delete one HandlingSaudi
     *   }
     * })
     * 
     */
    delete<T extends HandlingSaudiDeleteArgs>(args: SelectSubset<T, HandlingSaudiDeleteArgs<ExtArgs>>): Prisma__HandlingSaudiClient<$Result.GetResult<Prisma.$HandlingSaudiPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for HandlingSaudi.
   * 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__HandlingSaudiClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    MitraPackages<T extends HandlingSaudi$MitraPackagesArgs<ExtArgs> = {}>(args?: Subset<T, HandlingSaudi$MitraPackagesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MitraPackagePayload<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 HandlingSaudi model
   */ 
  interface HandlingSaudiFieldRefs {
    readonly id: FieldRef<"HandlingSaudi", 'String'>
    readonly name: FieldRef<"HandlingSaudi", 'String'>
    readonly price_idr: FieldRef<"HandlingSaudi", 'Decimal'>
    readonly order_number: FieldRef<"HandlingSaudi", 'Int'>
    readonly created_at: FieldRef<"HandlingSaudi", 'DateTime'>
    readonly updated_at: FieldRef<"HandlingSaudi", 'DateTime'>
  }
    

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

  /**
   * HandlingSaudi findUniqueOrThrow
   */
  export type HandlingSaudiFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HandlingSaudi
     */
    select?: HandlingSaudiSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: HandlingSaudiInclude<ExtArgs> | null
    /**
     * Filter, which HandlingSaudi to fetch.
     */
    where: HandlingSaudiWhereUniqueInput
  }

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

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

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

  /**
   * HandlingSaudi create
   */
  export type HandlingSaudiCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HandlingSaudi
     */
    select?: HandlingSaudiSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: HandlingSaudiInclude<ExtArgs> | null
    /**
     * The data needed to create a HandlingSaudi.
     */
    data: XOR<HandlingSaudiCreateInput, HandlingSaudiUncheckedCreateInput>
  }

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

  /**
   * HandlingSaudi update
   */
  export type HandlingSaudiUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HandlingSaudi
     */
    select?: HandlingSaudiSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: HandlingSaudiInclude<ExtArgs> | null
    /**
     * The data needed to update a HandlingSaudi.
     */
    data: XOR<HandlingSaudiUpdateInput, HandlingSaudiUncheckedUpdateInput>
    /**
     * Choose, which HandlingSaudi to update.
     */
    where: HandlingSaudiWhereUniqueInput
  }

  /**
   * HandlingSaudi updateMany
   */
  export type HandlingSaudiUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update HandlingSaudis.
     */
    data: XOR<HandlingSaudiUpdateManyMutationInput, HandlingSaudiUncheckedUpdateManyInput>
    /**
     * Filter which HandlingSaudis to update
     */
    where?: HandlingSaudiWhereInput
  }

  /**
   * HandlingSaudi upsert
   */
  export type HandlingSaudiUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HandlingSaudi
     */
    select?: HandlingSaudiSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: HandlingSaudiInclude<ExtArgs> | null
    /**
     * The filter to search for the HandlingSaudi to update in case it exists.
     */
    where: HandlingSaudiWhereUniqueInput
    /**
     * In case the HandlingSaudi found by the `where` argument doesn't exist, create a new HandlingSaudi with this data.
     */
    create: XOR<HandlingSaudiCreateInput, HandlingSaudiUncheckedCreateInput>
    /**
     * In case the HandlingSaudi was found with the provided `where` argument, update it with this data.
     */
    update: XOR<HandlingSaudiUpdateInput, HandlingSaudiUncheckedUpdateInput>
  }

  /**
   * HandlingSaudi delete
   */
  export type HandlingSaudiDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HandlingSaudi
     */
    select?: HandlingSaudiSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: HandlingSaudiInclude<ExtArgs> | null
    /**
     * Filter which HandlingSaudi to delete.
     */
    where: HandlingSaudiWhereUniqueInput
  }

  /**
   * HandlingSaudi deleteMany
   */
  export type HandlingSaudiDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which HandlingSaudis to delete
     */
    where?: HandlingSaudiWhereInput
  }

  /**
   * HandlingSaudi.MitraPackages
   */
  export type HandlingSaudi$MitraPackagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackage
     */
    select?: MitraPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageInclude<ExtArgs> | null
    where?: MitraPackageWhereInput
    orderBy?: MitraPackageOrderByWithRelationInput | MitraPackageOrderByWithRelationInput[]
    cursor?: MitraPackageWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MitraPackageScalarFieldEnum | MitraPackageScalarFieldEnum[]
  }

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


  /**
   * Model HandlingDomestic
   */

  export type AggregateHandlingDomestic = {
    _count: HandlingDomesticCountAggregateOutputType | null
    _avg: HandlingDomesticAvgAggregateOutputType | null
    _sum: HandlingDomesticSumAggregateOutputType | null
    _min: HandlingDomesticMinAggregateOutputType | null
    _max: HandlingDomesticMaxAggregateOutputType | null
  }

  export type HandlingDomesticAvgAggregateOutputType = {
    price_idr: Decimal | null
    order_number: number | null
  }

  export type HandlingDomesticSumAggregateOutputType = {
    price_idr: Decimal | null
    order_number: number | null
  }

  export type HandlingDomesticMinAggregateOutputType = {
    id: string | null
    name: string | null
    price_idr: Decimal | null
    order_number: number | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type HandlingDomesticMaxAggregateOutputType = {
    id: string | null
    name: string | null
    price_idr: Decimal | null
    order_number: number | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type HandlingDomesticCountAggregateOutputType = {
    id: number
    name: number
    price_idr: number
    order_number: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type HandlingDomesticAvgAggregateInputType = {
    price_idr?: true
    order_number?: true
  }

  export type HandlingDomesticSumAggregateInputType = {
    price_idr?: true
    order_number?: true
  }

  export type HandlingDomesticMinAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
  }

  export type HandlingDomesticMaxAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
  }

  export type HandlingDomesticCountAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type HandlingDomesticAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which HandlingDomestic to aggregate.
     */
    where?: HandlingDomesticWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of HandlingDomestics to fetch.
     */
    orderBy?: HandlingDomesticOrderByWithRelationInput | HandlingDomesticOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: HandlingDomesticWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` HandlingDomestics from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` HandlingDomestics.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned HandlingDomestics
    **/
    _count?: true | HandlingDomesticCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: HandlingDomesticAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: HandlingDomesticSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: HandlingDomesticMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: HandlingDomesticMaxAggregateInputType
  }

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




  export type HandlingDomesticGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: HandlingDomesticWhereInput
    orderBy?: HandlingDomesticOrderByWithAggregationInput | HandlingDomesticOrderByWithAggregationInput[]
    by: HandlingDomesticScalarFieldEnum[] | HandlingDomesticScalarFieldEnum
    having?: HandlingDomesticScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: HandlingDomesticCountAggregateInputType | true
    _avg?: HandlingDomesticAvgAggregateInputType
    _sum?: HandlingDomesticSumAggregateInputType
    _min?: HandlingDomesticMinAggregateInputType
    _max?: HandlingDomesticMaxAggregateInputType
  }

  export type HandlingDomesticGroupByOutputType = {
    id: string
    name: string
    price_idr: Decimal
    order_number: number
    created_at: Date
    updated_at: Date
    _count: HandlingDomesticCountAggregateOutputType | null
    _avg: HandlingDomesticAvgAggregateOutputType | null
    _sum: HandlingDomesticSumAggregateOutputType | null
    _min: HandlingDomesticMinAggregateOutputType | null
    _max: HandlingDomesticMaxAggregateOutputType | null
  }

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


  export type HandlingDomesticSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    price_idr?: boolean
    order_number?: boolean
    created_at?: boolean
    updated_at?: boolean
    MitraPackages?: boolean | HandlingDomestic$MitraPackagesArgs<ExtArgs>
    _count?: boolean | HandlingDomesticCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["handlingDomestic"]>


  export type HandlingDomesticSelectScalar = {
    id?: boolean
    name?: boolean
    price_idr?: boolean
    order_number?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type HandlingDomesticInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    MitraPackages?: boolean | HandlingDomestic$MitraPackagesArgs<ExtArgs>
    _count?: boolean | HandlingDomesticCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $HandlingDomesticPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "HandlingDomestic"
    objects: {
      MitraPackages: Prisma.$MitraPackagePayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      price_idr: Prisma.Decimal
      order_number: number
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["handlingDomestic"]>
    composites: {}
  }

  type HandlingDomesticGetPayload<S extends boolean | null | undefined | HandlingDomesticDefaultArgs> = $Result.GetResult<Prisma.$HandlingDomesticPayload, S>

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

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

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

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

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

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

    /**
     * Create a HandlingDomestic.
     * @param {HandlingDomesticCreateArgs} args - Arguments to create a HandlingDomestic.
     * @example
     * // Create one HandlingDomestic
     * const HandlingDomestic = await prisma.handlingDomestic.create({
     *   data: {
     *     // ... data to create a HandlingDomestic
     *   }
     * })
     * 
     */
    create<T extends HandlingDomesticCreateArgs>(args: SelectSubset<T, HandlingDomesticCreateArgs<ExtArgs>>): Prisma__HandlingDomesticClient<$Result.GetResult<Prisma.$HandlingDomesticPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Delete a HandlingDomestic.
     * @param {HandlingDomesticDeleteArgs} args - Arguments to delete one HandlingDomestic.
     * @example
     * // Delete one HandlingDomestic
     * const HandlingDomestic = await prisma.handlingDomestic.delete({
     *   where: {
     *     // ... filter to delete one HandlingDomestic
     *   }
     * })
     * 
     */
    delete<T extends HandlingDomesticDeleteArgs>(args: SelectSubset<T, HandlingDomesticDeleteArgs<ExtArgs>>): Prisma__HandlingDomesticClient<$Result.GetResult<Prisma.$HandlingDomesticPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for HandlingDomestic.
   * 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__HandlingDomesticClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    MitraPackages<T extends HandlingDomestic$MitraPackagesArgs<ExtArgs> = {}>(args?: Subset<T, HandlingDomestic$MitraPackagesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MitraPackagePayload<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 HandlingDomestic model
   */ 
  interface HandlingDomesticFieldRefs {
    readonly id: FieldRef<"HandlingDomestic", 'String'>
    readonly name: FieldRef<"HandlingDomestic", 'String'>
    readonly price_idr: FieldRef<"HandlingDomestic", 'Decimal'>
    readonly order_number: FieldRef<"HandlingDomestic", 'Int'>
    readonly created_at: FieldRef<"HandlingDomestic", 'DateTime'>
    readonly updated_at: FieldRef<"HandlingDomestic", 'DateTime'>
  }
    

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

  /**
   * HandlingDomestic findUniqueOrThrow
   */
  export type HandlingDomesticFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HandlingDomestic
     */
    select?: HandlingDomesticSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: HandlingDomesticInclude<ExtArgs> | null
    /**
     * Filter, which HandlingDomestic to fetch.
     */
    where: HandlingDomesticWhereUniqueInput
  }

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

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

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

  /**
   * HandlingDomestic create
   */
  export type HandlingDomesticCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HandlingDomestic
     */
    select?: HandlingDomesticSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: HandlingDomesticInclude<ExtArgs> | null
    /**
     * The data needed to create a HandlingDomestic.
     */
    data: XOR<HandlingDomesticCreateInput, HandlingDomesticUncheckedCreateInput>
  }

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

  /**
   * HandlingDomestic update
   */
  export type HandlingDomesticUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HandlingDomestic
     */
    select?: HandlingDomesticSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: HandlingDomesticInclude<ExtArgs> | null
    /**
     * The data needed to update a HandlingDomestic.
     */
    data: XOR<HandlingDomesticUpdateInput, HandlingDomesticUncheckedUpdateInput>
    /**
     * Choose, which HandlingDomestic to update.
     */
    where: HandlingDomesticWhereUniqueInput
  }

  /**
   * HandlingDomestic updateMany
   */
  export type HandlingDomesticUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update HandlingDomestics.
     */
    data: XOR<HandlingDomesticUpdateManyMutationInput, HandlingDomesticUncheckedUpdateManyInput>
    /**
     * Filter which HandlingDomestics to update
     */
    where?: HandlingDomesticWhereInput
  }

  /**
   * HandlingDomestic upsert
   */
  export type HandlingDomesticUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HandlingDomestic
     */
    select?: HandlingDomesticSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: HandlingDomesticInclude<ExtArgs> | null
    /**
     * The filter to search for the HandlingDomestic to update in case it exists.
     */
    where: HandlingDomesticWhereUniqueInput
    /**
     * In case the HandlingDomestic found by the `where` argument doesn't exist, create a new HandlingDomestic with this data.
     */
    create: XOR<HandlingDomesticCreateInput, HandlingDomesticUncheckedCreateInput>
    /**
     * In case the HandlingDomestic was found with the provided `where` argument, update it with this data.
     */
    update: XOR<HandlingDomesticUpdateInput, HandlingDomesticUncheckedUpdateInput>
  }

  /**
   * HandlingDomestic delete
   */
  export type HandlingDomesticDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HandlingDomestic
     */
    select?: HandlingDomesticSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: HandlingDomesticInclude<ExtArgs> | null
    /**
     * Filter which HandlingDomestic to delete.
     */
    where: HandlingDomesticWhereUniqueInput
  }

  /**
   * HandlingDomestic deleteMany
   */
  export type HandlingDomesticDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which HandlingDomestics to delete
     */
    where?: HandlingDomesticWhereInput
  }

  /**
   * HandlingDomestic.MitraPackages
   */
  export type HandlingDomestic$MitraPackagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackage
     */
    select?: MitraPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageInclude<ExtArgs> | null
    where?: MitraPackageWhereInput
    orderBy?: MitraPackageOrderByWithRelationInput | MitraPackageOrderByWithRelationInput[]
    cursor?: MitraPackageWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MitraPackageScalarFieldEnum | MitraPackageScalarFieldEnum[]
  }

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


  /**
   * Model Siskopatuh
   */

  export type AggregateSiskopatuh = {
    _count: SiskopatuhCountAggregateOutputType | null
    _avg: SiskopatuhAvgAggregateOutputType | null
    _sum: SiskopatuhSumAggregateOutputType | null
    _min: SiskopatuhMinAggregateOutputType | null
    _max: SiskopatuhMaxAggregateOutputType | null
  }

  export type SiskopatuhAvgAggregateOutputType = {
    price_idr: Decimal | null
    order_number: number | null
  }

  export type SiskopatuhSumAggregateOutputType = {
    price_idr: Decimal | null
    order_number: number | null
  }

  export type SiskopatuhMinAggregateOutputType = {
    id: string | null
    name: string | null
    price_idr: Decimal | null
    order_number: number | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type SiskopatuhMaxAggregateOutputType = {
    id: string | null
    name: string | null
    price_idr: Decimal | null
    order_number: number | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type SiskopatuhCountAggregateOutputType = {
    id: number
    name: number
    price_idr: number
    order_number: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type SiskopatuhAvgAggregateInputType = {
    price_idr?: true
    order_number?: true
  }

  export type SiskopatuhSumAggregateInputType = {
    price_idr?: true
    order_number?: true
  }

  export type SiskopatuhMinAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
  }

  export type SiskopatuhMaxAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
  }

  export type SiskopatuhCountAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type SiskopatuhAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Siskopatuh to aggregate.
     */
    where?: SiskopatuhWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Siskopatuhs to fetch.
     */
    orderBy?: SiskopatuhOrderByWithRelationInput | SiskopatuhOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: SiskopatuhWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Siskopatuhs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Siskopatuhs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Siskopatuhs
    **/
    _count?: true | SiskopatuhCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: SiskopatuhAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: SiskopatuhSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: SiskopatuhMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: SiskopatuhMaxAggregateInputType
  }

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




  export type SiskopatuhGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SiskopatuhWhereInput
    orderBy?: SiskopatuhOrderByWithAggregationInput | SiskopatuhOrderByWithAggregationInput[]
    by: SiskopatuhScalarFieldEnum[] | SiskopatuhScalarFieldEnum
    having?: SiskopatuhScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: SiskopatuhCountAggregateInputType | true
    _avg?: SiskopatuhAvgAggregateInputType
    _sum?: SiskopatuhSumAggregateInputType
    _min?: SiskopatuhMinAggregateInputType
    _max?: SiskopatuhMaxAggregateInputType
  }

  export type SiskopatuhGroupByOutputType = {
    id: string
    name: string
    price_idr: Decimal
    order_number: number
    created_at: Date
    updated_at: Date
    _count: SiskopatuhCountAggregateOutputType | null
    _avg: SiskopatuhAvgAggregateOutputType | null
    _sum: SiskopatuhSumAggregateOutputType | null
    _min: SiskopatuhMinAggregateOutputType | null
    _max: SiskopatuhMaxAggregateOutputType | null
  }

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


  export type SiskopatuhSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    price_idr?: boolean
    order_number?: boolean
    created_at?: boolean
    updated_at?: boolean
    MitraPackages?: boolean | Siskopatuh$MitraPackagesArgs<ExtArgs>
    _count?: boolean | SiskopatuhCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["siskopatuh"]>


  export type SiskopatuhSelectScalar = {
    id?: boolean
    name?: boolean
    price_idr?: boolean
    order_number?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type SiskopatuhInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    MitraPackages?: boolean | Siskopatuh$MitraPackagesArgs<ExtArgs>
    _count?: boolean | SiskopatuhCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $SiskopatuhPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Siskopatuh"
    objects: {
      MitraPackages: Prisma.$MitraPackagePayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      price_idr: Prisma.Decimal
      order_number: number
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["siskopatuh"]>
    composites: {}
  }

  type SiskopatuhGetPayload<S extends boolean | null | undefined | SiskopatuhDefaultArgs> = $Result.GetResult<Prisma.$SiskopatuhPayload, S>

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

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

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

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

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

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

    /**
     * Create a Siskopatuh.
     * @param {SiskopatuhCreateArgs} args - Arguments to create a Siskopatuh.
     * @example
     * // Create one Siskopatuh
     * const Siskopatuh = await prisma.siskopatuh.create({
     *   data: {
     *     // ... data to create a Siskopatuh
     *   }
     * })
     * 
     */
    create<T extends SiskopatuhCreateArgs>(args: SelectSubset<T, SiskopatuhCreateArgs<ExtArgs>>): Prisma__SiskopatuhClient<$Result.GetResult<Prisma.$SiskopatuhPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Delete a Siskopatuh.
     * @param {SiskopatuhDeleteArgs} args - Arguments to delete one Siskopatuh.
     * @example
     * // Delete one Siskopatuh
     * const Siskopatuh = await prisma.siskopatuh.delete({
     *   where: {
     *     // ... filter to delete one Siskopatuh
     *   }
     * })
     * 
     */
    delete<T extends SiskopatuhDeleteArgs>(args: SelectSubset<T, SiskopatuhDeleteArgs<ExtArgs>>): Prisma__SiskopatuhClient<$Result.GetResult<Prisma.$SiskopatuhPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Siskopatuh.
   * 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__SiskopatuhClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    MitraPackages<T extends Siskopatuh$MitraPackagesArgs<ExtArgs> = {}>(args?: Subset<T, Siskopatuh$MitraPackagesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MitraPackagePayload<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 Siskopatuh model
   */ 
  interface SiskopatuhFieldRefs {
    readonly id: FieldRef<"Siskopatuh", 'String'>
    readonly name: FieldRef<"Siskopatuh", 'String'>
    readonly price_idr: FieldRef<"Siskopatuh", 'Decimal'>
    readonly order_number: FieldRef<"Siskopatuh", 'Int'>
    readonly created_at: FieldRef<"Siskopatuh", 'DateTime'>
    readonly updated_at: FieldRef<"Siskopatuh", 'DateTime'>
  }
    

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

  /**
   * Siskopatuh findUniqueOrThrow
   */
  export type SiskopatuhFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Siskopatuh
     */
    select?: SiskopatuhSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SiskopatuhInclude<ExtArgs> | null
    /**
     * Filter, which Siskopatuh to fetch.
     */
    where: SiskopatuhWhereUniqueInput
  }

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

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

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

  /**
   * Siskopatuh create
   */
  export type SiskopatuhCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Siskopatuh
     */
    select?: SiskopatuhSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SiskopatuhInclude<ExtArgs> | null
    /**
     * The data needed to create a Siskopatuh.
     */
    data: XOR<SiskopatuhCreateInput, SiskopatuhUncheckedCreateInput>
  }

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

  /**
   * Siskopatuh update
   */
  export type SiskopatuhUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Siskopatuh
     */
    select?: SiskopatuhSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SiskopatuhInclude<ExtArgs> | null
    /**
     * The data needed to update a Siskopatuh.
     */
    data: XOR<SiskopatuhUpdateInput, SiskopatuhUncheckedUpdateInput>
    /**
     * Choose, which Siskopatuh to update.
     */
    where: SiskopatuhWhereUniqueInput
  }

  /**
   * Siskopatuh updateMany
   */
  export type SiskopatuhUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Siskopatuhs.
     */
    data: XOR<SiskopatuhUpdateManyMutationInput, SiskopatuhUncheckedUpdateManyInput>
    /**
     * Filter which Siskopatuhs to update
     */
    where?: SiskopatuhWhereInput
  }

  /**
   * Siskopatuh upsert
   */
  export type SiskopatuhUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Siskopatuh
     */
    select?: SiskopatuhSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SiskopatuhInclude<ExtArgs> | null
    /**
     * The filter to search for the Siskopatuh to update in case it exists.
     */
    where: SiskopatuhWhereUniqueInput
    /**
     * In case the Siskopatuh found by the `where` argument doesn't exist, create a new Siskopatuh with this data.
     */
    create: XOR<SiskopatuhCreateInput, SiskopatuhUncheckedCreateInput>
    /**
     * In case the Siskopatuh was found with the provided `where` argument, update it with this data.
     */
    update: XOR<SiskopatuhUpdateInput, SiskopatuhUncheckedUpdateInput>
  }

  /**
   * Siskopatuh delete
   */
  export type SiskopatuhDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Siskopatuh
     */
    select?: SiskopatuhSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SiskopatuhInclude<ExtArgs> | null
    /**
     * Filter which Siskopatuh to delete.
     */
    where: SiskopatuhWhereUniqueInput
  }

  /**
   * Siskopatuh deleteMany
   */
  export type SiskopatuhDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Siskopatuhs to delete
     */
    where?: SiskopatuhWhereInput
  }

  /**
   * Siskopatuh.MitraPackages
   */
  export type Siskopatuh$MitraPackagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackage
     */
    select?: MitraPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageInclude<ExtArgs> | null
    where?: MitraPackageWhereInput
    orderBy?: MitraPackageOrderByWithRelationInput | MitraPackageOrderByWithRelationInput[]
    cursor?: MitraPackageWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MitraPackageScalarFieldEnum | MitraPackageScalarFieldEnum[]
  }

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


  /**
   * Model Equipment
   */

  export type AggregateEquipment = {
    _count: EquipmentCountAggregateOutputType | null
    _avg: EquipmentAvgAggregateOutputType | null
    _sum: EquipmentSumAggregateOutputType | null
    _min: EquipmentMinAggregateOutputType | null
    _max: EquipmentMaxAggregateOutputType | null
  }

  export type EquipmentAvgAggregateOutputType = {
    price_idr: Decimal | null
    order_number: number | null
  }

  export type EquipmentSumAggregateOutputType = {
    price_idr: Decimal | null
    order_number: number | null
  }

  export type EquipmentMinAggregateOutputType = {
    id: string | null
    name: string | null
    price_idr: Decimal | null
    order_number: number | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type EquipmentMaxAggregateOutputType = {
    id: string | null
    name: string | null
    price_idr: Decimal | null
    order_number: number | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type EquipmentCountAggregateOutputType = {
    id: number
    name: number
    price_idr: number
    order_number: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type EquipmentAvgAggregateInputType = {
    price_idr?: true
    order_number?: true
  }

  export type EquipmentSumAggregateInputType = {
    price_idr?: true
    order_number?: true
  }

  export type EquipmentMinAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
  }

  export type EquipmentMaxAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
  }

  export type EquipmentCountAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

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

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




  export type EquipmentGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: EquipmentWhereInput
    orderBy?: EquipmentOrderByWithAggregationInput | EquipmentOrderByWithAggregationInput[]
    by: EquipmentScalarFieldEnum[] | EquipmentScalarFieldEnum
    having?: EquipmentScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: EquipmentCountAggregateInputType | true
    _avg?: EquipmentAvgAggregateInputType
    _sum?: EquipmentSumAggregateInputType
    _min?: EquipmentMinAggregateInputType
    _max?: EquipmentMaxAggregateInputType
  }

  export type EquipmentGroupByOutputType = {
    id: string
    name: string
    price_idr: Decimal
    order_number: number
    created_at: Date
    updated_at: Date
    _count: EquipmentCountAggregateOutputType | null
    _avg: EquipmentAvgAggregateOutputType | null
    _sum: EquipmentSumAggregateOutputType | null
    _min: EquipmentMinAggregateOutputType | null
    _max: EquipmentMaxAggregateOutputType | null
  }

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


  export type EquipmentSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    price_idr?: boolean
    order_number?: boolean
    created_at?: boolean
    updated_at?: boolean
    MitraPackages?: boolean | Equipment$MitraPackagesArgs<ExtArgs>
    _count?: boolean | EquipmentCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["equipment"]>


  export type EquipmentSelectScalar = {
    id?: boolean
    name?: boolean
    price_idr?: boolean
    order_number?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type EquipmentInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    MitraPackages?: boolean | Equipment$MitraPackagesArgs<ExtArgs>
    _count?: boolean | EquipmentCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $EquipmentPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Equipment"
    objects: {
      MitraPackages: Prisma.$MitraPackagePayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      price_idr: Prisma.Decimal
      order_number: number
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["equipment"]>
    composites: {}
  }

  type EquipmentGetPayload<S extends boolean | null | undefined | EquipmentDefaultArgs> = $Result.GetResult<Prisma.$EquipmentPayload, S>

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

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

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

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

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

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

    /**
     * Create a Equipment.
     * @param {EquipmentCreateArgs} args - Arguments to create a Equipment.
     * @example
     * // Create one Equipment
     * const Equipment = await prisma.equipment.create({
     *   data: {
     *     // ... data to create a Equipment
     *   }
     * })
     * 
     */
    create<T extends EquipmentCreateArgs>(args: SelectSubset<T, EquipmentCreateArgs<ExtArgs>>): Prisma__EquipmentClient<$Result.GetResult<Prisma.$EquipmentPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Delete a Equipment.
     * @param {EquipmentDeleteArgs} args - Arguments to delete one Equipment.
     * @example
     * // Delete one Equipment
     * const Equipment = await prisma.equipment.delete({
     *   where: {
     *     // ... filter to delete one Equipment
     *   }
     * })
     * 
     */
    delete<T extends EquipmentDeleteArgs>(args: SelectSubset<T, EquipmentDeleteArgs<ExtArgs>>): Prisma__EquipmentClient<$Result.GetResult<Prisma.$EquipmentPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Equipment.
   * 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__EquipmentClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    MitraPackages<T extends Equipment$MitraPackagesArgs<ExtArgs> = {}>(args?: Subset<T, Equipment$MitraPackagesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MitraPackagePayload<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 Equipment model
   */ 
  interface EquipmentFieldRefs {
    readonly id: FieldRef<"Equipment", 'String'>
    readonly name: FieldRef<"Equipment", 'String'>
    readonly price_idr: FieldRef<"Equipment", 'Decimal'>
    readonly order_number: FieldRef<"Equipment", 'Int'>
    readonly created_at: FieldRef<"Equipment", 'DateTime'>
    readonly updated_at: FieldRef<"Equipment", 'DateTime'>
  }
    

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

  /**
   * Equipment findUniqueOrThrow
   */
  export type EquipmentFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Equipment
     */
    select?: EquipmentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EquipmentInclude<ExtArgs> | null
    /**
     * Filter, which Equipment to fetch.
     */
    where: EquipmentWhereUniqueInput
  }

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

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

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

  /**
   * Equipment create
   */
  export type EquipmentCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Equipment
     */
    select?: EquipmentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EquipmentInclude<ExtArgs> | null
    /**
     * The data needed to create a Equipment.
     */
    data: XOR<EquipmentCreateInput, EquipmentUncheckedCreateInput>
  }

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

  /**
   * Equipment update
   */
  export type EquipmentUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Equipment
     */
    select?: EquipmentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EquipmentInclude<ExtArgs> | null
    /**
     * The data needed to update a Equipment.
     */
    data: XOR<EquipmentUpdateInput, EquipmentUncheckedUpdateInput>
    /**
     * Choose, which Equipment to update.
     */
    where: EquipmentWhereUniqueInput
  }

  /**
   * Equipment updateMany
   */
  export type EquipmentUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Equipment.
     */
    data: XOR<EquipmentUpdateManyMutationInput, EquipmentUncheckedUpdateManyInput>
    /**
     * Filter which Equipment to update
     */
    where?: EquipmentWhereInput
  }

  /**
   * Equipment upsert
   */
  export type EquipmentUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Equipment
     */
    select?: EquipmentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EquipmentInclude<ExtArgs> | null
    /**
     * The filter to search for the Equipment to update in case it exists.
     */
    where: EquipmentWhereUniqueInput
    /**
     * In case the Equipment found by the `where` argument doesn't exist, create a new Equipment with this data.
     */
    create: XOR<EquipmentCreateInput, EquipmentUncheckedCreateInput>
    /**
     * In case the Equipment was found with the provided `where` argument, update it with this data.
     */
    update: XOR<EquipmentUpdateInput, EquipmentUncheckedUpdateInput>
  }

  /**
   * Equipment delete
   */
  export type EquipmentDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Equipment
     */
    select?: EquipmentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EquipmentInclude<ExtArgs> | null
    /**
     * Filter which Equipment to delete.
     */
    where: EquipmentWhereUniqueInput
  }

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

  /**
   * Equipment.MitraPackages
   */
  export type Equipment$MitraPackagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackage
     */
    select?: MitraPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageInclude<ExtArgs> | null
    where?: MitraPackageWhereInput
    orderBy?: MitraPackageOrderByWithRelationInput | MitraPackageOrderByWithRelationInput[]
    cursor?: MitraPackageWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MitraPackageScalarFieldEnum | MitraPackageScalarFieldEnum[]
  }

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


  /**
   * Model TourPlus
   */

  export type AggregateTourPlus = {
    _count: TourPlusCountAggregateOutputType | null
    _avg: TourPlusAvgAggregateOutputType | null
    _sum: TourPlusSumAggregateOutputType | null
    _min: TourPlusMinAggregateOutputType | null
    _max: TourPlusMaxAggregateOutputType | null
  }

  export type TourPlusAvgAggregateOutputType = {
    price_idr: Decimal | null
    order_number: number | null
  }

  export type TourPlusSumAggregateOutputType = {
    price_idr: Decimal | null
    order_number: number | null
  }

  export type TourPlusMinAggregateOutputType = {
    id: string | null
    name: string | null
    price_idr: Decimal | null
    order_number: number | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type TourPlusMaxAggregateOutputType = {
    id: string | null
    name: string | null
    price_idr: Decimal | null
    order_number: number | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type TourPlusCountAggregateOutputType = {
    id: number
    name: number
    price_idr: number
    order_number: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type TourPlusAvgAggregateInputType = {
    price_idr?: true
    order_number?: true
  }

  export type TourPlusSumAggregateInputType = {
    price_idr?: true
    order_number?: true
  }

  export type TourPlusMinAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
  }

  export type TourPlusMaxAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
  }

  export type TourPlusCountAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type TourPlusAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which TourPlus to aggregate.
     */
    where?: TourPlusWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of TourPluses to fetch.
     */
    orderBy?: TourPlusOrderByWithRelationInput | TourPlusOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: TourPlusWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` TourPluses from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` TourPluses.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned TourPluses
    **/
    _count?: true | TourPlusCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: TourPlusAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: TourPlusSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: TourPlusMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: TourPlusMaxAggregateInputType
  }

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




  export type TourPlusGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: TourPlusWhereInput
    orderBy?: TourPlusOrderByWithAggregationInput | TourPlusOrderByWithAggregationInput[]
    by: TourPlusScalarFieldEnum[] | TourPlusScalarFieldEnum
    having?: TourPlusScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: TourPlusCountAggregateInputType | true
    _avg?: TourPlusAvgAggregateInputType
    _sum?: TourPlusSumAggregateInputType
    _min?: TourPlusMinAggregateInputType
    _max?: TourPlusMaxAggregateInputType
  }

  export type TourPlusGroupByOutputType = {
    id: string
    name: string
    price_idr: Decimal
    order_number: number
    created_at: Date
    updated_at: Date
    _count: TourPlusCountAggregateOutputType | null
    _avg: TourPlusAvgAggregateOutputType | null
    _sum: TourPlusSumAggregateOutputType | null
    _min: TourPlusMinAggregateOutputType | null
    _max: TourPlusMaxAggregateOutputType | null
  }

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


  export type TourPlusSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    price_idr?: boolean
    order_number?: boolean
    created_at?: boolean
    updated_at?: boolean
    MitraPackages?: boolean | TourPlus$MitraPackagesArgs<ExtArgs>
    _count?: boolean | TourPlusCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["tourPlus"]>


  export type TourPlusSelectScalar = {
    id?: boolean
    name?: boolean
    price_idr?: boolean
    order_number?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type TourPlusInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    MitraPackages?: boolean | TourPlus$MitraPackagesArgs<ExtArgs>
    _count?: boolean | TourPlusCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $TourPlusPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "TourPlus"
    objects: {
      MitraPackages: Prisma.$MitraPackagePayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      price_idr: Prisma.Decimal
      order_number: number
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["tourPlus"]>
    composites: {}
  }

  type TourPlusGetPayload<S extends boolean | null | undefined | TourPlusDefaultArgs> = $Result.GetResult<Prisma.$TourPlusPayload, S>

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

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

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

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

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

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

    /**
     * Create a TourPlus.
     * @param {TourPlusCreateArgs} args - Arguments to create a TourPlus.
     * @example
     * // Create one TourPlus
     * const TourPlus = await prisma.tourPlus.create({
     *   data: {
     *     // ... data to create a TourPlus
     *   }
     * })
     * 
     */
    create<T extends TourPlusCreateArgs>(args: SelectSubset<T, TourPlusCreateArgs<ExtArgs>>): Prisma__TourPlusClient<$Result.GetResult<Prisma.$TourPlusPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Delete a TourPlus.
     * @param {TourPlusDeleteArgs} args - Arguments to delete one TourPlus.
     * @example
     * // Delete one TourPlus
     * const TourPlus = await prisma.tourPlus.delete({
     *   where: {
     *     // ... filter to delete one TourPlus
     *   }
     * })
     * 
     */
    delete<T extends TourPlusDeleteArgs>(args: SelectSubset<T, TourPlusDeleteArgs<ExtArgs>>): Prisma__TourPlusClient<$Result.GetResult<Prisma.$TourPlusPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for TourPlus.
   * 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__TourPlusClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    MitraPackages<T extends TourPlus$MitraPackagesArgs<ExtArgs> = {}>(args?: Subset<T, TourPlus$MitraPackagesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MitraPackagePayload<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 TourPlus model
   */ 
  interface TourPlusFieldRefs {
    readonly id: FieldRef<"TourPlus", 'String'>
    readonly name: FieldRef<"TourPlus", 'String'>
    readonly price_idr: FieldRef<"TourPlus", 'Decimal'>
    readonly order_number: FieldRef<"TourPlus", 'Int'>
    readonly created_at: FieldRef<"TourPlus", 'DateTime'>
    readonly updated_at: FieldRef<"TourPlus", 'DateTime'>
  }
    

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

  /**
   * TourPlus findUniqueOrThrow
   */
  export type TourPlusFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TourPlus
     */
    select?: TourPlusSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TourPlusInclude<ExtArgs> | null
    /**
     * Filter, which TourPlus to fetch.
     */
    where: TourPlusWhereUniqueInput
  }

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

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

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

  /**
   * TourPlus create
   */
  export type TourPlusCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TourPlus
     */
    select?: TourPlusSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TourPlusInclude<ExtArgs> | null
    /**
     * The data needed to create a TourPlus.
     */
    data: XOR<TourPlusCreateInput, TourPlusUncheckedCreateInput>
  }

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

  /**
   * TourPlus update
   */
  export type TourPlusUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TourPlus
     */
    select?: TourPlusSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TourPlusInclude<ExtArgs> | null
    /**
     * The data needed to update a TourPlus.
     */
    data: XOR<TourPlusUpdateInput, TourPlusUncheckedUpdateInput>
    /**
     * Choose, which TourPlus to update.
     */
    where: TourPlusWhereUniqueInput
  }

  /**
   * TourPlus updateMany
   */
  export type TourPlusUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update TourPluses.
     */
    data: XOR<TourPlusUpdateManyMutationInput, TourPlusUncheckedUpdateManyInput>
    /**
     * Filter which TourPluses to update
     */
    where?: TourPlusWhereInput
  }

  /**
   * TourPlus upsert
   */
  export type TourPlusUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TourPlus
     */
    select?: TourPlusSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TourPlusInclude<ExtArgs> | null
    /**
     * The filter to search for the TourPlus to update in case it exists.
     */
    where: TourPlusWhereUniqueInput
    /**
     * In case the TourPlus found by the `where` argument doesn't exist, create a new TourPlus with this data.
     */
    create: XOR<TourPlusCreateInput, TourPlusUncheckedCreateInput>
    /**
     * In case the TourPlus was found with the provided `where` argument, update it with this data.
     */
    update: XOR<TourPlusUpdateInput, TourPlusUncheckedUpdateInput>
  }

  /**
   * TourPlus delete
   */
  export type TourPlusDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TourPlus
     */
    select?: TourPlusSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TourPlusInclude<ExtArgs> | null
    /**
     * Filter which TourPlus to delete.
     */
    where: TourPlusWhereUniqueInput
  }

  /**
   * TourPlus deleteMany
   */
  export type TourPlusDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which TourPluses to delete
     */
    where?: TourPlusWhereInput
  }

  /**
   * TourPlus.MitraPackages
   */
  export type TourPlus$MitraPackagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackage
     */
    select?: MitraPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageInclude<ExtArgs> | null
    where?: MitraPackageWhereInput
    orderBy?: MitraPackageOrderByWithRelationInput | MitraPackageOrderByWithRelationInput[]
    cursor?: MitraPackageWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MitraPackageScalarFieldEnum | MitraPackageScalarFieldEnum[]
  }

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


  /**
   * Model Manasik
   */

  export type AggregateManasik = {
    _count: ManasikCountAggregateOutputType | null
    _avg: ManasikAvgAggregateOutputType | null
    _sum: ManasikSumAggregateOutputType | null
    _min: ManasikMinAggregateOutputType | null
    _max: ManasikMaxAggregateOutputType | null
  }

  export type ManasikAvgAggregateOutputType = {
    price_idr: Decimal | null
    order_number: number | null
  }

  export type ManasikSumAggregateOutputType = {
    price_idr: Decimal | null
    order_number: number | null
  }

  export type ManasikMinAggregateOutputType = {
    id: string | null
    name: string | null
    price_idr: Decimal | null
    order_number: number | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type ManasikMaxAggregateOutputType = {
    id: string | null
    name: string | null
    price_idr: Decimal | null
    order_number: number | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type ManasikCountAggregateOutputType = {
    id: number
    name: number
    price_idr: number
    order_number: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type ManasikAvgAggregateInputType = {
    price_idr?: true
    order_number?: true
  }

  export type ManasikSumAggregateInputType = {
    price_idr?: true
    order_number?: true
  }

  export type ManasikMinAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
  }

  export type ManasikMaxAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
  }

  export type ManasikCountAggregateInputType = {
    id?: true
    name?: true
    price_idr?: true
    order_number?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type ManasikAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Manasik to aggregate.
     */
    where?: ManasikWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Manasiks to fetch.
     */
    orderBy?: ManasikOrderByWithRelationInput | ManasikOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ManasikWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Manasiks from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Manasiks.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Manasiks
    **/
    _count?: true | ManasikCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ManasikAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ManasikSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ManasikMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ManasikMaxAggregateInputType
  }

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




  export type ManasikGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ManasikWhereInput
    orderBy?: ManasikOrderByWithAggregationInput | ManasikOrderByWithAggregationInput[]
    by: ManasikScalarFieldEnum[] | ManasikScalarFieldEnum
    having?: ManasikScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ManasikCountAggregateInputType | true
    _avg?: ManasikAvgAggregateInputType
    _sum?: ManasikSumAggregateInputType
    _min?: ManasikMinAggregateInputType
    _max?: ManasikMaxAggregateInputType
  }

  export type ManasikGroupByOutputType = {
    id: string
    name: string
    price_idr: Decimal
    order_number: number
    created_at: Date
    updated_at: Date
    _count: ManasikCountAggregateOutputType | null
    _avg: ManasikAvgAggregateOutputType | null
    _sum: ManasikSumAggregateOutputType | null
    _min: ManasikMinAggregateOutputType | null
    _max: ManasikMaxAggregateOutputType | null
  }

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


  export type ManasikSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    price_idr?: boolean
    order_number?: boolean
    created_at?: boolean
    updated_at?: boolean
    MitraPackages?: boolean | Manasik$MitraPackagesArgs<ExtArgs>
    _count?: boolean | ManasikCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["manasik"]>


  export type ManasikSelectScalar = {
    id?: boolean
    name?: boolean
    price_idr?: boolean
    order_number?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type ManasikInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    MitraPackages?: boolean | Manasik$MitraPackagesArgs<ExtArgs>
    _count?: boolean | ManasikCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $ManasikPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Manasik"
    objects: {
      MitraPackages: Prisma.$MitraPackagePayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      price_idr: Prisma.Decimal
      order_number: number
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["manasik"]>
    composites: {}
  }

  type ManasikGetPayload<S extends boolean | null | undefined | ManasikDefaultArgs> = $Result.GetResult<Prisma.$ManasikPayload, S>

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

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

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

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

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

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

    /**
     * Create a Manasik.
     * @param {ManasikCreateArgs} args - Arguments to create a Manasik.
     * @example
     * // Create one Manasik
     * const Manasik = await prisma.manasik.create({
     *   data: {
     *     // ... data to create a Manasik
     *   }
     * })
     * 
     */
    create<T extends ManasikCreateArgs>(args: SelectSubset<T, ManasikCreateArgs<ExtArgs>>): Prisma__ManasikClient<$Result.GetResult<Prisma.$ManasikPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

    /**
     * Delete a Manasik.
     * @param {ManasikDeleteArgs} args - Arguments to delete one Manasik.
     * @example
     * // Delete one Manasik
     * const Manasik = await prisma.manasik.delete({
     *   where: {
     *     // ... filter to delete one Manasik
     *   }
     * })
     * 
     */
    delete<T extends ManasikDeleteArgs>(args: SelectSubset<T, ManasikDeleteArgs<ExtArgs>>): Prisma__ManasikClient<$Result.GetResult<Prisma.$ManasikPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Manasik.
   * 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__ManasikClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    MitraPackages<T extends Manasik$MitraPackagesArgs<ExtArgs> = {}>(args?: Subset<T, Manasik$MitraPackagesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MitraPackagePayload<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 Manasik model
   */ 
  interface ManasikFieldRefs {
    readonly id: FieldRef<"Manasik", 'String'>
    readonly name: FieldRef<"Manasik", 'String'>
    readonly price_idr: FieldRef<"Manasik", 'Decimal'>
    readonly order_number: FieldRef<"Manasik", 'Int'>
    readonly created_at: FieldRef<"Manasik", 'DateTime'>
    readonly updated_at: FieldRef<"Manasik", 'DateTime'>
  }
    

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

  /**
   * Manasik findUniqueOrThrow
   */
  export type ManasikFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Manasik
     */
    select?: ManasikSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ManasikInclude<ExtArgs> | null
    /**
     * Filter, which Manasik to fetch.
     */
    where: ManasikWhereUniqueInput
  }

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

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

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

  /**
   * Manasik create
   */
  export type ManasikCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Manasik
     */
    select?: ManasikSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ManasikInclude<ExtArgs> | null
    /**
     * The data needed to create a Manasik.
     */
    data: XOR<ManasikCreateInput, ManasikUncheckedCreateInput>
  }

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

  /**
   * Manasik update
   */
  export type ManasikUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Manasik
     */
    select?: ManasikSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ManasikInclude<ExtArgs> | null
    /**
     * The data needed to update a Manasik.
     */
    data: XOR<ManasikUpdateInput, ManasikUncheckedUpdateInput>
    /**
     * Choose, which Manasik to update.
     */
    where: ManasikWhereUniqueInput
  }

  /**
   * Manasik updateMany
   */
  export type ManasikUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Manasiks.
     */
    data: XOR<ManasikUpdateManyMutationInput, ManasikUncheckedUpdateManyInput>
    /**
     * Filter which Manasiks to update
     */
    where?: ManasikWhereInput
  }

  /**
   * Manasik upsert
   */
  export type ManasikUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Manasik
     */
    select?: ManasikSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ManasikInclude<ExtArgs> | null
    /**
     * The filter to search for the Manasik to update in case it exists.
     */
    where: ManasikWhereUniqueInput
    /**
     * In case the Manasik found by the `where` argument doesn't exist, create a new Manasik with this data.
     */
    create: XOR<ManasikCreateInput, ManasikUncheckedCreateInput>
    /**
     * In case the Manasik was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ManasikUpdateInput, ManasikUncheckedUpdateInput>
  }

  /**
   * Manasik delete
   */
  export type ManasikDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Manasik
     */
    select?: ManasikSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ManasikInclude<ExtArgs> | null
    /**
     * Filter which Manasik to delete.
     */
    where: ManasikWhereUniqueInput
  }

  /**
   * Manasik deleteMany
   */
  export type ManasikDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Manasiks to delete
     */
    where?: ManasikWhereInput
  }

  /**
   * Manasik.MitraPackages
   */
  export type Manasik$MitraPackagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackage
     */
    select?: MitraPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageInclude<ExtArgs> | null
    where?: MitraPackageWhereInput
    orderBy?: MitraPackageOrderByWithRelationInput | MitraPackageOrderByWithRelationInput[]
    cursor?: MitraPackageWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MitraPackageScalarFieldEnum | MitraPackageScalarFieldEnum[]
  }

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


  /**
   * Model MitraPackage
   */

  export type AggregateMitraPackage = {
    _count: MitraPackageCountAggregateOutputType | null
    _avg: MitraPackageAvgAggregateOutputType | null
    _sum: MitraPackageSumAggregateOutputType | null
    _min: MitraPackageMinAggregateOutputType | null
    _max: MitraPackageMaxAggregateOutputType | null
  }

  export type MitraPackageAvgAggregateOutputType = {
    number_of_pax: number | null
    travel_duration: number | null
    mekkah_duration: number | null
    madinah_duration: number | null
    tour_leader: number | null
    margin: Decimal | null
    per_pax_price_double: Decimal | null
    per_pax_price_triple: Decimal | null
    per_pax_price_quad: Decimal | null
  }

  export type MitraPackageSumAggregateOutputType = {
    number_of_pax: number | null
    travel_duration: number | null
    mekkah_duration: number | null
    madinah_duration: number | null
    tour_leader: number | null
    margin: Decimal | null
    per_pax_price_double: Decimal | null
    per_pax_price_triple: Decimal | null
    per_pax_price_quad: Decimal | null
  }

  export type MitraPackageMinAggregateOutputType = {
    id: string | null
    period_id: string | null
    airline_id: string | null
    vendor_id: string | null
    hotel_mekkah_id: string | null
    hotel_madinah_id: string | null
    visa_id: string | null
    transportation_id: string | null
    muthawif_id: string | null
    handling_saudi_id: string | null
    handling_domestic_id: string | null
    siskopatuh_id: string | null
    equipment_id: string | null
    tour_plus_id: string | null
    manasik_id: string | null
    number_of_pax: number | null
    departure_date: Date | null
    travel_duration: number | null
    mekkah_duration: number | null
    madinah_duration: number | null
    tour_leader: number | null
    margin: Decimal | null
    per_pax_price_double: Decimal | null
    per_pax_price_triple: Decimal | null
    per_pax_price_quad: Decimal | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type MitraPackageMaxAggregateOutputType = {
    id: string | null
    period_id: string | null
    airline_id: string | null
    vendor_id: string | null
    hotel_mekkah_id: string | null
    hotel_madinah_id: string | null
    visa_id: string | null
    transportation_id: string | null
    muthawif_id: string | null
    handling_saudi_id: string | null
    handling_domestic_id: string | null
    siskopatuh_id: string | null
    equipment_id: string | null
    tour_plus_id: string | null
    manasik_id: string | null
    number_of_pax: number | null
    departure_date: Date | null
    travel_duration: number | null
    mekkah_duration: number | null
    madinah_duration: number | null
    tour_leader: number | null
    margin: Decimal | null
    per_pax_price_double: Decimal | null
    per_pax_price_triple: Decimal | null
    per_pax_price_quad: Decimal | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type MitraPackageCountAggregateOutputType = {
    id: number
    period_id: number
    airline_id: number
    vendor_id: number
    hotel_mekkah_id: number
    hotel_madinah_id: number
    visa_id: number
    transportation_id: number
    muthawif_id: number
    handling_saudi_id: number
    handling_domestic_id: number
    siskopatuh_id: number
    equipment_id: number
    tour_plus_id: number
    manasik_id: number
    number_of_pax: number
    departure_date: number
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: number
    per_pax_price_double: number
    per_pax_price_triple: number
    per_pax_price_quad: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type MitraPackageAvgAggregateInputType = {
    number_of_pax?: true
    travel_duration?: true
    mekkah_duration?: true
    madinah_duration?: true
    tour_leader?: true
    margin?: true
    per_pax_price_double?: true
    per_pax_price_triple?: true
    per_pax_price_quad?: true
  }

  export type MitraPackageSumAggregateInputType = {
    number_of_pax?: true
    travel_duration?: true
    mekkah_duration?: true
    madinah_duration?: true
    tour_leader?: true
    margin?: true
    per_pax_price_double?: true
    per_pax_price_triple?: true
    per_pax_price_quad?: true
  }

  export type MitraPackageMinAggregateInputType = {
    id?: true
    period_id?: true
    airline_id?: true
    vendor_id?: true
    hotel_mekkah_id?: true
    hotel_madinah_id?: true
    visa_id?: true
    transportation_id?: true
    muthawif_id?: true
    handling_saudi_id?: true
    handling_domestic_id?: true
    siskopatuh_id?: true
    equipment_id?: true
    tour_plus_id?: true
    manasik_id?: true
    number_of_pax?: true
    departure_date?: true
    travel_duration?: true
    mekkah_duration?: true
    madinah_duration?: true
    tour_leader?: true
    margin?: true
    per_pax_price_double?: true
    per_pax_price_triple?: true
    per_pax_price_quad?: true
    created_at?: true
    updated_at?: true
  }

  export type MitraPackageMaxAggregateInputType = {
    id?: true
    period_id?: true
    airline_id?: true
    vendor_id?: true
    hotel_mekkah_id?: true
    hotel_madinah_id?: true
    visa_id?: true
    transportation_id?: true
    muthawif_id?: true
    handling_saudi_id?: true
    handling_domestic_id?: true
    siskopatuh_id?: true
    equipment_id?: true
    tour_plus_id?: true
    manasik_id?: true
    number_of_pax?: true
    departure_date?: true
    travel_duration?: true
    mekkah_duration?: true
    madinah_duration?: true
    tour_leader?: true
    margin?: true
    per_pax_price_double?: true
    per_pax_price_triple?: true
    per_pax_price_quad?: true
    created_at?: true
    updated_at?: true
  }

  export type MitraPackageCountAggregateInputType = {
    id?: true
    period_id?: true
    airline_id?: true
    vendor_id?: true
    hotel_mekkah_id?: true
    hotel_madinah_id?: true
    visa_id?: true
    transportation_id?: true
    muthawif_id?: true
    handling_saudi_id?: true
    handling_domestic_id?: true
    siskopatuh_id?: true
    equipment_id?: true
    tour_plus_id?: true
    manasik_id?: true
    number_of_pax?: true
    departure_date?: true
    travel_duration?: true
    mekkah_duration?: true
    madinah_duration?: true
    tour_leader?: true
    margin?: true
    per_pax_price_double?: true
    per_pax_price_triple?: true
    per_pax_price_quad?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type MitraPackageAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which MitraPackage to aggregate.
     */
    where?: MitraPackageWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MitraPackages to fetch.
     */
    orderBy?: MitraPackageOrderByWithRelationInput | MitraPackageOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: MitraPackageWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MitraPackages from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` MitraPackages.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned MitraPackages
    **/
    _count?: true | MitraPackageCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: MitraPackageAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: MitraPackageSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: MitraPackageMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: MitraPackageMaxAggregateInputType
  }

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




  export type MitraPackageGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MitraPackageWhereInput
    orderBy?: MitraPackageOrderByWithAggregationInput | MitraPackageOrderByWithAggregationInput[]
    by: MitraPackageScalarFieldEnum[] | MitraPackageScalarFieldEnum
    having?: MitraPackageScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: MitraPackageCountAggregateInputType | true
    _avg?: MitraPackageAvgAggregateInputType
    _sum?: MitraPackageSumAggregateInputType
    _min?: MitraPackageMinAggregateInputType
    _max?: MitraPackageMaxAggregateInputType
  }

  export type MitraPackageGroupByOutputType = {
    id: string
    period_id: string | null
    airline_id: string | null
    vendor_id: string | null
    hotel_mekkah_id: string | null
    hotel_madinah_id: string | null
    visa_id: string | null
    transportation_id: string | null
    muthawif_id: string | null
    handling_saudi_id: string | null
    handling_domestic_id: string | null
    siskopatuh_id: string | null
    equipment_id: string | null
    tour_plus_id: string | null
    manasik_id: string | null
    number_of_pax: number
    departure_date: Date
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal
    per_pax_price_double: Decimal
    per_pax_price_triple: Decimal
    per_pax_price_quad: Decimal
    created_at: Date
    updated_at: Date
    _count: MitraPackageCountAggregateOutputType | null
    _avg: MitraPackageAvgAggregateOutputType | null
    _sum: MitraPackageSumAggregateOutputType | null
    _min: MitraPackageMinAggregateOutputType | null
    _max: MitraPackageMaxAggregateOutputType | null
  }

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


  export type MitraPackageSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    period_id?: boolean
    airline_id?: boolean
    vendor_id?: boolean
    hotel_mekkah_id?: boolean
    hotel_madinah_id?: boolean
    visa_id?: boolean
    transportation_id?: boolean
    muthawif_id?: boolean
    handling_saudi_id?: boolean
    handling_domestic_id?: boolean
    siskopatuh_id?: boolean
    equipment_id?: boolean
    tour_plus_id?: boolean
    manasik_id?: boolean
    number_of_pax?: boolean
    departure_date?: boolean
    travel_duration?: boolean
    mekkah_duration?: boolean
    madinah_duration?: boolean
    tour_leader?: boolean
    margin?: boolean
    per_pax_price_double?: boolean
    per_pax_price_triple?: boolean
    per_pax_price_quad?: boolean
    created_at?: boolean
    updated_at?: boolean
    MitraPackageOrders?: boolean | MitraPackage$MitraPackageOrdersArgs<ExtArgs>
    period?: boolean | MitraPackage$periodArgs<ExtArgs>
    airline?: boolean | MitraPackage$airlineArgs<ExtArgs>
    vendor?: boolean | MitraPackage$vendorArgs<ExtArgs>
    hotelMekkah?: boolean | MitraPackage$hotelMekkahArgs<ExtArgs>
    hotelMadinah?: boolean | MitraPackage$hotelMadinahArgs<ExtArgs>
    visa?: boolean | MitraPackage$visaArgs<ExtArgs>
    transportation?: boolean | MitraPackage$transportationArgs<ExtArgs>
    muthawif?: boolean | MitraPackage$muthawifArgs<ExtArgs>
    handlingSaudi?: boolean | MitraPackage$handlingSaudiArgs<ExtArgs>
    handlingDomestic?: boolean | MitraPackage$handlingDomesticArgs<ExtArgs>
    siskopatuh?: boolean | MitraPackage$siskopatuhArgs<ExtArgs>
    equipment?: boolean | MitraPackage$equipmentArgs<ExtArgs>
    tourPlus?: boolean | MitraPackage$tourPlusArgs<ExtArgs>
    manasik?: boolean | MitraPackage$manasikArgs<ExtArgs>
    _count?: boolean | MitraPackageCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["mitraPackage"]>


  export type MitraPackageSelectScalar = {
    id?: boolean
    period_id?: boolean
    airline_id?: boolean
    vendor_id?: boolean
    hotel_mekkah_id?: boolean
    hotel_madinah_id?: boolean
    visa_id?: boolean
    transportation_id?: boolean
    muthawif_id?: boolean
    handling_saudi_id?: boolean
    handling_domestic_id?: boolean
    siskopatuh_id?: boolean
    equipment_id?: boolean
    tour_plus_id?: boolean
    manasik_id?: boolean
    number_of_pax?: boolean
    departure_date?: boolean
    travel_duration?: boolean
    mekkah_duration?: boolean
    madinah_duration?: boolean
    tour_leader?: boolean
    margin?: boolean
    per_pax_price_double?: boolean
    per_pax_price_triple?: boolean
    per_pax_price_quad?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type MitraPackageInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    MitraPackageOrders?: boolean | MitraPackage$MitraPackageOrdersArgs<ExtArgs>
    period?: boolean | MitraPackage$periodArgs<ExtArgs>
    airline?: boolean | MitraPackage$airlineArgs<ExtArgs>
    vendor?: boolean | MitraPackage$vendorArgs<ExtArgs>
    hotelMekkah?: boolean | MitraPackage$hotelMekkahArgs<ExtArgs>
    hotelMadinah?: boolean | MitraPackage$hotelMadinahArgs<ExtArgs>
    visa?: boolean | MitraPackage$visaArgs<ExtArgs>
    transportation?: boolean | MitraPackage$transportationArgs<ExtArgs>
    muthawif?: boolean | MitraPackage$muthawifArgs<ExtArgs>
    handlingSaudi?: boolean | MitraPackage$handlingSaudiArgs<ExtArgs>
    handlingDomestic?: boolean | MitraPackage$handlingDomesticArgs<ExtArgs>
    siskopatuh?: boolean | MitraPackage$siskopatuhArgs<ExtArgs>
    equipment?: boolean | MitraPackage$equipmentArgs<ExtArgs>
    tourPlus?: boolean | MitraPackage$tourPlusArgs<ExtArgs>
    manasik?: boolean | MitraPackage$manasikArgs<ExtArgs>
    _count?: boolean | MitraPackageCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $MitraPackagePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "MitraPackage"
    objects: {
      MitraPackageOrders: Prisma.$MitraPackageOrderPayload<ExtArgs>[]
      period: Prisma.$PeriodPayload<ExtArgs> | null
      airline: Prisma.$AirlinePayload<ExtArgs> | null
      vendor: Prisma.$VendorPayload<ExtArgs> | null
      hotelMekkah: Prisma.$HotelPayload<ExtArgs> | null
      hotelMadinah: Prisma.$HotelPayload<ExtArgs> | null
      visa: Prisma.$VisaPayload<ExtArgs> | null
      transportation: Prisma.$TransportationPayload<ExtArgs> | null
      muthawif: Prisma.$MuthawifPayload<ExtArgs> | null
      handlingSaudi: Prisma.$HandlingSaudiPayload<ExtArgs> | null
      handlingDomestic: Prisma.$HandlingDomesticPayload<ExtArgs> | null
      siskopatuh: Prisma.$SiskopatuhPayload<ExtArgs> | null
      equipment: Prisma.$EquipmentPayload<ExtArgs> | null
      tourPlus: Prisma.$TourPlusPayload<ExtArgs> | null
      manasik: Prisma.$ManasikPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      period_id: string | null
      airline_id: string | null
      vendor_id: string | null
      hotel_mekkah_id: string | null
      hotel_madinah_id: string | null
      visa_id: string | null
      transportation_id: string | null
      muthawif_id: string | null
      handling_saudi_id: string | null
      handling_domestic_id: string | null
      siskopatuh_id: string | null
      equipment_id: string | null
      tour_plus_id: string | null
      manasik_id: string | null
      number_of_pax: number
      departure_date: Date
      travel_duration: number
      mekkah_duration: number
      madinah_duration: number
      tour_leader: number
      margin: Prisma.Decimal
      per_pax_price_double: Prisma.Decimal
      per_pax_price_triple: Prisma.Decimal
      per_pax_price_quad: Prisma.Decimal
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["mitraPackage"]>
    composites: {}
  }

  type MitraPackageGetPayload<S extends boolean | null | undefined | MitraPackageDefaultArgs> = $Result.GetResult<Prisma.$MitraPackagePayload, S>

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

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

    /**
     * Find one MitraPackage that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {MitraPackageFindUniqueOrThrowArgs} args - Arguments to find a MitraPackage
     * @example
     * // Get one MitraPackage
     * const mitraPackage = await prisma.mitraPackage.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends MitraPackageFindUniqueOrThrowArgs>(args: SelectSubset<T, MitraPackageFindUniqueOrThrowArgs<ExtArgs>>): Prisma__MitraPackageClient<$Result.GetResult<Prisma.$MitraPackagePayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first MitraPackage that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MitraPackageFindFirstArgs} args - Arguments to find a MitraPackage
     * @example
     * // Get one MitraPackage
     * const mitraPackage = await prisma.mitraPackage.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends MitraPackageFindFirstArgs>(args?: SelectSubset<T, MitraPackageFindFirstArgs<ExtArgs>>): Prisma__MitraPackageClient<$Result.GetResult<Prisma.$MitraPackagePayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first MitraPackage 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 {MitraPackageFindFirstOrThrowArgs} args - Arguments to find a MitraPackage
     * @example
     * // Get one MitraPackage
     * const mitraPackage = await prisma.mitraPackage.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends MitraPackageFindFirstOrThrowArgs>(args?: SelectSubset<T, MitraPackageFindFirstOrThrowArgs<ExtArgs>>): Prisma__MitraPackageClient<$Result.GetResult<Prisma.$MitraPackagePayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more MitraPackages that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MitraPackageFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all MitraPackages
     * const mitraPackages = await prisma.mitraPackage.findMany()
     * 
     * // Get first 10 MitraPackages
     * const mitraPackages = await prisma.mitraPackage.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const mitraPackageWithIdOnly = await prisma.mitraPackage.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends MitraPackageFindManyArgs>(args?: SelectSubset<T, MitraPackageFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MitraPackagePayload<ExtArgs>, T, "findMany">>

    /**
     * Create a MitraPackage.
     * @param {MitraPackageCreateArgs} args - Arguments to create a MitraPackage.
     * @example
     * // Create one MitraPackage
     * const MitraPackage = await prisma.mitraPackage.create({
     *   data: {
     *     // ... data to create a MitraPackage
     *   }
     * })
     * 
     */
    create<T extends MitraPackageCreateArgs>(args: SelectSubset<T, MitraPackageCreateArgs<ExtArgs>>): Prisma__MitraPackageClient<$Result.GetResult<Prisma.$MitraPackagePayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many MitraPackages.
     * @param {MitraPackageCreateManyArgs} args - Arguments to create many MitraPackages.
     * @example
     * // Create many MitraPackages
     * const mitraPackage = await prisma.mitraPackage.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends MitraPackageCreateManyArgs>(args?: SelectSubset<T, MitraPackageCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a MitraPackage.
     * @param {MitraPackageDeleteArgs} args - Arguments to delete one MitraPackage.
     * @example
     * // Delete one MitraPackage
     * const MitraPackage = await prisma.mitraPackage.delete({
     *   where: {
     *     // ... filter to delete one MitraPackage
     *   }
     * })
     * 
     */
    delete<T extends MitraPackageDeleteArgs>(args: SelectSubset<T, MitraPackageDeleteArgs<ExtArgs>>): Prisma__MitraPackageClient<$Result.GetResult<Prisma.$MitraPackagePayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one MitraPackage.
     * @param {MitraPackageUpdateArgs} args - Arguments to update one MitraPackage.
     * @example
     * // Update one MitraPackage
     * const mitraPackage = await prisma.mitraPackage.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends MitraPackageUpdateArgs>(args: SelectSubset<T, MitraPackageUpdateArgs<ExtArgs>>): Prisma__MitraPackageClient<$Result.GetResult<Prisma.$MitraPackagePayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more MitraPackages.
     * @param {MitraPackageDeleteManyArgs} args - Arguments to filter MitraPackages to delete.
     * @example
     * // Delete a few MitraPackages
     * const { count } = await prisma.mitraPackage.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends MitraPackageDeleteManyArgs>(args?: SelectSubset<T, MitraPackageDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more MitraPackages.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MitraPackageUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many MitraPackages
     * const mitraPackage = await prisma.mitraPackage.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends MitraPackageUpdateManyArgs>(args: SelectSubset<T, MitraPackageUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one MitraPackage.
     * @param {MitraPackageUpsertArgs} args - Arguments to update or create a MitraPackage.
     * @example
     * // Update or create a MitraPackage
     * const mitraPackage = await prisma.mitraPackage.upsert({
     *   create: {
     *     // ... data to create a MitraPackage
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the MitraPackage we want to update
     *   }
     * })
     */
    upsert<T extends MitraPackageUpsertArgs>(args: SelectSubset<T, MitraPackageUpsertArgs<ExtArgs>>): Prisma__MitraPackageClient<$Result.GetResult<Prisma.$MitraPackagePayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of MitraPackages.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MitraPackageCountArgs} args - Arguments to filter MitraPackages to count.
     * @example
     * // Count the number of MitraPackages
     * const count = await prisma.mitraPackage.count({
     *   where: {
     *     // ... the filter for the MitraPackages we want to count
     *   }
     * })
    **/
    count<T extends MitraPackageCountArgs>(
      args?: Subset<T, MitraPackageCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], MitraPackageCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a MitraPackage.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MitraPackageAggregateArgs} 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 MitraPackageAggregateArgs>(args: Subset<T, MitraPackageAggregateArgs>): Prisma.PrismaPromise<GetMitraPackageAggregateType<T>>

    /**
     * Group by MitraPackage.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MitraPackageGroupByArgs} 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 MitraPackageGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: MitraPackageGroupByArgs['orderBy'] }
        : { orderBy?: MitraPackageGroupByArgs['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, MitraPackageGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetMitraPackageGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the MitraPackage model
   */
  readonly fields: MitraPackageFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for MitraPackage.
   * 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__MitraPackageClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    MitraPackageOrders<T extends MitraPackage$MitraPackageOrdersArgs<ExtArgs> = {}>(args?: Subset<T, MitraPackage$MitraPackageOrdersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MitraPackageOrderPayload<ExtArgs>, T, "findMany"> | Null>
    period<T extends MitraPackage$periodArgs<ExtArgs> = {}>(args?: Subset<T, MitraPackage$periodArgs<ExtArgs>>): Prisma__PeriodClient<$Result.GetResult<Prisma.$PeriodPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    airline<T extends MitraPackage$airlineArgs<ExtArgs> = {}>(args?: Subset<T, MitraPackage$airlineArgs<ExtArgs>>): Prisma__AirlineClient<$Result.GetResult<Prisma.$AirlinePayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    vendor<T extends MitraPackage$vendorArgs<ExtArgs> = {}>(args?: Subset<T, MitraPackage$vendorArgs<ExtArgs>>): Prisma__VendorClient<$Result.GetResult<Prisma.$VendorPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    hotelMekkah<T extends MitraPackage$hotelMekkahArgs<ExtArgs> = {}>(args?: Subset<T, MitraPackage$hotelMekkahArgs<ExtArgs>>): Prisma__HotelClient<$Result.GetResult<Prisma.$HotelPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    hotelMadinah<T extends MitraPackage$hotelMadinahArgs<ExtArgs> = {}>(args?: Subset<T, MitraPackage$hotelMadinahArgs<ExtArgs>>): Prisma__HotelClient<$Result.GetResult<Prisma.$HotelPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    visa<T extends MitraPackage$visaArgs<ExtArgs> = {}>(args?: Subset<T, MitraPackage$visaArgs<ExtArgs>>): Prisma__VisaClient<$Result.GetResult<Prisma.$VisaPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    transportation<T extends MitraPackage$transportationArgs<ExtArgs> = {}>(args?: Subset<T, MitraPackage$transportationArgs<ExtArgs>>): Prisma__TransportationClient<$Result.GetResult<Prisma.$TransportationPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    muthawif<T extends MitraPackage$muthawifArgs<ExtArgs> = {}>(args?: Subset<T, MitraPackage$muthawifArgs<ExtArgs>>): Prisma__MuthawifClient<$Result.GetResult<Prisma.$MuthawifPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    handlingSaudi<T extends MitraPackage$handlingSaudiArgs<ExtArgs> = {}>(args?: Subset<T, MitraPackage$handlingSaudiArgs<ExtArgs>>): Prisma__HandlingSaudiClient<$Result.GetResult<Prisma.$HandlingSaudiPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    handlingDomestic<T extends MitraPackage$handlingDomesticArgs<ExtArgs> = {}>(args?: Subset<T, MitraPackage$handlingDomesticArgs<ExtArgs>>): Prisma__HandlingDomesticClient<$Result.GetResult<Prisma.$HandlingDomesticPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    siskopatuh<T extends MitraPackage$siskopatuhArgs<ExtArgs> = {}>(args?: Subset<T, MitraPackage$siskopatuhArgs<ExtArgs>>): Prisma__SiskopatuhClient<$Result.GetResult<Prisma.$SiskopatuhPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    equipment<T extends MitraPackage$equipmentArgs<ExtArgs> = {}>(args?: Subset<T, MitraPackage$equipmentArgs<ExtArgs>>): Prisma__EquipmentClient<$Result.GetResult<Prisma.$EquipmentPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    tourPlus<T extends MitraPackage$tourPlusArgs<ExtArgs> = {}>(args?: Subset<T, MitraPackage$tourPlusArgs<ExtArgs>>): Prisma__TourPlusClient<$Result.GetResult<Prisma.$TourPlusPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    manasik<T extends MitraPackage$manasikArgs<ExtArgs> = {}>(args?: Subset<T, MitraPackage$manasikArgs<ExtArgs>>): Prisma__ManasikClient<$Result.GetResult<Prisma.$ManasikPayload<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 MitraPackage model
   */ 
  interface MitraPackageFieldRefs {
    readonly id: FieldRef<"MitraPackage", 'String'>
    readonly period_id: FieldRef<"MitraPackage", 'String'>
    readonly airline_id: FieldRef<"MitraPackage", 'String'>
    readonly vendor_id: FieldRef<"MitraPackage", 'String'>
    readonly hotel_mekkah_id: FieldRef<"MitraPackage", 'String'>
    readonly hotel_madinah_id: FieldRef<"MitraPackage", 'String'>
    readonly visa_id: FieldRef<"MitraPackage", 'String'>
    readonly transportation_id: FieldRef<"MitraPackage", 'String'>
    readonly muthawif_id: FieldRef<"MitraPackage", 'String'>
    readonly handling_saudi_id: FieldRef<"MitraPackage", 'String'>
    readonly handling_domestic_id: FieldRef<"MitraPackage", 'String'>
    readonly siskopatuh_id: FieldRef<"MitraPackage", 'String'>
    readonly equipment_id: FieldRef<"MitraPackage", 'String'>
    readonly tour_plus_id: FieldRef<"MitraPackage", 'String'>
    readonly manasik_id: FieldRef<"MitraPackage", 'String'>
    readonly number_of_pax: FieldRef<"MitraPackage", 'Int'>
    readonly departure_date: FieldRef<"MitraPackage", 'DateTime'>
    readonly travel_duration: FieldRef<"MitraPackage", 'Int'>
    readonly mekkah_duration: FieldRef<"MitraPackage", 'Int'>
    readonly madinah_duration: FieldRef<"MitraPackage", 'Int'>
    readonly tour_leader: FieldRef<"MitraPackage", 'Int'>
    readonly margin: FieldRef<"MitraPackage", 'Decimal'>
    readonly per_pax_price_double: FieldRef<"MitraPackage", 'Decimal'>
    readonly per_pax_price_triple: FieldRef<"MitraPackage", 'Decimal'>
    readonly per_pax_price_quad: FieldRef<"MitraPackage", 'Decimal'>
    readonly created_at: FieldRef<"MitraPackage", 'DateTime'>
    readonly updated_at: FieldRef<"MitraPackage", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * MitraPackage findUnique
   */
  export type MitraPackageFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackage
     */
    select?: MitraPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageInclude<ExtArgs> | null
    /**
     * Filter, which MitraPackage to fetch.
     */
    where: MitraPackageWhereUniqueInput
  }

  /**
   * MitraPackage findUniqueOrThrow
   */
  export type MitraPackageFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackage
     */
    select?: MitraPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageInclude<ExtArgs> | null
    /**
     * Filter, which MitraPackage to fetch.
     */
    where: MitraPackageWhereUniqueInput
  }

  /**
   * MitraPackage findFirst
   */
  export type MitraPackageFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackage
     */
    select?: MitraPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageInclude<ExtArgs> | null
    /**
     * Filter, which MitraPackage to fetch.
     */
    where?: MitraPackageWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MitraPackages to fetch.
     */
    orderBy?: MitraPackageOrderByWithRelationInput | MitraPackageOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for MitraPackages.
     */
    cursor?: MitraPackageWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MitraPackages from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` MitraPackages.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of MitraPackages.
     */
    distinct?: MitraPackageScalarFieldEnum | MitraPackageScalarFieldEnum[]
  }

  /**
   * MitraPackage findFirstOrThrow
   */
  export type MitraPackageFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackage
     */
    select?: MitraPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageInclude<ExtArgs> | null
    /**
     * Filter, which MitraPackage to fetch.
     */
    where?: MitraPackageWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MitraPackages to fetch.
     */
    orderBy?: MitraPackageOrderByWithRelationInput | MitraPackageOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for MitraPackages.
     */
    cursor?: MitraPackageWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MitraPackages from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` MitraPackages.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of MitraPackages.
     */
    distinct?: MitraPackageScalarFieldEnum | MitraPackageScalarFieldEnum[]
  }

  /**
   * MitraPackage findMany
   */
  export type MitraPackageFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackage
     */
    select?: MitraPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageInclude<ExtArgs> | null
    /**
     * Filter, which MitraPackages to fetch.
     */
    where?: MitraPackageWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MitraPackages to fetch.
     */
    orderBy?: MitraPackageOrderByWithRelationInput | MitraPackageOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing MitraPackages.
     */
    cursor?: MitraPackageWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MitraPackages from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` MitraPackages.
     */
    skip?: number
    distinct?: MitraPackageScalarFieldEnum | MitraPackageScalarFieldEnum[]
  }

  /**
   * MitraPackage create
   */
  export type MitraPackageCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackage
     */
    select?: MitraPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageInclude<ExtArgs> | null
    /**
     * The data needed to create a MitraPackage.
     */
    data: XOR<MitraPackageCreateInput, MitraPackageUncheckedCreateInput>
  }

  /**
   * MitraPackage createMany
   */
  export type MitraPackageCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many MitraPackages.
     */
    data: MitraPackageCreateManyInput | MitraPackageCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * MitraPackage update
   */
  export type MitraPackageUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackage
     */
    select?: MitraPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageInclude<ExtArgs> | null
    /**
     * The data needed to update a MitraPackage.
     */
    data: XOR<MitraPackageUpdateInput, MitraPackageUncheckedUpdateInput>
    /**
     * Choose, which MitraPackage to update.
     */
    where: MitraPackageWhereUniqueInput
  }

  /**
   * MitraPackage updateMany
   */
  export type MitraPackageUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update MitraPackages.
     */
    data: XOR<MitraPackageUpdateManyMutationInput, MitraPackageUncheckedUpdateManyInput>
    /**
     * Filter which MitraPackages to update
     */
    where?: MitraPackageWhereInput
  }

  /**
   * MitraPackage upsert
   */
  export type MitraPackageUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackage
     */
    select?: MitraPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageInclude<ExtArgs> | null
    /**
     * The filter to search for the MitraPackage to update in case it exists.
     */
    where: MitraPackageWhereUniqueInput
    /**
     * In case the MitraPackage found by the `where` argument doesn't exist, create a new MitraPackage with this data.
     */
    create: XOR<MitraPackageCreateInput, MitraPackageUncheckedCreateInput>
    /**
     * In case the MitraPackage was found with the provided `where` argument, update it with this data.
     */
    update: XOR<MitraPackageUpdateInput, MitraPackageUncheckedUpdateInput>
  }

  /**
   * MitraPackage delete
   */
  export type MitraPackageDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackage
     */
    select?: MitraPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageInclude<ExtArgs> | null
    /**
     * Filter which MitraPackage to delete.
     */
    where: MitraPackageWhereUniqueInput
  }

  /**
   * MitraPackage deleteMany
   */
  export type MitraPackageDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which MitraPackages to delete
     */
    where?: MitraPackageWhereInput
  }

  /**
   * MitraPackage.MitraPackageOrders
   */
  export type MitraPackage$MitraPackageOrdersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackageOrder
     */
    select?: MitraPackageOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageOrderInclude<ExtArgs> | null
    where?: MitraPackageOrderWhereInput
    orderBy?: MitraPackageOrderOrderByWithRelationInput | MitraPackageOrderOrderByWithRelationInput[]
    cursor?: MitraPackageOrderWhereUniqueInput
    take?: number
    skip?: number
    distinct?: MitraPackageOrderScalarFieldEnum | MitraPackageOrderScalarFieldEnum[]
  }

  /**
   * MitraPackage.period
   */
  export type MitraPackage$periodArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Period
     */
    select?: PeriodSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PeriodInclude<ExtArgs> | null
    where?: PeriodWhereInput
  }

  /**
   * MitraPackage.airline
   */
  export type MitraPackage$airlineArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Airline
     */
    select?: AirlineSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AirlineInclude<ExtArgs> | null
    where?: AirlineWhereInput
  }

  /**
   * MitraPackage.vendor
   */
  export type MitraPackage$vendorArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Vendor
     */
    select?: VendorSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VendorInclude<ExtArgs> | null
    where?: VendorWhereInput
  }

  /**
   * MitraPackage.hotelMekkah
   */
  export type MitraPackage$hotelMekkahArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Hotel
     */
    select?: HotelSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: HotelInclude<ExtArgs> | null
    where?: HotelWhereInput
  }

  /**
   * MitraPackage.hotelMadinah
   */
  export type MitraPackage$hotelMadinahArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Hotel
     */
    select?: HotelSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: HotelInclude<ExtArgs> | null
    where?: HotelWhereInput
  }

  /**
   * MitraPackage.visa
   */
  export type MitraPackage$visaArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Visa
     */
    select?: VisaSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: VisaInclude<ExtArgs> | null
    where?: VisaWhereInput
  }

  /**
   * MitraPackage.transportation
   */
  export type MitraPackage$transportationArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Transportation
     */
    select?: TransportationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TransportationInclude<ExtArgs> | null
    where?: TransportationWhereInput
  }

  /**
   * MitraPackage.muthawif
   */
  export type MitraPackage$muthawifArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Muthawif
     */
    select?: MuthawifSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MuthawifInclude<ExtArgs> | null
    where?: MuthawifWhereInput
  }

  /**
   * MitraPackage.handlingSaudi
   */
  export type MitraPackage$handlingSaudiArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HandlingSaudi
     */
    select?: HandlingSaudiSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: HandlingSaudiInclude<ExtArgs> | null
    where?: HandlingSaudiWhereInput
  }

  /**
   * MitraPackage.handlingDomestic
   */
  export type MitraPackage$handlingDomesticArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the HandlingDomestic
     */
    select?: HandlingDomesticSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: HandlingDomesticInclude<ExtArgs> | null
    where?: HandlingDomesticWhereInput
  }

  /**
   * MitraPackage.siskopatuh
   */
  export type MitraPackage$siskopatuhArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Siskopatuh
     */
    select?: SiskopatuhSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SiskopatuhInclude<ExtArgs> | null
    where?: SiskopatuhWhereInput
  }

  /**
   * MitraPackage.equipment
   */
  export type MitraPackage$equipmentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Equipment
     */
    select?: EquipmentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: EquipmentInclude<ExtArgs> | null
    where?: EquipmentWhereInput
  }

  /**
   * MitraPackage.tourPlus
   */
  export type MitraPackage$tourPlusArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the TourPlus
     */
    select?: TourPlusSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: TourPlusInclude<ExtArgs> | null
    where?: TourPlusWhereInput
  }

  /**
   * MitraPackage.manasik
   */
  export type MitraPackage$manasikArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Manasik
     */
    select?: ManasikSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ManasikInclude<ExtArgs> | null
    where?: ManasikWhereInput
  }

  /**
   * MitraPackage without action
   */
  export type MitraPackageDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackage
     */
    select?: MitraPackageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageInclude<ExtArgs> | null
  }


  /**
   * Model MitraPackageOrder
   */

  export type AggregateMitraPackageOrder = {
    _count: MitraPackageOrderCountAggregateOutputType | null
    _min: MitraPackageOrderMinAggregateOutputType | null
    _max: MitraPackageOrderMaxAggregateOutputType | null
  }

  export type MitraPackageOrderMinAggregateOutputType = {
    id: string | null
    user_id: string | null
    mitra_package_id: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type MitraPackageOrderMaxAggregateOutputType = {
    id: string | null
    user_id: string | null
    mitra_package_id: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type MitraPackageOrderCountAggregateOutputType = {
    id: number
    user_id: number
    mitra_package_id: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type MitraPackageOrderMinAggregateInputType = {
    id?: true
    user_id?: true
    mitra_package_id?: true
    created_at?: true
    updated_at?: true
  }

  export type MitraPackageOrderMaxAggregateInputType = {
    id?: true
    user_id?: true
    mitra_package_id?: true
    created_at?: true
    updated_at?: true
  }

  export type MitraPackageOrderCountAggregateInputType = {
    id?: true
    user_id?: true
    mitra_package_id?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type MitraPackageOrderAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which MitraPackageOrder to aggregate.
     */
    where?: MitraPackageOrderWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MitraPackageOrders to fetch.
     */
    orderBy?: MitraPackageOrderOrderByWithRelationInput | MitraPackageOrderOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: MitraPackageOrderWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MitraPackageOrders from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` MitraPackageOrders.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned MitraPackageOrders
    **/
    _count?: true | MitraPackageOrderCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: MitraPackageOrderMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: MitraPackageOrderMaxAggregateInputType
  }

  export type GetMitraPackageOrderAggregateType<T extends MitraPackageOrderAggregateArgs> = {
        [P in keyof T & keyof AggregateMitraPackageOrder]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateMitraPackageOrder[P]>
      : GetScalarType<T[P], AggregateMitraPackageOrder[P]>
  }




  export type MitraPackageOrderGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MitraPackageOrderWhereInput
    orderBy?: MitraPackageOrderOrderByWithAggregationInput | MitraPackageOrderOrderByWithAggregationInput[]
    by: MitraPackageOrderScalarFieldEnum[] | MitraPackageOrderScalarFieldEnum
    having?: MitraPackageOrderScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: MitraPackageOrderCountAggregateInputType | true
    _min?: MitraPackageOrderMinAggregateInputType
    _max?: MitraPackageOrderMaxAggregateInputType
  }

  export type MitraPackageOrderGroupByOutputType = {
    id: string
    user_id: string
    mitra_package_id: string
    created_at: Date
    updated_at: Date
    _count: MitraPackageOrderCountAggregateOutputType | null
    _min: MitraPackageOrderMinAggregateOutputType | null
    _max: MitraPackageOrderMaxAggregateOutputType | null
  }

  type GetMitraPackageOrderGroupByPayload<T extends MitraPackageOrderGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<MitraPackageOrderGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof MitraPackageOrderGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], MitraPackageOrderGroupByOutputType[P]>
            : GetScalarType<T[P], MitraPackageOrderGroupByOutputType[P]>
        }
      >
    >


  export type MitraPackageOrderSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    user_id?: boolean
    mitra_package_id?: boolean
    created_at?: boolean
    updated_at?: boolean
    MitraPackage?: boolean | MitraPackageDefaultArgs<ExtArgs>
    User?: boolean | UserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["mitraPackageOrder"]>


  export type MitraPackageOrderSelectScalar = {
    id?: boolean
    user_id?: boolean
    mitra_package_id?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type MitraPackageOrderInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    MitraPackage?: boolean | MitraPackageDefaultArgs<ExtArgs>
    User?: boolean | UserDefaultArgs<ExtArgs>
  }

  export type $MitraPackageOrderPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "MitraPackageOrder"
    objects: {
      MitraPackage: Prisma.$MitraPackagePayload<ExtArgs>
      User: Prisma.$UserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      user_id: string
      mitra_package_id: string
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["mitraPackageOrder"]>
    composites: {}
  }

  type MitraPackageOrderGetPayload<S extends boolean | null | undefined | MitraPackageOrderDefaultArgs> = $Result.GetResult<Prisma.$MitraPackageOrderPayload, S>

  type MitraPackageOrderCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<MitraPackageOrderFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: MitraPackageOrderCountAggregateInputType | true
    }

  export interface MitraPackageOrderDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['MitraPackageOrder'], meta: { name: 'MitraPackageOrder' } }
    /**
     * Find zero or one MitraPackageOrder that matches the filter.
     * @param {MitraPackageOrderFindUniqueArgs} args - Arguments to find a MitraPackageOrder
     * @example
     * // Get one MitraPackageOrder
     * const mitraPackageOrder = await prisma.mitraPackageOrder.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends MitraPackageOrderFindUniqueArgs>(args: SelectSubset<T, MitraPackageOrderFindUniqueArgs<ExtArgs>>): Prisma__MitraPackageOrderClient<$Result.GetResult<Prisma.$MitraPackageOrderPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one MitraPackageOrder that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {MitraPackageOrderFindUniqueOrThrowArgs} args - Arguments to find a MitraPackageOrder
     * @example
     * // Get one MitraPackageOrder
     * const mitraPackageOrder = await prisma.mitraPackageOrder.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends MitraPackageOrderFindUniqueOrThrowArgs>(args: SelectSubset<T, MitraPackageOrderFindUniqueOrThrowArgs<ExtArgs>>): Prisma__MitraPackageOrderClient<$Result.GetResult<Prisma.$MitraPackageOrderPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first MitraPackageOrder that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MitraPackageOrderFindFirstArgs} args - Arguments to find a MitraPackageOrder
     * @example
     * // Get one MitraPackageOrder
     * const mitraPackageOrder = await prisma.mitraPackageOrder.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends MitraPackageOrderFindFirstArgs>(args?: SelectSubset<T, MitraPackageOrderFindFirstArgs<ExtArgs>>): Prisma__MitraPackageOrderClient<$Result.GetResult<Prisma.$MitraPackageOrderPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first MitraPackageOrder 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 {MitraPackageOrderFindFirstOrThrowArgs} args - Arguments to find a MitraPackageOrder
     * @example
     * // Get one MitraPackageOrder
     * const mitraPackageOrder = await prisma.mitraPackageOrder.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends MitraPackageOrderFindFirstOrThrowArgs>(args?: SelectSubset<T, MitraPackageOrderFindFirstOrThrowArgs<ExtArgs>>): Prisma__MitraPackageOrderClient<$Result.GetResult<Prisma.$MitraPackageOrderPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more MitraPackageOrders that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MitraPackageOrderFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all MitraPackageOrders
     * const mitraPackageOrders = await prisma.mitraPackageOrder.findMany()
     * 
     * // Get first 10 MitraPackageOrders
     * const mitraPackageOrders = await prisma.mitraPackageOrder.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const mitraPackageOrderWithIdOnly = await prisma.mitraPackageOrder.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends MitraPackageOrderFindManyArgs>(args?: SelectSubset<T, MitraPackageOrderFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MitraPackageOrderPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a MitraPackageOrder.
     * @param {MitraPackageOrderCreateArgs} args - Arguments to create a MitraPackageOrder.
     * @example
     * // Create one MitraPackageOrder
     * const MitraPackageOrder = await prisma.mitraPackageOrder.create({
     *   data: {
     *     // ... data to create a MitraPackageOrder
     *   }
     * })
     * 
     */
    create<T extends MitraPackageOrderCreateArgs>(args: SelectSubset<T, MitraPackageOrderCreateArgs<ExtArgs>>): Prisma__MitraPackageOrderClient<$Result.GetResult<Prisma.$MitraPackageOrderPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many MitraPackageOrders.
     * @param {MitraPackageOrderCreateManyArgs} args - Arguments to create many MitraPackageOrders.
     * @example
     * // Create many MitraPackageOrders
     * const mitraPackageOrder = await prisma.mitraPackageOrder.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends MitraPackageOrderCreateManyArgs>(args?: SelectSubset<T, MitraPackageOrderCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a MitraPackageOrder.
     * @param {MitraPackageOrderDeleteArgs} args - Arguments to delete one MitraPackageOrder.
     * @example
     * // Delete one MitraPackageOrder
     * const MitraPackageOrder = await prisma.mitraPackageOrder.delete({
     *   where: {
     *     // ... filter to delete one MitraPackageOrder
     *   }
     * })
     * 
     */
    delete<T extends MitraPackageOrderDeleteArgs>(args: SelectSubset<T, MitraPackageOrderDeleteArgs<ExtArgs>>): Prisma__MitraPackageOrderClient<$Result.GetResult<Prisma.$MitraPackageOrderPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one MitraPackageOrder.
     * @param {MitraPackageOrderUpdateArgs} args - Arguments to update one MitraPackageOrder.
     * @example
     * // Update one MitraPackageOrder
     * const mitraPackageOrder = await prisma.mitraPackageOrder.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends MitraPackageOrderUpdateArgs>(args: SelectSubset<T, MitraPackageOrderUpdateArgs<ExtArgs>>): Prisma__MitraPackageOrderClient<$Result.GetResult<Prisma.$MitraPackageOrderPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more MitraPackageOrders.
     * @param {MitraPackageOrderDeleteManyArgs} args - Arguments to filter MitraPackageOrders to delete.
     * @example
     * // Delete a few MitraPackageOrders
     * const { count } = await prisma.mitraPackageOrder.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends MitraPackageOrderDeleteManyArgs>(args?: SelectSubset<T, MitraPackageOrderDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more MitraPackageOrders.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MitraPackageOrderUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many MitraPackageOrders
     * const mitraPackageOrder = await prisma.mitraPackageOrder.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends MitraPackageOrderUpdateManyArgs>(args: SelectSubset<T, MitraPackageOrderUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one MitraPackageOrder.
     * @param {MitraPackageOrderUpsertArgs} args - Arguments to update or create a MitraPackageOrder.
     * @example
     * // Update or create a MitraPackageOrder
     * const mitraPackageOrder = await prisma.mitraPackageOrder.upsert({
     *   create: {
     *     // ... data to create a MitraPackageOrder
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the MitraPackageOrder we want to update
     *   }
     * })
     */
    upsert<T extends MitraPackageOrderUpsertArgs>(args: SelectSubset<T, MitraPackageOrderUpsertArgs<ExtArgs>>): Prisma__MitraPackageOrderClient<$Result.GetResult<Prisma.$MitraPackageOrderPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of MitraPackageOrders.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MitraPackageOrderCountArgs} args - Arguments to filter MitraPackageOrders to count.
     * @example
     * // Count the number of MitraPackageOrders
     * const count = await prisma.mitraPackageOrder.count({
     *   where: {
     *     // ... the filter for the MitraPackageOrders we want to count
     *   }
     * })
    **/
    count<T extends MitraPackageOrderCountArgs>(
      args?: Subset<T, MitraPackageOrderCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], MitraPackageOrderCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a MitraPackageOrder.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MitraPackageOrderAggregateArgs} 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 MitraPackageOrderAggregateArgs>(args: Subset<T, MitraPackageOrderAggregateArgs>): Prisma.PrismaPromise<GetMitraPackageOrderAggregateType<T>>

    /**
     * Group by MitraPackageOrder.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MitraPackageOrderGroupByArgs} 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 MitraPackageOrderGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: MitraPackageOrderGroupByArgs['orderBy'] }
        : { orderBy?: MitraPackageOrderGroupByArgs['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, MitraPackageOrderGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetMitraPackageOrderGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the MitraPackageOrder model
   */
  readonly fields: MitraPackageOrderFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for MitraPackageOrder.
   * 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__MitraPackageOrderClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    MitraPackage<T extends MitraPackageDefaultArgs<ExtArgs> = {}>(args?: Subset<T, MitraPackageDefaultArgs<ExtArgs>>): Prisma__MitraPackageClient<$Result.GetResult<Prisma.$MitraPackagePayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    User<T extends UserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserDefaultArgs<ExtArgs>>): Prisma__UserClient<$Result.GetResult<Prisma.$UserPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
  }




  /**
   * Fields of the MitraPackageOrder model
   */ 
  interface MitraPackageOrderFieldRefs {
    readonly id: FieldRef<"MitraPackageOrder", 'String'>
    readonly user_id: FieldRef<"MitraPackageOrder", 'String'>
    readonly mitra_package_id: FieldRef<"MitraPackageOrder", 'String'>
    readonly created_at: FieldRef<"MitraPackageOrder", 'DateTime'>
    readonly updated_at: FieldRef<"MitraPackageOrder", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * MitraPackageOrder findUnique
   */
  export type MitraPackageOrderFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackageOrder
     */
    select?: MitraPackageOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageOrderInclude<ExtArgs> | null
    /**
     * Filter, which MitraPackageOrder to fetch.
     */
    where: MitraPackageOrderWhereUniqueInput
  }

  /**
   * MitraPackageOrder findUniqueOrThrow
   */
  export type MitraPackageOrderFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackageOrder
     */
    select?: MitraPackageOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageOrderInclude<ExtArgs> | null
    /**
     * Filter, which MitraPackageOrder to fetch.
     */
    where: MitraPackageOrderWhereUniqueInput
  }

  /**
   * MitraPackageOrder findFirst
   */
  export type MitraPackageOrderFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackageOrder
     */
    select?: MitraPackageOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageOrderInclude<ExtArgs> | null
    /**
     * Filter, which MitraPackageOrder to fetch.
     */
    where?: MitraPackageOrderWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MitraPackageOrders to fetch.
     */
    orderBy?: MitraPackageOrderOrderByWithRelationInput | MitraPackageOrderOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for MitraPackageOrders.
     */
    cursor?: MitraPackageOrderWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MitraPackageOrders from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` MitraPackageOrders.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of MitraPackageOrders.
     */
    distinct?: MitraPackageOrderScalarFieldEnum | MitraPackageOrderScalarFieldEnum[]
  }

  /**
   * MitraPackageOrder findFirstOrThrow
   */
  export type MitraPackageOrderFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackageOrder
     */
    select?: MitraPackageOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageOrderInclude<ExtArgs> | null
    /**
     * Filter, which MitraPackageOrder to fetch.
     */
    where?: MitraPackageOrderWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MitraPackageOrders to fetch.
     */
    orderBy?: MitraPackageOrderOrderByWithRelationInput | MitraPackageOrderOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for MitraPackageOrders.
     */
    cursor?: MitraPackageOrderWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MitraPackageOrders from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` MitraPackageOrders.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of MitraPackageOrders.
     */
    distinct?: MitraPackageOrderScalarFieldEnum | MitraPackageOrderScalarFieldEnum[]
  }

  /**
   * MitraPackageOrder findMany
   */
  export type MitraPackageOrderFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackageOrder
     */
    select?: MitraPackageOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageOrderInclude<ExtArgs> | null
    /**
     * Filter, which MitraPackageOrders to fetch.
     */
    where?: MitraPackageOrderWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MitraPackageOrders to fetch.
     */
    orderBy?: MitraPackageOrderOrderByWithRelationInput | MitraPackageOrderOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing MitraPackageOrders.
     */
    cursor?: MitraPackageOrderWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MitraPackageOrders from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` MitraPackageOrders.
     */
    skip?: number
    distinct?: MitraPackageOrderScalarFieldEnum | MitraPackageOrderScalarFieldEnum[]
  }

  /**
   * MitraPackageOrder create
   */
  export type MitraPackageOrderCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackageOrder
     */
    select?: MitraPackageOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageOrderInclude<ExtArgs> | null
    /**
     * The data needed to create a MitraPackageOrder.
     */
    data: XOR<MitraPackageOrderCreateInput, MitraPackageOrderUncheckedCreateInput>
  }

  /**
   * MitraPackageOrder createMany
   */
  export type MitraPackageOrderCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many MitraPackageOrders.
     */
    data: MitraPackageOrderCreateManyInput | MitraPackageOrderCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * MitraPackageOrder update
   */
  export type MitraPackageOrderUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackageOrder
     */
    select?: MitraPackageOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageOrderInclude<ExtArgs> | null
    /**
     * The data needed to update a MitraPackageOrder.
     */
    data: XOR<MitraPackageOrderUpdateInput, MitraPackageOrderUncheckedUpdateInput>
    /**
     * Choose, which MitraPackageOrder to update.
     */
    where: MitraPackageOrderWhereUniqueInput
  }

  /**
   * MitraPackageOrder updateMany
   */
  export type MitraPackageOrderUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update MitraPackageOrders.
     */
    data: XOR<MitraPackageOrderUpdateManyMutationInput, MitraPackageOrderUncheckedUpdateManyInput>
    /**
     * Filter which MitraPackageOrders to update
     */
    where?: MitraPackageOrderWhereInput
  }

  /**
   * MitraPackageOrder upsert
   */
  export type MitraPackageOrderUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackageOrder
     */
    select?: MitraPackageOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageOrderInclude<ExtArgs> | null
    /**
     * The filter to search for the MitraPackageOrder to update in case it exists.
     */
    where: MitraPackageOrderWhereUniqueInput
    /**
     * In case the MitraPackageOrder found by the `where` argument doesn't exist, create a new MitraPackageOrder with this data.
     */
    create: XOR<MitraPackageOrderCreateInput, MitraPackageOrderUncheckedCreateInput>
    /**
     * In case the MitraPackageOrder was found with the provided `where` argument, update it with this data.
     */
    update: XOR<MitraPackageOrderUpdateInput, MitraPackageOrderUncheckedUpdateInput>
  }

  /**
   * MitraPackageOrder delete
   */
  export type MitraPackageOrderDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackageOrder
     */
    select?: MitraPackageOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageOrderInclude<ExtArgs> | null
    /**
     * Filter which MitraPackageOrder to delete.
     */
    where: MitraPackageOrderWhereUniqueInput
  }

  /**
   * MitraPackageOrder deleteMany
   */
  export type MitraPackageOrderDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which MitraPackageOrders to delete
     */
    where?: MitraPackageOrderWhereInput
  }

  /**
   * MitraPackageOrder without action
   */
  export type MitraPackageOrderDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MitraPackageOrder
     */
    select?: MitraPackageOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: MitraPackageOrderInclude<ExtArgs> | null
  }


  /**
   * Model ExchangeRate
   */

  export type AggregateExchangeRate = {
    _count: ExchangeRateCountAggregateOutputType | null
    _avg: ExchangeRateAvgAggregateOutputType | null
    _sum: ExchangeRateSumAggregateOutputType | null
    _min: ExchangeRateMinAggregateOutputType | null
    _max: ExchangeRateMaxAggregateOutputType | null
  }

  export type ExchangeRateAvgAggregateOutputType = {
    rate_idr: Decimal | null
  }

  export type ExchangeRateSumAggregateOutputType = {
    rate_idr: Decimal | null
  }

  export type ExchangeRateMinAggregateOutputType = {
    id: string | null
    currency: string | null
    rate_idr: Decimal | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type ExchangeRateMaxAggregateOutputType = {
    id: string | null
    currency: string | null
    rate_idr: Decimal | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type ExchangeRateCountAggregateOutputType = {
    id: number
    currency: number
    rate_idr: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type ExchangeRateAvgAggregateInputType = {
    rate_idr?: true
  }

  export type ExchangeRateSumAggregateInputType = {
    rate_idr?: true
  }

  export type ExchangeRateMinAggregateInputType = {
    id?: true
    currency?: true
    rate_idr?: true
    created_at?: true
    updated_at?: true
  }

  export type ExchangeRateMaxAggregateInputType = {
    id?: true
    currency?: true
    rate_idr?: true
    created_at?: true
    updated_at?: true
  }

  export type ExchangeRateCountAggregateInputType = {
    id?: true
    currency?: true
    rate_idr?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type ExchangeRateAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ExchangeRate to aggregate.
     */
    where?: ExchangeRateWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ExchangeRates to fetch.
     */
    orderBy?: ExchangeRateOrderByWithRelationInput | ExchangeRateOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ExchangeRateWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ExchangeRates from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` ExchangeRates.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ExchangeRates
    **/
    _count?: true | ExchangeRateCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ExchangeRateAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ExchangeRateSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ExchangeRateMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ExchangeRateMaxAggregateInputType
  }

  export type GetExchangeRateAggregateType<T extends ExchangeRateAggregateArgs> = {
        [P in keyof T & keyof AggregateExchangeRate]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateExchangeRate[P]>
      : GetScalarType<T[P], AggregateExchangeRate[P]>
  }




  export type ExchangeRateGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ExchangeRateWhereInput
    orderBy?: ExchangeRateOrderByWithAggregationInput | ExchangeRateOrderByWithAggregationInput[]
    by: ExchangeRateScalarFieldEnum[] | ExchangeRateScalarFieldEnum
    having?: ExchangeRateScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ExchangeRateCountAggregateInputType | true
    _avg?: ExchangeRateAvgAggregateInputType
    _sum?: ExchangeRateSumAggregateInputType
    _min?: ExchangeRateMinAggregateInputType
    _max?: ExchangeRateMaxAggregateInputType
  }

  export type ExchangeRateGroupByOutputType = {
    id: string
    currency: string
    rate_idr: Decimal
    created_at: Date
    updated_at: Date
    _count: ExchangeRateCountAggregateOutputType | null
    _avg: ExchangeRateAvgAggregateOutputType | null
    _sum: ExchangeRateSumAggregateOutputType | null
    _min: ExchangeRateMinAggregateOutputType | null
    _max: ExchangeRateMaxAggregateOutputType | null
  }

  type GetExchangeRateGroupByPayload<T extends ExchangeRateGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<ExchangeRateGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof ExchangeRateGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], ExchangeRateGroupByOutputType[P]>
            : GetScalarType<T[P], ExchangeRateGroupByOutputType[P]>
        }
      >
    >


  export type ExchangeRateSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    currency?: boolean
    rate_idr?: boolean
    created_at?: boolean
    updated_at?: boolean
  }, ExtArgs["result"]["exchangeRate"]>


  export type ExchangeRateSelectScalar = {
    id?: boolean
    currency?: boolean
    rate_idr?: boolean
    created_at?: boolean
    updated_at?: boolean
  }


  export type $ExchangeRatePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ExchangeRate"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      currency: string
      rate_idr: Prisma.Decimal
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["exchangeRate"]>
    composites: {}
  }

  type ExchangeRateGetPayload<S extends boolean | null | undefined | ExchangeRateDefaultArgs> = $Result.GetResult<Prisma.$ExchangeRatePayload, S>

  type ExchangeRateCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ExchangeRateFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: ExchangeRateCountAggregateInputType | true
    }

  export interface ExchangeRateDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['ExchangeRate'], meta: { name: 'ExchangeRate' } }
    /**
     * Find zero or one ExchangeRate that matches the filter.
     * @param {ExchangeRateFindUniqueArgs} args - Arguments to find a ExchangeRate
     * @example
     * // Get one ExchangeRate
     * const exchangeRate = await prisma.exchangeRate.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends ExchangeRateFindUniqueArgs>(args: SelectSubset<T, ExchangeRateFindUniqueArgs<ExtArgs>>): Prisma__ExchangeRateClient<$Result.GetResult<Prisma.$ExchangeRatePayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one ExchangeRate that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {ExchangeRateFindUniqueOrThrowArgs} args - Arguments to find a ExchangeRate
     * @example
     * // Get one ExchangeRate
     * const exchangeRate = await prisma.exchangeRate.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends ExchangeRateFindUniqueOrThrowArgs>(args: SelectSubset<T, ExchangeRateFindUniqueOrThrowArgs<ExtArgs>>): Prisma__ExchangeRateClient<$Result.GetResult<Prisma.$ExchangeRatePayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first ExchangeRate that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ExchangeRateFindFirstArgs} args - Arguments to find a ExchangeRate
     * @example
     * // Get one ExchangeRate
     * const exchangeRate = await prisma.exchangeRate.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends ExchangeRateFindFirstArgs>(args?: SelectSubset<T, ExchangeRateFindFirstArgs<ExtArgs>>): Prisma__ExchangeRateClient<$Result.GetResult<Prisma.$ExchangeRatePayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first ExchangeRate 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 {ExchangeRateFindFirstOrThrowArgs} args - Arguments to find a ExchangeRate
     * @example
     * // Get one ExchangeRate
     * const exchangeRate = await prisma.exchangeRate.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends ExchangeRateFindFirstOrThrowArgs>(args?: SelectSubset<T, ExchangeRateFindFirstOrThrowArgs<ExtArgs>>): Prisma__ExchangeRateClient<$Result.GetResult<Prisma.$ExchangeRatePayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more ExchangeRates that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ExchangeRateFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all ExchangeRates
     * const exchangeRates = await prisma.exchangeRate.findMany()
     * 
     * // Get first 10 ExchangeRates
     * const exchangeRates = await prisma.exchangeRate.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const exchangeRateWithIdOnly = await prisma.exchangeRate.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends ExchangeRateFindManyArgs>(args?: SelectSubset<T, ExchangeRateFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ExchangeRatePayload<ExtArgs>, T, "findMany">>

    /**
     * Create a ExchangeRate.
     * @param {ExchangeRateCreateArgs} args - Arguments to create a ExchangeRate.
     * @example
     * // Create one ExchangeRate
     * const ExchangeRate = await prisma.exchangeRate.create({
     *   data: {
     *     // ... data to create a ExchangeRate
     *   }
     * })
     * 
     */
    create<T extends ExchangeRateCreateArgs>(args: SelectSubset<T, ExchangeRateCreateArgs<ExtArgs>>): Prisma__ExchangeRateClient<$Result.GetResult<Prisma.$ExchangeRatePayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many ExchangeRates.
     * @param {ExchangeRateCreateManyArgs} args - Arguments to create many ExchangeRates.
     * @example
     * // Create many ExchangeRates
     * const exchangeRate = await prisma.exchangeRate.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends ExchangeRateCreateManyArgs>(args?: SelectSubset<T, ExchangeRateCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a ExchangeRate.
     * @param {ExchangeRateDeleteArgs} args - Arguments to delete one ExchangeRate.
     * @example
     * // Delete one ExchangeRate
     * const ExchangeRate = await prisma.exchangeRate.delete({
     *   where: {
     *     // ... filter to delete one ExchangeRate
     *   }
     * })
     * 
     */
    delete<T extends ExchangeRateDeleteArgs>(args: SelectSubset<T, ExchangeRateDeleteArgs<ExtArgs>>): Prisma__ExchangeRateClient<$Result.GetResult<Prisma.$ExchangeRatePayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one ExchangeRate.
     * @param {ExchangeRateUpdateArgs} args - Arguments to update one ExchangeRate.
     * @example
     * // Update one ExchangeRate
     * const exchangeRate = await prisma.exchangeRate.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends ExchangeRateUpdateArgs>(args: SelectSubset<T, ExchangeRateUpdateArgs<ExtArgs>>): Prisma__ExchangeRateClient<$Result.GetResult<Prisma.$ExchangeRatePayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more ExchangeRates.
     * @param {ExchangeRateDeleteManyArgs} args - Arguments to filter ExchangeRates to delete.
     * @example
     * // Delete a few ExchangeRates
     * const { count } = await prisma.exchangeRate.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends ExchangeRateDeleteManyArgs>(args?: SelectSubset<T, ExchangeRateDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more ExchangeRates.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ExchangeRateUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many ExchangeRates
     * const exchangeRate = await prisma.exchangeRate.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends ExchangeRateUpdateManyArgs>(args: SelectSubset<T, ExchangeRateUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one ExchangeRate.
     * @param {ExchangeRateUpsertArgs} args - Arguments to update or create a ExchangeRate.
     * @example
     * // Update or create a ExchangeRate
     * const exchangeRate = await prisma.exchangeRate.upsert({
     *   create: {
     *     // ... data to create a ExchangeRate
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the ExchangeRate we want to update
     *   }
     * })
     */
    upsert<T extends ExchangeRateUpsertArgs>(args: SelectSubset<T, ExchangeRateUpsertArgs<ExtArgs>>): Prisma__ExchangeRateClient<$Result.GetResult<Prisma.$ExchangeRatePayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of ExchangeRates.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ExchangeRateCountArgs} args - Arguments to filter ExchangeRates to count.
     * @example
     * // Count the number of ExchangeRates
     * const count = await prisma.exchangeRate.count({
     *   where: {
     *     // ... the filter for the ExchangeRates we want to count
     *   }
     * })
    **/
    count<T extends ExchangeRateCountArgs>(
      args?: Subset<T, ExchangeRateCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], ExchangeRateCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a ExchangeRate.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ExchangeRateAggregateArgs} 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 ExchangeRateAggregateArgs>(args: Subset<T, ExchangeRateAggregateArgs>): Prisma.PrismaPromise<GetExchangeRateAggregateType<T>>

    /**
     * Group by ExchangeRate.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ExchangeRateGroupByArgs} 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 ExchangeRateGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: ExchangeRateGroupByArgs['orderBy'] }
        : { orderBy?: ExchangeRateGroupByArgs['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, ExchangeRateGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetExchangeRateGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the ExchangeRate model
   */
  readonly fields: ExchangeRateFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for ExchangeRate.
   * 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__ExchangeRateClient<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 ExchangeRate model
   */ 
  interface ExchangeRateFieldRefs {
    readonly id: FieldRef<"ExchangeRate", 'String'>
    readonly currency: FieldRef<"ExchangeRate", 'String'>
    readonly rate_idr: FieldRef<"ExchangeRate", 'Decimal'>
    readonly created_at: FieldRef<"ExchangeRate", 'DateTime'>
    readonly updated_at: FieldRef<"ExchangeRate", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * ExchangeRate findUnique
   */
  export type ExchangeRateFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExchangeRate
     */
    select?: ExchangeRateSelect<ExtArgs> | null
    /**
     * Filter, which ExchangeRate to fetch.
     */
    where: ExchangeRateWhereUniqueInput
  }

  /**
   * ExchangeRate findUniqueOrThrow
   */
  export type ExchangeRateFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExchangeRate
     */
    select?: ExchangeRateSelect<ExtArgs> | null
    /**
     * Filter, which ExchangeRate to fetch.
     */
    where: ExchangeRateWhereUniqueInput
  }

  /**
   * ExchangeRate findFirst
   */
  export type ExchangeRateFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExchangeRate
     */
    select?: ExchangeRateSelect<ExtArgs> | null
    /**
     * Filter, which ExchangeRate to fetch.
     */
    where?: ExchangeRateWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ExchangeRates to fetch.
     */
    orderBy?: ExchangeRateOrderByWithRelationInput | ExchangeRateOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for ExchangeRates.
     */
    cursor?: ExchangeRateWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ExchangeRates from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` ExchangeRates.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of ExchangeRates.
     */
    distinct?: ExchangeRateScalarFieldEnum | ExchangeRateScalarFieldEnum[]
  }

  /**
   * ExchangeRate findFirstOrThrow
   */
  export type ExchangeRateFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExchangeRate
     */
    select?: ExchangeRateSelect<ExtArgs> | null
    /**
     * Filter, which ExchangeRate to fetch.
     */
    where?: ExchangeRateWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ExchangeRates to fetch.
     */
    orderBy?: ExchangeRateOrderByWithRelationInput | ExchangeRateOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for ExchangeRates.
     */
    cursor?: ExchangeRateWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ExchangeRates from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` ExchangeRates.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of ExchangeRates.
     */
    distinct?: ExchangeRateScalarFieldEnum | ExchangeRateScalarFieldEnum[]
  }

  /**
   * ExchangeRate findMany
   */
  export type ExchangeRateFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExchangeRate
     */
    select?: ExchangeRateSelect<ExtArgs> | null
    /**
     * Filter, which ExchangeRates to fetch.
     */
    where?: ExchangeRateWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ExchangeRates to fetch.
     */
    orderBy?: ExchangeRateOrderByWithRelationInput | ExchangeRateOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing ExchangeRates.
     */
    cursor?: ExchangeRateWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ExchangeRates from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` ExchangeRates.
     */
    skip?: number
    distinct?: ExchangeRateScalarFieldEnum | ExchangeRateScalarFieldEnum[]
  }

  /**
   * ExchangeRate create
   */
  export type ExchangeRateCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExchangeRate
     */
    select?: ExchangeRateSelect<ExtArgs> | null
    /**
     * The data needed to create a ExchangeRate.
     */
    data: XOR<ExchangeRateCreateInput, ExchangeRateUncheckedCreateInput>
  }

  /**
   * ExchangeRate createMany
   */
  export type ExchangeRateCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many ExchangeRates.
     */
    data: ExchangeRateCreateManyInput | ExchangeRateCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * ExchangeRate update
   */
  export type ExchangeRateUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExchangeRate
     */
    select?: ExchangeRateSelect<ExtArgs> | null
    /**
     * The data needed to update a ExchangeRate.
     */
    data: XOR<ExchangeRateUpdateInput, ExchangeRateUncheckedUpdateInput>
    /**
     * Choose, which ExchangeRate to update.
     */
    where: ExchangeRateWhereUniqueInput
  }

  /**
   * ExchangeRate updateMany
   */
  export type ExchangeRateUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ExchangeRates.
     */
    data: XOR<ExchangeRateUpdateManyMutationInput, ExchangeRateUncheckedUpdateManyInput>
    /**
     * Filter which ExchangeRates to update
     */
    where?: ExchangeRateWhereInput
  }

  /**
   * ExchangeRate upsert
   */
  export type ExchangeRateUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExchangeRate
     */
    select?: ExchangeRateSelect<ExtArgs> | null
    /**
     * The filter to search for the ExchangeRate to update in case it exists.
     */
    where: ExchangeRateWhereUniqueInput
    /**
     * In case the ExchangeRate found by the `where` argument doesn't exist, create a new ExchangeRate with this data.
     */
    create: XOR<ExchangeRateCreateInput, ExchangeRateUncheckedCreateInput>
    /**
     * In case the ExchangeRate was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ExchangeRateUpdateInput, ExchangeRateUncheckedUpdateInput>
  }

  /**
   * ExchangeRate delete
   */
  export type ExchangeRateDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExchangeRate
     */
    select?: ExchangeRateSelect<ExtArgs> | null
    /**
     * Filter which ExchangeRate to delete.
     */
    where: ExchangeRateWhereUniqueInput
  }

  /**
   * ExchangeRate deleteMany
   */
  export type ExchangeRateDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ExchangeRates to delete
     */
    where?: ExchangeRateWhereInput
  }

  /**
   * ExchangeRate without action
   */
  export type ExchangeRateDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ExchangeRate
     */
    select?: ExchangeRateSelect<ExtArgs> | null
  }


  /**
   * Model Contact
   */

  export type AggregateContact = {
    _count: ContactCountAggregateOutputType | null
    _min: ContactMinAggregateOutputType | null
    _max: ContactMaxAggregateOutputType | null
  }

  export type ContactMinAggregateOutputType = {
    id: string | null
    name: string | null
    value: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type ContactMaxAggregateOutputType = {
    id: string | null
    name: string | null
    value: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type ContactCountAggregateOutputType = {
    id: number
    name: number
    value: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type ContactMinAggregateInputType = {
    id?: true
    name?: true
    value?: true
    created_at?: true
    updated_at?: true
  }

  export type ContactMaxAggregateInputType = {
    id?: true
    name?: true
    value?: true
    created_at?: true
    updated_at?: true
  }

  export type ContactCountAggregateInputType = {
    id?: true
    name?: true
    value?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type ContactAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Contact to aggregate.
     */
    where?: ContactWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Contacts to fetch.
     */
    orderBy?: ContactOrderByWithRelationInput | ContactOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ContactWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Contacts from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Contacts.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Contacts
    **/
    _count?: true | ContactCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ContactMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ContactMaxAggregateInputType
  }

  export type GetContactAggregateType<T extends ContactAggregateArgs> = {
        [P in keyof T & keyof AggregateContact]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateContact[P]>
      : GetScalarType<T[P], AggregateContact[P]>
  }




  export type ContactGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ContactWhereInput
    orderBy?: ContactOrderByWithAggregationInput | ContactOrderByWithAggregationInput[]
    by: ContactScalarFieldEnum[] | ContactScalarFieldEnum
    having?: ContactScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ContactCountAggregateInputType | true
    _min?: ContactMinAggregateInputType
    _max?: ContactMaxAggregateInputType
  }

  export type ContactGroupByOutputType = {
    id: string
    name: string
    value: string | null
    created_at: Date
    updated_at: Date
    _count: ContactCountAggregateOutputType | null
    _min: ContactMinAggregateOutputType | null
    _max: ContactMaxAggregateOutputType | null
  }

  type GetContactGroupByPayload<T extends ContactGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<ContactGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof ContactGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], ContactGroupByOutputType[P]>
            : GetScalarType<T[P], ContactGroupByOutputType[P]>
        }
      >
    >


  export type ContactSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    value?: boolean
    created_at?: boolean
    updated_at?: boolean
  }, ExtArgs["result"]["contact"]>


  export type ContactSelectScalar = {
    id?: boolean
    name?: boolean
    value?: boolean
    created_at?: boolean
    updated_at?: boolean
  }


  export type $ContactPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Contact"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      value: string | null
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["contact"]>
    composites: {}
  }

  type ContactGetPayload<S extends boolean | null | undefined | ContactDefaultArgs> = $Result.GetResult<Prisma.$ContactPayload, S>

  type ContactCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ContactFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: ContactCountAggregateInputType | true
    }

  export interface ContactDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Contact'], meta: { name: 'Contact' } }
    /**
     * Find zero or one Contact that matches the filter.
     * @param {ContactFindUniqueArgs} args - Arguments to find a Contact
     * @example
     * // Get one Contact
     * const contact = await prisma.contact.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends ContactFindUniqueArgs>(args: SelectSubset<T, ContactFindUniqueArgs<ExtArgs>>): Prisma__ContactClient<$Result.GetResult<Prisma.$ContactPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one Contact that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {ContactFindUniqueOrThrowArgs} args - Arguments to find a Contact
     * @example
     * // Get one Contact
     * const contact = await prisma.contact.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends ContactFindUniqueOrThrowArgs>(args: SelectSubset<T, ContactFindUniqueOrThrowArgs<ExtArgs>>): Prisma__ContactClient<$Result.GetResult<Prisma.$ContactPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first Contact that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ContactFindFirstArgs} args - Arguments to find a Contact
     * @example
     * // Get one Contact
     * const contact = await prisma.contact.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends ContactFindFirstArgs>(args?: SelectSubset<T, ContactFindFirstArgs<ExtArgs>>): Prisma__ContactClient<$Result.GetResult<Prisma.$ContactPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Contact 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 {ContactFindFirstOrThrowArgs} args - Arguments to find a Contact
     * @example
     * // Get one Contact
     * const contact = await prisma.contact.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends ContactFindFirstOrThrowArgs>(args?: SelectSubset<T, ContactFindFirstOrThrowArgs<ExtArgs>>): Prisma__ContactClient<$Result.GetResult<Prisma.$ContactPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Contacts that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ContactFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Contacts
     * const contacts = await prisma.contact.findMany()
     * 
     * // Get first 10 Contacts
     * const contacts = await prisma.contact.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const contactWithIdOnly = await prisma.contact.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends ContactFindManyArgs>(args?: SelectSubset<T, ContactFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ContactPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Contact.
     * @param {ContactCreateArgs} args - Arguments to create a Contact.
     * @example
     * // Create one Contact
     * const Contact = await prisma.contact.create({
     *   data: {
     *     // ... data to create a Contact
     *   }
     * })
     * 
     */
    create<T extends ContactCreateArgs>(args: SelectSubset<T, ContactCreateArgs<ExtArgs>>): Prisma__ContactClient<$Result.GetResult<Prisma.$ContactPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many Contacts.
     * @param {ContactCreateManyArgs} args - Arguments to create many Contacts.
     * @example
     * // Create many Contacts
     * const contact = await prisma.contact.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends ContactCreateManyArgs>(args?: SelectSubset<T, ContactCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Contact.
     * @param {ContactDeleteArgs} args - Arguments to delete one Contact.
     * @example
     * // Delete one Contact
     * const Contact = await prisma.contact.delete({
     *   where: {
     *     // ... filter to delete one Contact
     *   }
     * })
     * 
     */
    delete<T extends ContactDeleteArgs>(args: SelectSubset<T, ContactDeleteArgs<ExtArgs>>): Prisma__ContactClient<$Result.GetResult<Prisma.$ContactPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Contact.
     * @param {ContactUpdateArgs} args - Arguments to update one Contact.
     * @example
     * // Update one Contact
     * const contact = await prisma.contact.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends ContactUpdateArgs>(args: SelectSubset<T, ContactUpdateArgs<ExtArgs>>): Prisma__ContactClient<$Result.GetResult<Prisma.$ContactPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more Contacts.
     * @param {ContactDeleteManyArgs} args - Arguments to filter Contacts to delete.
     * @example
     * // Delete a few Contacts
     * const { count } = await prisma.contact.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends ContactDeleteManyArgs>(args?: SelectSubset<T, ContactDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Contacts.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ContactUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Contacts
     * const contact = await prisma.contact.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends ContactUpdateManyArgs>(args: SelectSubset<T, ContactUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Contact.
     * @param {ContactUpsertArgs} args - Arguments to update or create a Contact.
     * @example
     * // Update or create a Contact
     * const contact = await prisma.contact.upsert({
     *   create: {
     *     // ... data to create a Contact
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Contact we want to update
     *   }
     * })
     */
    upsert<T extends ContactUpsertArgs>(args: SelectSubset<T, ContactUpsertArgs<ExtArgs>>): Prisma__ContactClient<$Result.GetResult<Prisma.$ContactPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of Contacts.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ContactCountArgs} args - Arguments to filter Contacts to count.
     * @example
     * // Count the number of Contacts
     * const count = await prisma.contact.count({
     *   where: {
     *     // ... the filter for the Contacts we want to count
     *   }
     * })
    **/
    count<T extends ContactCountArgs>(
      args?: Subset<T, ContactCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], ContactCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Contact.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ContactAggregateArgs} 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 ContactAggregateArgs>(args: Subset<T, ContactAggregateArgs>): Prisma.PrismaPromise<GetContactAggregateType<T>>

    /**
     * Group by Contact.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ContactGroupByArgs} 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 ContactGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: ContactGroupByArgs['orderBy'] }
        : { orderBy?: ContactGroupByArgs['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, ContactGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetContactGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Contact model
   */
  readonly fields: ContactFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Contact.
   * 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__ContactClient<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 Contact model
   */ 
  interface ContactFieldRefs {
    readonly id: FieldRef<"Contact", 'String'>
    readonly name: FieldRef<"Contact", 'String'>
    readonly value: FieldRef<"Contact", 'String'>
    readonly created_at: FieldRef<"Contact", 'DateTime'>
    readonly updated_at: FieldRef<"Contact", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Contact findUnique
   */
  export type ContactFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Contact
     */
    select?: ContactSelect<ExtArgs> | null
    /**
     * Filter, which Contact to fetch.
     */
    where: ContactWhereUniqueInput
  }

  /**
   * Contact findUniqueOrThrow
   */
  export type ContactFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Contact
     */
    select?: ContactSelect<ExtArgs> | null
    /**
     * Filter, which Contact to fetch.
     */
    where: ContactWhereUniqueInput
  }

  /**
   * Contact findFirst
   */
  export type ContactFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Contact
     */
    select?: ContactSelect<ExtArgs> | null
    /**
     * Filter, which Contact to fetch.
     */
    where?: ContactWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Contacts to fetch.
     */
    orderBy?: ContactOrderByWithRelationInput | ContactOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Contacts.
     */
    cursor?: ContactWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Contacts from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Contacts.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Contacts.
     */
    distinct?: ContactScalarFieldEnum | ContactScalarFieldEnum[]
  }

  /**
   * Contact findFirstOrThrow
   */
  export type ContactFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Contact
     */
    select?: ContactSelect<ExtArgs> | null
    /**
     * Filter, which Contact to fetch.
     */
    where?: ContactWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Contacts to fetch.
     */
    orderBy?: ContactOrderByWithRelationInput | ContactOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Contacts.
     */
    cursor?: ContactWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Contacts from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Contacts.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Contacts.
     */
    distinct?: ContactScalarFieldEnum | ContactScalarFieldEnum[]
  }

  /**
   * Contact findMany
   */
  export type ContactFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Contact
     */
    select?: ContactSelect<ExtArgs> | null
    /**
     * Filter, which Contacts to fetch.
     */
    where?: ContactWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Contacts to fetch.
     */
    orderBy?: ContactOrderByWithRelationInput | ContactOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Contacts.
     */
    cursor?: ContactWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Contacts from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Contacts.
     */
    skip?: number
    distinct?: ContactScalarFieldEnum | ContactScalarFieldEnum[]
  }

  /**
   * Contact create
   */
  export type ContactCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Contact
     */
    select?: ContactSelect<ExtArgs> | null
    /**
     * The data needed to create a Contact.
     */
    data: XOR<ContactCreateInput, ContactUncheckedCreateInput>
  }

  /**
   * Contact createMany
   */
  export type ContactCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Contacts.
     */
    data: ContactCreateManyInput | ContactCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Contact update
   */
  export type ContactUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Contact
     */
    select?: ContactSelect<ExtArgs> | null
    /**
     * The data needed to update a Contact.
     */
    data: XOR<ContactUpdateInput, ContactUncheckedUpdateInput>
    /**
     * Choose, which Contact to update.
     */
    where: ContactWhereUniqueInput
  }

  /**
   * Contact updateMany
   */
  export type ContactUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Contacts.
     */
    data: XOR<ContactUpdateManyMutationInput, ContactUncheckedUpdateManyInput>
    /**
     * Filter which Contacts to update
     */
    where?: ContactWhereInput
  }

  /**
   * Contact upsert
   */
  export type ContactUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Contact
     */
    select?: ContactSelect<ExtArgs> | null
    /**
     * The filter to search for the Contact to update in case it exists.
     */
    where: ContactWhereUniqueInput
    /**
     * In case the Contact found by the `where` argument doesn't exist, create a new Contact with this data.
     */
    create: XOR<ContactCreateInput, ContactUncheckedCreateInput>
    /**
     * In case the Contact was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ContactUpdateInput, ContactUncheckedUpdateInput>
  }

  /**
   * Contact delete
   */
  export type ContactDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Contact
     */
    select?: ContactSelect<ExtArgs> | null
    /**
     * Filter which Contact to delete.
     */
    where: ContactWhereUniqueInput
  }

  /**
   * Contact deleteMany
   */
  export type ContactDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Contacts to delete
     */
    where?: ContactWhereInput
  }

  /**
   * Contact without action
   */
  export type ContactDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Contact
     */
    select?: ContactSelect<ExtArgs> | null
  }


  /**
   * Model Faq
   */

  export type AggregateFaq = {
    _count: FaqCountAggregateOutputType | null
    _min: FaqMinAggregateOutputType | null
    _max: FaqMaxAggregateOutputType | null
  }

  export type FaqMinAggregateOutputType = {
    id: string | null
    question: string | null
    answer: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type FaqMaxAggregateOutputType = {
    id: string | null
    question: string | null
    answer: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type FaqCountAggregateOutputType = {
    id: number
    question: number
    answer: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type FaqMinAggregateInputType = {
    id?: true
    question?: true
    answer?: true
    created_at?: true
    updated_at?: true
  }

  export type FaqMaxAggregateInputType = {
    id?: true
    question?: true
    answer?: true
    created_at?: true
    updated_at?: true
  }

  export type FaqCountAggregateInputType = {
    id?: true
    question?: true
    answer?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type FaqAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Faq to aggregate.
     */
    where?: FaqWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Faqs to fetch.
     */
    orderBy?: FaqOrderByWithRelationInput | FaqOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: FaqWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Faqs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Faqs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Faqs
    **/
    _count?: true | FaqCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: FaqMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: FaqMaxAggregateInputType
  }

  export type GetFaqAggregateType<T extends FaqAggregateArgs> = {
        [P in keyof T & keyof AggregateFaq]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateFaq[P]>
      : GetScalarType<T[P], AggregateFaq[P]>
  }




  export type FaqGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: FaqWhereInput
    orderBy?: FaqOrderByWithAggregationInput | FaqOrderByWithAggregationInput[]
    by: FaqScalarFieldEnum[] | FaqScalarFieldEnum
    having?: FaqScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: FaqCountAggregateInputType | true
    _min?: FaqMinAggregateInputType
    _max?: FaqMaxAggregateInputType
  }

  export type FaqGroupByOutputType = {
    id: string
    question: string
    answer: string
    created_at: Date
    updated_at: Date
    _count: FaqCountAggregateOutputType | null
    _min: FaqMinAggregateOutputType | null
    _max: FaqMaxAggregateOutputType | null
  }

  type GetFaqGroupByPayload<T extends FaqGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<FaqGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof FaqGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], FaqGroupByOutputType[P]>
            : GetScalarType<T[P], FaqGroupByOutputType[P]>
        }
      >
    >


  export type FaqSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    question?: boolean
    answer?: boolean
    created_at?: boolean
    updated_at?: boolean
  }, ExtArgs["result"]["faq"]>


  export type FaqSelectScalar = {
    id?: boolean
    question?: boolean
    answer?: boolean
    created_at?: boolean
    updated_at?: boolean
  }


  export type $FaqPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Faq"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      question: string
      answer: string
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["faq"]>
    composites: {}
  }

  type FaqGetPayload<S extends boolean | null | undefined | FaqDefaultArgs> = $Result.GetResult<Prisma.$FaqPayload, S>

  type FaqCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<FaqFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: FaqCountAggregateInputType | true
    }

  export interface FaqDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Faq'], meta: { name: 'Faq' } }
    /**
     * Find zero or one Faq that matches the filter.
     * @param {FaqFindUniqueArgs} args - Arguments to find a Faq
     * @example
     * // Get one Faq
     * const faq = await prisma.faq.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends FaqFindUniqueArgs>(args: SelectSubset<T, FaqFindUniqueArgs<ExtArgs>>): Prisma__FaqClient<$Result.GetResult<Prisma.$FaqPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one Faq that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {FaqFindUniqueOrThrowArgs} args - Arguments to find a Faq
     * @example
     * // Get one Faq
     * const faq = await prisma.faq.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends FaqFindUniqueOrThrowArgs>(args: SelectSubset<T, FaqFindUniqueOrThrowArgs<ExtArgs>>): Prisma__FaqClient<$Result.GetResult<Prisma.$FaqPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first Faq that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FaqFindFirstArgs} args - Arguments to find a Faq
     * @example
     * // Get one Faq
     * const faq = await prisma.faq.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends FaqFindFirstArgs>(args?: SelectSubset<T, FaqFindFirstArgs<ExtArgs>>): Prisma__FaqClient<$Result.GetResult<Prisma.$FaqPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Faq 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 {FaqFindFirstOrThrowArgs} args - Arguments to find a Faq
     * @example
     * // Get one Faq
     * const faq = await prisma.faq.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends FaqFindFirstOrThrowArgs>(args?: SelectSubset<T, FaqFindFirstOrThrowArgs<ExtArgs>>): Prisma__FaqClient<$Result.GetResult<Prisma.$FaqPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Faqs that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FaqFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Faqs
     * const faqs = await prisma.faq.findMany()
     * 
     * // Get first 10 Faqs
     * const faqs = await prisma.faq.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const faqWithIdOnly = await prisma.faq.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends FaqFindManyArgs>(args?: SelectSubset<T, FaqFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$FaqPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Faq.
     * @param {FaqCreateArgs} args - Arguments to create a Faq.
     * @example
     * // Create one Faq
     * const Faq = await prisma.faq.create({
     *   data: {
     *     // ... data to create a Faq
     *   }
     * })
     * 
     */
    create<T extends FaqCreateArgs>(args: SelectSubset<T, FaqCreateArgs<ExtArgs>>): Prisma__FaqClient<$Result.GetResult<Prisma.$FaqPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many Faqs.
     * @param {FaqCreateManyArgs} args - Arguments to create many Faqs.
     * @example
     * // Create many Faqs
     * const faq = await prisma.faq.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends FaqCreateManyArgs>(args?: SelectSubset<T, FaqCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Faq.
     * @param {FaqDeleteArgs} args - Arguments to delete one Faq.
     * @example
     * // Delete one Faq
     * const Faq = await prisma.faq.delete({
     *   where: {
     *     // ... filter to delete one Faq
     *   }
     * })
     * 
     */
    delete<T extends FaqDeleteArgs>(args: SelectSubset<T, FaqDeleteArgs<ExtArgs>>): Prisma__FaqClient<$Result.GetResult<Prisma.$FaqPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Faq.
     * @param {FaqUpdateArgs} args - Arguments to update one Faq.
     * @example
     * // Update one Faq
     * const faq = await prisma.faq.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends FaqUpdateArgs>(args: SelectSubset<T, FaqUpdateArgs<ExtArgs>>): Prisma__FaqClient<$Result.GetResult<Prisma.$FaqPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more Faqs.
     * @param {FaqDeleteManyArgs} args - Arguments to filter Faqs to delete.
     * @example
     * // Delete a few Faqs
     * const { count } = await prisma.faq.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends FaqDeleteManyArgs>(args?: SelectSubset<T, FaqDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Faqs.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FaqUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Faqs
     * const faq = await prisma.faq.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends FaqUpdateManyArgs>(args: SelectSubset<T, FaqUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Faq.
     * @param {FaqUpsertArgs} args - Arguments to update or create a Faq.
     * @example
     * // Update or create a Faq
     * const faq = await prisma.faq.upsert({
     *   create: {
     *     // ... data to create a Faq
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Faq we want to update
     *   }
     * })
     */
    upsert<T extends FaqUpsertArgs>(args: SelectSubset<T, FaqUpsertArgs<ExtArgs>>): Prisma__FaqClient<$Result.GetResult<Prisma.$FaqPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of Faqs.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FaqCountArgs} args - Arguments to filter Faqs to count.
     * @example
     * // Count the number of Faqs
     * const count = await prisma.faq.count({
     *   where: {
     *     // ... the filter for the Faqs we want to count
     *   }
     * })
    **/
    count<T extends FaqCountArgs>(
      args?: Subset<T, FaqCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], FaqCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Faq.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FaqAggregateArgs} 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 FaqAggregateArgs>(args: Subset<T, FaqAggregateArgs>): Prisma.PrismaPromise<GetFaqAggregateType<T>>

    /**
     * Group by Faq.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FaqGroupByArgs} 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 FaqGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: FaqGroupByArgs['orderBy'] }
        : { orderBy?: FaqGroupByArgs['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, FaqGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetFaqGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Faq model
   */
  readonly fields: FaqFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Faq.
   * 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__FaqClient<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 Faq model
   */ 
  interface FaqFieldRefs {
    readonly id: FieldRef<"Faq", 'String'>
    readonly question: FieldRef<"Faq", 'String'>
    readonly answer: FieldRef<"Faq", 'String'>
    readonly created_at: FieldRef<"Faq", 'DateTime'>
    readonly updated_at: FieldRef<"Faq", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Faq findUnique
   */
  export type FaqFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Faq
     */
    select?: FaqSelect<ExtArgs> | null
    /**
     * Filter, which Faq to fetch.
     */
    where: FaqWhereUniqueInput
  }

  /**
   * Faq findUniqueOrThrow
   */
  export type FaqFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Faq
     */
    select?: FaqSelect<ExtArgs> | null
    /**
     * Filter, which Faq to fetch.
     */
    where: FaqWhereUniqueInput
  }

  /**
   * Faq findFirst
   */
  export type FaqFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Faq
     */
    select?: FaqSelect<ExtArgs> | null
    /**
     * Filter, which Faq to fetch.
     */
    where?: FaqWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Faqs to fetch.
     */
    orderBy?: FaqOrderByWithRelationInput | FaqOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Faqs.
     */
    cursor?: FaqWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Faqs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Faqs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Faqs.
     */
    distinct?: FaqScalarFieldEnum | FaqScalarFieldEnum[]
  }

  /**
   * Faq findFirstOrThrow
   */
  export type FaqFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Faq
     */
    select?: FaqSelect<ExtArgs> | null
    /**
     * Filter, which Faq to fetch.
     */
    where?: FaqWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Faqs to fetch.
     */
    orderBy?: FaqOrderByWithRelationInput | FaqOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Faqs.
     */
    cursor?: FaqWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Faqs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Faqs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Faqs.
     */
    distinct?: FaqScalarFieldEnum | FaqScalarFieldEnum[]
  }

  /**
   * Faq findMany
   */
  export type FaqFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Faq
     */
    select?: FaqSelect<ExtArgs> | null
    /**
     * Filter, which Faqs to fetch.
     */
    where?: FaqWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Faqs to fetch.
     */
    orderBy?: FaqOrderByWithRelationInput | FaqOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Faqs.
     */
    cursor?: FaqWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Faqs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Faqs.
     */
    skip?: number
    distinct?: FaqScalarFieldEnum | FaqScalarFieldEnum[]
  }

  /**
   * Faq create
   */
  export type FaqCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Faq
     */
    select?: FaqSelect<ExtArgs> | null
    /**
     * The data needed to create a Faq.
     */
    data: XOR<FaqCreateInput, FaqUncheckedCreateInput>
  }

  /**
   * Faq createMany
   */
  export type FaqCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Faqs.
     */
    data: FaqCreateManyInput | FaqCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Faq update
   */
  export type FaqUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Faq
     */
    select?: FaqSelect<ExtArgs> | null
    /**
     * The data needed to update a Faq.
     */
    data: XOR<FaqUpdateInput, FaqUncheckedUpdateInput>
    /**
     * Choose, which Faq to update.
     */
    where: FaqWhereUniqueInput
  }

  /**
   * Faq updateMany
   */
  export type FaqUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Faqs.
     */
    data: XOR<FaqUpdateManyMutationInput, FaqUncheckedUpdateManyInput>
    /**
     * Filter which Faqs to update
     */
    where?: FaqWhereInput
  }

  /**
   * Faq upsert
   */
  export type FaqUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Faq
     */
    select?: FaqSelect<ExtArgs> | null
    /**
     * The filter to search for the Faq to update in case it exists.
     */
    where: FaqWhereUniqueInput
    /**
     * In case the Faq found by the `where` argument doesn't exist, create a new Faq with this data.
     */
    create: XOR<FaqCreateInput, FaqUncheckedCreateInput>
    /**
     * In case the Faq was found with the provided `where` argument, update it with this data.
     */
    update: XOR<FaqUpdateInput, FaqUncheckedUpdateInput>
  }

  /**
   * Faq delete
   */
  export type FaqDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Faq
     */
    select?: FaqSelect<ExtArgs> | null
    /**
     * Filter which Faq to delete.
     */
    where: FaqWhereUniqueInput
  }

  /**
   * Faq deleteMany
   */
  export type FaqDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Faqs to delete
     */
    where?: FaqWhereInput
  }

  /**
   * Faq without action
   */
  export type FaqDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Faq
     */
    select?: FaqSelect<ExtArgs> | null
  }


  /**
   * Model Content
   */

  export type AggregateContent = {
    _count: ContentCountAggregateOutputType | null
    _min: ContentMinAggregateOutputType | null
    _max: ContentMaxAggregateOutputType | null
  }

  export type ContentMinAggregateOutputType = {
    id: string | null
    page: string | null
    section: string | null
    type: $Enums.ContentType | null
    key: string | null
    visible: boolean | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type ContentMaxAggregateOutputType = {
    id: string | null
    page: string | null
    section: string | null
    type: $Enums.ContentType | null
    key: string | null
    visible: boolean | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type ContentCountAggregateOutputType = {
    id: number
    page: number
    section: number
    type: number
    key: number
    value: number
    visible: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type ContentMinAggregateInputType = {
    id?: true
    page?: true
    section?: true
    type?: true
    key?: true
    visible?: true
    created_at?: true
    updated_at?: true
  }

  export type ContentMaxAggregateInputType = {
    id?: true
    page?: true
    section?: true
    type?: true
    key?: true
    visible?: true
    created_at?: true
    updated_at?: true
  }

  export type ContentCountAggregateInputType = {
    id?: true
    page?: true
    section?: true
    type?: true
    key?: true
    value?: true
    visible?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type ContentAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Content to aggregate.
     */
    where?: ContentWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Contents to fetch.
     */
    orderBy?: ContentOrderByWithRelationInput | ContentOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ContentWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Contents from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Contents.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Contents
    **/
    _count?: true | ContentCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ContentMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ContentMaxAggregateInputType
  }

  export type GetContentAggregateType<T extends ContentAggregateArgs> = {
        [P in keyof T & keyof AggregateContent]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateContent[P]>
      : GetScalarType<T[P], AggregateContent[P]>
  }




  export type ContentGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ContentWhereInput
    orderBy?: ContentOrderByWithAggregationInput | ContentOrderByWithAggregationInput[]
    by: ContentScalarFieldEnum[] | ContentScalarFieldEnum
    having?: ContentScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ContentCountAggregateInputType | true
    _min?: ContentMinAggregateInputType
    _max?: ContentMaxAggregateInputType
  }

  export type ContentGroupByOutputType = {
    id: string
    page: string
    section: string
    type: $Enums.ContentType
    key: string
    value: JsonValue
    visible: boolean
    created_at: Date
    updated_at: Date
    _count: ContentCountAggregateOutputType | null
    _min: ContentMinAggregateOutputType | null
    _max: ContentMaxAggregateOutputType | null
  }

  type GetContentGroupByPayload<T extends ContentGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<ContentGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof ContentGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], ContentGroupByOutputType[P]>
            : GetScalarType<T[P], ContentGroupByOutputType[P]>
        }
      >
    >


  export type ContentSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    page?: boolean
    section?: boolean
    type?: boolean
    key?: boolean
    value?: boolean
    visible?: boolean
    created_at?: boolean
    updated_at?: boolean
  }, ExtArgs["result"]["content"]>


  export type ContentSelectScalar = {
    id?: boolean
    page?: boolean
    section?: boolean
    type?: boolean
    key?: boolean
    value?: boolean
    visible?: boolean
    created_at?: boolean
    updated_at?: boolean
  }


  export type $ContentPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Content"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      page: string
      section: string
      type: $Enums.ContentType
      key: string
      value: Prisma.JsonValue
      visible: boolean
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["content"]>
    composites: {}
  }

  type ContentGetPayload<S extends boolean | null | undefined | ContentDefaultArgs> = $Result.GetResult<Prisma.$ContentPayload, S>

  type ContentCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ContentFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: ContentCountAggregateInputType | true
    }

  export interface ContentDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Content'], meta: { name: 'Content' } }
    /**
     * Find zero or one Content that matches the filter.
     * @param {ContentFindUniqueArgs} args - Arguments to find a Content
     * @example
     * // Get one Content
     * const content = await prisma.content.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends ContentFindUniqueArgs>(args: SelectSubset<T, ContentFindUniqueArgs<ExtArgs>>): Prisma__ContentClient<$Result.GetResult<Prisma.$ContentPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one Content that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {ContentFindUniqueOrThrowArgs} args - Arguments to find a Content
     * @example
     * // Get one Content
     * const content = await prisma.content.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends ContentFindUniqueOrThrowArgs>(args: SelectSubset<T, ContentFindUniqueOrThrowArgs<ExtArgs>>): Prisma__ContentClient<$Result.GetResult<Prisma.$ContentPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first Content that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ContentFindFirstArgs} args - Arguments to find a Content
     * @example
     * // Get one Content
     * const content = await prisma.content.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends ContentFindFirstArgs>(args?: SelectSubset<T, ContentFindFirstArgs<ExtArgs>>): Prisma__ContentClient<$Result.GetResult<Prisma.$ContentPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Content 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 {ContentFindFirstOrThrowArgs} args - Arguments to find a Content
     * @example
     * // Get one Content
     * const content = await prisma.content.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends ContentFindFirstOrThrowArgs>(args?: SelectSubset<T, ContentFindFirstOrThrowArgs<ExtArgs>>): Prisma__ContentClient<$Result.GetResult<Prisma.$ContentPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Contents that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ContentFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Contents
     * const contents = await prisma.content.findMany()
     * 
     * // Get first 10 Contents
     * const contents = await prisma.content.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const contentWithIdOnly = await prisma.content.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends ContentFindManyArgs>(args?: SelectSubset<T, ContentFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ContentPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Content.
     * @param {ContentCreateArgs} args - Arguments to create a Content.
     * @example
     * // Create one Content
     * const Content = await prisma.content.create({
     *   data: {
     *     // ... data to create a Content
     *   }
     * })
     * 
     */
    create<T extends ContentCreateArgs>(args: SelectSubset<T, ContentCreateArgs<ExtArgs>>): Prisma__ContentClient<$Result.GetResult<Prisma.$ContentPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many Contents.
     * @param {ContentCreateManyArgs} args - Arguments to create many Contents.
     * @example
     * // Create many Contents
     * const content = await prisma.content.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends ContentCreateManyArgs>(args?: SelectSubset<T, ContentCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Content.
     * @param {ContentDeleteArgs} args - Arguments to delete one Content.
     * @example
     * // Delete one Content
     * const Content = await prisma.content.delete({
     *   where: {
     *     // ... filter to delete one Content
     *   }
     * })
     * 
     */
    delete<T extends ContentDeleteArgs>(args: SelectSubset<T, ContentDeleteArgs<ExtArgs>>): Prisma__ContentClient<$Result.GetResult<Prisma.$ContentPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Content.
     * @param {ContentUpdateArgs} args - Arguments to update one Content.
     * @example
     * // Update one Content
     * const content = await prisma.content.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends ContentUpdateArgs>(args: SelectSubset<T, ContentUpdateArgs<ExtArgs>>): Prisma__ContentClient<$Result.GetResult<Prisma.$ContentPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more Contents.
     * @param {ContentDeleteManyArgs} args - Arguments to filter Contents to delete.
     * @example
     * // Delete a few Contents
     * const { count } = await prisma.content.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends ContentDeleteManyArgs>(args?: SelectSubset<T, ContentDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Contents.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ContentUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Contents
     * const content = await prisma.content.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends ContentUpdateManyArgs>(args: SelectSubset<T, ContentUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Content.
     * @param {ContentUpsertArgs} args - Arguments to update or create a Content.
     * @example
     * // Update or create a Content
     * const content = await prisma.content.upsert({
     *   create: {
     *     // ... data to create a Content
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Content we want to update
     *   }
     * })
     */
    upsert<T extends ContentUpsertArgs>(args: SelectSubset<T, ContentUpsertArgs<ExtArgs>>): Prisma__ContentClient<$Result.GetResult<Prisma.$ContentPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of Contents.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ContentCountArgs} args - Arguments to filter Contents to count.
     * @example
     * // Count the number of Contents
     * const count = await prisma.content.count({
     *   where: {
     *     // ... the filter for the Contents we want to count
     *   }
     * })
    **/
    count<T extends ContentCountArgs>(
      args?: Subset<T, ContentCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], ContentCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Content.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ContentAggregateArgs} 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 ContentAggregateArgs>(args: Subset<T, ContentAggregateArgs>): Prisma.PrismaPromise<GetContentAggregateType<T>>

    /**
     * Group by Content.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ContentGroupByArgs} 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 ContentGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: ContentGroupByArgs['orderBy'] }
        : { orderBy?: ContentGroupByArgs['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, ContentGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetContentGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Content model
   */
  readonly fields: ContentFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Content.
   * 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__ContentClient<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 Content model
   */ 
  interface ContentFieldRefs {
    readonly id: FieldRef<"Content", 'String'>
    readonly page: FieldRef<"Content", 'String'>
    readonly section: FieldRef<"Content", 'String'>
    readonly type: FieldRef<"Content", 'ContentType'>
    readonly key: FieldRef<"Content", 'String'>
    readonly value: FieldRef<"Content", 'Json'>
    readonly visible: FieldRef<"Content", 'Boolean'>
    readonly created_at: FieldRef<"Content", 'DateTime'>
    readonly updated_at: FieldRef<"Content", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Content findUnique
   */
  export type ContentFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Content
     */
    select?: ContentSelect<ExtArgs> | null
    /**
     * Filter, which Content to fetch.
     */
    where: ContentWhereUniqueInput
  }

  /**
   * Content findUniqueOrThrow
   */
  export type ContentFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Content
     */
    select?: ContentSelect<ExtArgs> | null
    /**
     * Filter, which Content to fetch.
     */
    where: ContentWhereUniqueInput
  }

  /**
   * Content findFirst
   */
  export type ContentFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Content
     */
    select?: ContentSelect<ExtArgs> | null
    /**
     * Filter, which Content to fetch.
     */
    where?: ContentWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Contents to fetch.
     */
    orderBy?: ContentOrderByWithRelationInput | ContentOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Contents.
     */
    cursor?: ContentWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Contents from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Contents.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Contents.
     */
    distinct?: ContentScalarFieldEnum | ContentScalarFieldEnum[]
  }

  /**
   * Content findFirstOrThrow
   */
  export type ContentFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Content
     */
    select?: ContentSelect<ExtArgs> | null
    /**
     * Filter, which Content to fetch.
     */
    where?: ContentWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Contents to fetch.
     */
    orderBy?: ContentOrderByWithRelationInput | ContentOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Contents.
     */
    cursor?: ContentWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Contents from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Contents.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Contents.
     */
    distinct?: ContentScalarFieldEnum | ContentScalarFieldEnum[]
  }

  /**
   * Content findMany
   */
  export type ContentFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Content
     */
    select?: ContentSelect<ExtArgs> | null
    /**
     * Filter, which Contents to fetch.
     */
    where?: ContentWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Contents to fetch.
     */
    orderBy?: ContentOrderByWithRelationInput | ContentOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Contents.
     */
    cursor?: ContentWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Contents from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Contents.
     */
    skip?: number
    distinct?: ContentScalarFieldEnum | ContentScalarFieldEnum[]
  }

  /**
   * Content create
   */
  export type ContentCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Content
     */
    select?: ContentSelect<ExtArgs> | null
    /**
     * The data needed to create a Content.
     */
    data: XOR<ContentCreateInput, ContentUncheckedCreateInput>
  }

  /**
   * Content createMany
   */
  export type ContentCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Contents.
     */
    data: ContentCreateManyInput | ContentCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Content update
   */
  export type ContentUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Content
     */
    select?: ContentSelect<ExtArgs> | null
    /**
     * The data needed to update a Content.
     */
    data: XOR<ContentUpdateInput, ContentUncheckedUpdateInput>
    /**
     * Choose, which Content to update.
     */
    where: ContentWhereUniqueInput
  }

  /**
   * Content updateMany
   */
  export type ContentUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Contents.
     */
    data: XOR<ContentUpdateManyMutationInput, ContentUncheckedUpdateManyInput>
    /**
     * Filter which Contents to update
     */
    where?: ContentWhereInput
  }

  /**
   * Content upsert
   */
  export type ContentUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Content
     */
    select?: ContentSelect<ExtArgs> | null
    /**
     * The filter to search for the Content to update in case it exists.
     */
    where: ContentWhereUniqueInput
    /**
     * In case the Content found by the `where` argument doesn't exist, create a new Content with this data.
     */
    create: XOR<ContentCreateInput, ContentUncheckedCreateInput>
    /**
     * In case the Content was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ContentUpdateInput, ContentUncheckedUpdateInput>
  }

  /**
   * Content delete
   */
  export type ContentDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Content
     */
    select?: ContentSelect<ExtArgs> | null
    /**
     * Filter which Content to delete.
     */
    where: ContentWhereUniqueInput
  }

  /**
   * Content deleteMany
   */
  export type ContentDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Contents to delete
     */
    where?: ContentWhereInput
  }

  /**
   * Content without action
   */
  export type ContentDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Content
     */
    select?: ContentSelect<ExtArgs> | null
  }


  /**
   * Model MenuItem
   */

  export type AggregateMenuItem = {
    _count: MenuItemCountAggregateOutputType | null
    _min: MenuItemMinAggregateOutputType | null
    _max: MenuItemMaxAggregateOutputType | null
  }

  export type MenuItemMinAggregateOutputType = {
    id: string | null
    name: string | null
    url: string | null
    visible: boolean | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type MenuItemMaxAggregateOutputType = {
    id: string | null
    name: string | null
    url: string | null
    visible: boolean | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type MenuItemCountAggregateOutputType = {
    id: number
    name: number
    url: number
    visible: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type MenuItemMinAggregateInputType = {
    id?: true
    name?: true
    url?: true
    visible?: true
    created_at?: true
    updated_at?: true
  }

  export type MenuItemMaxAggregateInputType = {
    id?: true
    name?: true
    url?: true
    visible?: true
    created_at?: true
    updated_at?: true
  }

  export type MenuItemCountAggregateInputType = {
    id?: true
    name?: true
    url?: true
    visible?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type MenuItemAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which MenuItem to aggregate.
     */
    where?: MenuItemWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MenuItems to fetch.
     */
    orderBy?: MenuItemOrderByWithRelationInput | MenuItemOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: MenuItemWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MenuItems from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` MenuItems.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned MenuItems
    **/
    _count?: true | MenuItemCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: MenuItemMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: MenuItemMaxAggregateInputType
  }

  export type GetMenuItemAggregateType<T extends MenuItemAggregateArgs> = {
        [P in keyof T & keyof AggregateMenuItem]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateMenuItem[P]>
      : GetScalarType<T[P], AggregateMenuItem[P]>
  }




  export type MenuItemGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: MenuItemWhereInput
    orderBy?: MenuItemOrderByWithAggregationInput | MenuItemOrderByWithAggregationInput[]
    by: MenuItemScalarFieldEnum[] | MenuItemScalarFieldEnum
    having?: MenuItemScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: MenuItemCountAggregateInputType | true
    _min?: MenuItemMinAggregateInputType
    _max?: MenuItemMaxAggregateInputType
  }

  export type MenuItemGroupByOutputType = {
    id: string
    name: string
    url: string
    visible: boolean
    created_at: Date
    updated_at: Date
    _count: MenuItemCountAggregateOutputType | null
    _min: MenuItemMinAggregateOutputType | null
    _max: MenuItemMaxAggregateOutputType | null
  }

  type GetMenuItemGroupByPayload<T extends MenuItemGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<MenuItemGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof MenuItemGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], MenuItemGroupByOutputType[P]>
            : GetScalarType<T[P], MenuItemGroupByOutputType[P]>
        }
      >
    >


  export type MenuItemSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    url?: boolean
    visible?: boolean
    created_at?: boolean
    updated_at?: boolean
  }, ExtArgs["result"]["menuItem"]>


  export type MenuItemSelectScalar = {
    id?: boolean
    name?: boolean
    url?: boolean
    visible?: boolean
    created_at?: boolean
    updated_at?: boolean
  }


  export type $MenuItemPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "MenuItem"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      url: string
      visible: boolean
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["menuItem"]>
    composites: {}
  }

  type MenuItemGetPayload<S extends boolean | null | undefined | MenuItemDefaultArgs> = $Result.GetResult<Prisma.$MenuItemPayload, S>

  type MenuItemCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<MenuItemFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: MenuItemCountAggregateInputType | true
    }

  export interface MenuItemDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['MenuItem'], meta: { name: 'MenuItem' } }
    /**
     * Find zero or one MenuItem that matches the filter.
     * @param {MenuItemFindUniqueArgs} args - Arguments to find a MenuItem
     * @example
     * // Get one MenuItem
     * const menuItem = await prisma.menuItem.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends MenuItemFindUniqueArgs>(args: SelectSubset<T, MenuItemFindUniqueArgs<ExtArgs>>): Prisma__MenuItemClient<$Result.GetResult<Prisma.$MenuItemPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one MenuItem that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {MenuItemFindUniqueOrThrowArgs} args - Arguments to find a MenuItem
     * @example
     * // Get one MenuItem
     * const menuItem = await prisma.menuItem.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends MenuItemFindUniqueOrThrowArgs>(args: SelectSubset<T, MenuItemFindUniqueOrThrowArgs<ExtArgs>>): Prisma__MenuItemClient<$Result.GetResult<Prisma.$MenuItemPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first MenuItem that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MenuItemFindFirstArgs} args - Arguments to find a MenuItem
     * @example
     * // Get one MenuItem
     * const menuItem = await prisma.menuItem.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends MenuItemFindFirstArgs>(args?: SelectSubset<T, MenuItemFindFirstArgs<ExtArgs>>): Prisma__MenuItemClient<$Result.GetResult<Prisma.$MenuItemPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first MenuItem 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 {MenuItemFindFirstOrThrowArgs} args - Arguments to find a MenuItem
     * @example
     * // Get one MenuItem
     * const menuItem = await prisma.menuItem.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends MenuItemFindFirstOrThrowArgs>(args?: SelectSubset<T, MenuItemFindFirstOrThrowArgs<ExtArgs>>): Prisma__MenuItemClient<$Result.GetResult<Prisma.$MenuItemPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more MenuItems that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MenuItemFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all MenuItems
     * const menuItems = await prisma.menuItem.findMany()
     * 
     * // Get first 10 MenuItems
     * const menuItems = await prisma.menuItem.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const menuItemWithIdOnly = await prisma.menuItem.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends MenuItemFindManyArgs>(args?: SelectSubset<T, MenuItemFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$MenuItemPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a MenuItem.
     * @param {MenuItemCreateArgs} args - Arguments to create a MenuItem.
     * @example
     * // Create one MenuItem
     * const MenuItem = await prisma.menuItem.create({
     *   data: {
     *     // ... data to create a MenuItem
     *   }
     * })
     * 
     */
    create<T extends MenuItemCreateArgs>(args: SelectSubset<T, MenuItemCreateArgs<ExtArgs>>): Prisma__MenuItemClient<$Result.GetResult<Prisma.$MenuItemPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many MenuItems.
     * @param {MenuItemCreateManyArgs} args - Arguments to create many MenuItems.
     * @example
     * // Create many MenuItems
     * const menuItem = await prisma.menuItem.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends MenuItemCreateManyArgs>(args?: SelectSubset<T, MenuItemCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a MenuItem.
     * @param {MenuItemDeleteArgs} args - Arguments to delete one MenuItem.
     * @example
     * // Delete one MenuItem
     * const MenuItem = await prisma.menuItem.delete({
     *   where: {
     *     // ... filter to delete one MenuItem
     *   }
     * })
     * 
     */
    delete<T extends MenuItemDeleteArgs>(args: SelectSubset<T, MenuItemDeleteArgs<ExtArgs>>): Prisma__MenuItemClient<$Result.GetResult<Prisma.$MenuItemPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one MenuItem.
     * @param {MenuItemUpdateArgs} args - Arguments to update one MenuItem.
     * @example
     * // Update one MenuItem
     * const menuItem = await prisma.menuItem.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends MenuItemUpdateArgs>(args: SelectSubset<T, MenuItemUpdateArgs<ExtArgs>>): Prisma__MenuItemClient<$Result.GetResult<Prisma.$MenuItemPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more MenuItems.
     * @param {MenuItemDeleteManyArgs} args - Arguments to filter MenuItems to delete.
     * @example
     * // Delete a few MenuItems
     * const { count } = await prisma.menuItem.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends MenuItemDeleteManyArgs>(args?: SelectSubset<T, MenuItemDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more MenuItems.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MenuItemUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many MenuItems
     * const menuItem = await prisma.menuItem.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends MenuItemUpdateManyArgs>(args: SelectSubset<T, MenuItemUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one MenuItem.
     * @param {MenuItemUpsertArgs} args - Arguments to update or create a MenuItem.
     * @example
     * // Update or create a MenuItem
     * const menuItem = await prisma.menuItem.upsert({
     *   create: {
     *     // ... data to create a MenuItem
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the MenuItem we want to update
     *   }
     * })
     */
    upsert<T extends MenuItemUpsertArgs>(args: SelectSubset<T, MenuItemUpsertArgs<ExtArgs>>): Prisma__MenuItemClient<$Result.GetResult<Prisma.$MenuItemPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of MenuItems.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MenuItemCountArgs} args - Arguments to filter MenuItems to count.
     * @example
     * // Count the number of MenuItems
     * const count = await prisma.menuItem.count({
     *   where: {
     *     // ... the filter for the MenuItems we want to count
     *   }
     * })
    **/
    count<T extends MenuItemCountArgs>(
      args?: Subset<T, MenuItemCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], MenuItemCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a MenuItem.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MenuItemAggregateArgs} 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 MenuItemAggregateArgs>(args: Subset<T, MenuItemAggregateArgs>): Prisma.PrismaPromise<GetMenuItemAggregateType<T>>

    /**
     * Group by MenuItem.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {MenuItemGroupByArgs} 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 MenuItemGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: MenuItemGroupByArgs['orderBy'] }
        : { orderBy?: MenuItemGroupByArgs['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, MenuItemGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetMenuItemGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the MenuItem model
   */
  readonly fields: MenuItemFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for MenuItem.
   * 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__MenuItemClient<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 MenuItem model
   */ 
  interface MenuItemFieldRefs {
    readonly id: FieldRef<"MenuItem", 'String'>
    readonly name: FieldRef<"MenuItem", 'String'>
    readonly url: FieldRef<"MenuItem", 'String'>
    readonly visible: FieldRef<"MenuItem", 'Boolean'>
    readonly created_at: FieldRef<"MenuItem", 'DateTime'>
    readonly updated_at: FieldRef<"MenuItem", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * MenuItem findUnique
   */
  export type MenuItemFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MenuItem
     */
    select?: MenuItemSelect<ExtArgs> | null
    /**
     * Filter, which MenuItem to fetch.
     */
    where: MenuItemWhereUniqueInput
  }

  /**
   * MenuItem findUniqueOrThrow
   */
  export type MenuItemFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MenuItem
     */
    select?: MenuItemSelect<ExtArgs> | null
    /**
     * Filter, which MenuItem to fetch.
     */
    where: MenuItemWhereUniqueInput
  }

  /**
   * MenuItem findFirst
   */
  export type MenuItemFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MenuItem
     */
    select?: MenuItemSelect<ExtArgs> | null
    /**
     * Filter, which MenuItem to fetch.
     */
    where?: MenuItemWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MenuItems to fetch.
     */
    orderBy?: MenuItemOrderByWithRelationInput | MenuItemOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for MenuItems.
     */
    cursor?: MenuItemWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MenuItems from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` MenuItems.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of MenuItems.
     */
    distinct?: MenuItemScalarFieldEnum | MenuItemScalarFieldEnum[]
  }

  /**
   * MenuItem findFirstOrThrow
   */
  export type MenuItemFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MenuItem
     */
    select?: MenuItemSelect<ExtArgs> | null
    /**
     * Filter, which MenuItem to fetch.
     */
    where?: MenuItemWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MenuItems to fetch.
     */
    orderBy?: MenuItemOrderByWithRelationInput | MenuItemOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for MenuItems.
     */
    cursor?: MenuItemWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MenuItems from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` MenuItems.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of MenuItems.
     */
    distinct?: MenuItemScalarFieldEnum | MenuItemScalarFieldEnum[]
  }

  /**
   * MenuItem findMany
   */
  export type MenuItemFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MenuItem
     */
    select?: MenuItemSelect<ExtArgs> | null
    /**
     * Filter, which MenuItems to fetch.
     */
    where?: MenuItemWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of MenuItems to fetch.
     */
    orderBy?: MenuItemOrderByWithRelationInput | MenuItemOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing MenuItems.
     */
    cursor?: MenuItemWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` MenuItems from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` MenuItems.
     */
    skip?: number
    distinct?: MenuItemScalarFieldEnum | MenuItemScalarFieldEnum[]
  }

  /**
   * MenuItem create
   */
  export type MenuItemCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MenuItem
     */
    select?: MenuItemSelect<ExtArgs> | null
    /**
     * The data needed to create a MenuItem.
     */
    data: XOR<MenuItemCreateInput, MenuItemUncheckedCreateInput>
  }

  /**
   * MenuItem createMany
   */
  export type MenuItemCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many MenuItems.
     */
    data: MenuItemCreateManyInput | MenuItemCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * MenuItem update
   */
  export type MenuItemUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MenuItem
     */
    select?: MenuItemSelect<ExtArgs> | null
    /**
     * The data needed to update a MenuItem.
     */
    data: XOR<MenuItemUpdateInput, MenuItemUncheckedUpdateInput>
    /**
     * Choose, which MenuItem to update.
     */
    where: MenuItemWhereUniqueInput
  }

  /**
   * MenuItem updateMany
   */
  export type MenuItemUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update MenuItems.
     */
    data: XOR<MenuItemUpdateManyMutationInput, MenuItemUncheckedUpdateManyInput>
    /**
     * Filter which MenuItems to update
     */
    where?: MenuItemWhereInput
  }

  /**
   * MenuItem upsert
   */
  export type MenuItemUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MenuItem
     */
    select?: MenuItemSelect<ExtArgs> | null
    /**
     * The filter to search for the MenuItem to update in case it exists.
     */
    where: MenuItemWhereUniqueInput
    /**
     * In case the MenuItem found by the `where` argument doesn't exist, create a new MenuItem with this data.
     */
    create: XOR<MenuItemCreateInput, MenuItemUncheckedCreateInput>
    /**
     * In case the MenuItem was found with the provided `where` argument, update it with this data.
     */
    update: XOR<MenuItemUpdateInput, MenuItemUncheckedUpdateInput>
  }

  /**
   * MenuItem delete
   */
  export type MenuItemDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MenuItem
     */
    select?: MenuItemSelect<ExtArgs> | null
    /**
     * Filter which MenuItem to delete.
     */
    where: MenuItemWhereUniqueInput
  }

  /**
   * MenuItem deleteMany
   */
  export type MenuItemDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which MenuItems to delete
     */
    where?: MenuItemWhereInput
  }

  /**
   * MenuItem without action
   */
  export type MenuItemDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the MenuItem
     */
    select?: MenuItemSelect<ExtArgs> | null
  }


  /**
   * Model Footer
   */

  export type AggregateFooter = {
    _count: FooterCountAggregateOutputType | null
    _avg: FooterAvgAggregateOutputType | null
    _sum: FooterSumAggregateOutputType | null
    _min: FooterMinAggregateOutputType | null
    _max: FooterMaxAggregateOutputType | null
  }

  export type FooterAvgAggregateOutputType = {
    order: number | null
  }

  export type FooterSumAggregateOutputType = {
    order: number | null
  }

  export type FooterMinAggregateOutputType = {
    id: string | null
    name: string | null
    type: $Enums.FooterType | null
    visible: boolean | null
    order: number | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type FooterMaxAggregateOutputType = {
    id: string | null
    name: string | null
    type: $Enums.FooterType | null
    visible: boolean | null
    order: number | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type FooterCountAggregateOutputType = {
    id: number
    name: number
    type: number
    visible: number
    order: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type FooterAvgAggregateInputType = {
    order?: true
  }

  export type FooterSumAggregateInputType = {
    order?: true
  }

  export type FooterMinAggregateInputType = {
    id?: true
    name?: true
    type?: true
    visible?: true
    order?: true
    created_at?: true
    updated_at?: true
  }

  export type FooterMaxAggregateInputType = {
    id?: true
    name?: true
    type?: true
    visible?: true
    order?: true
    created_at?: true
    updated_at?: true
  }

  export type FooterCountAggregateInputType = {
    id?: true
    name?: true
    type?: true
    visible?: true
    order?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type FooterAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Footer to aggregate.
     */
    where?: FooterWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Footers to fetch.
     */
    orderBy?: FooterOrderByWithRelationInput | FooterOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: FooterWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Footers from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Footers.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Footers
    **/
    _count?: true | FooterCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: FooterAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: FooterSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: FooterMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: FooterMaxAggregateInputType
  }

  export type GetFooterAggregateType<T extends FooterAggregateArgs> = {
        [P in keyof T & keyof AggregateFooter]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateFooter[P]>
      : GetScalarType<T[P], AggregateFooter[P]>
  }




  export type FooterGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: FooterWhereInput
    orderBy?: FooterOrderByWithAggregationInput | FooterOrderByWithAggregationInput[]
    by: FooterScalarFieldEnum[] | FooterScalarFieldEnum
    having?: FooterScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: FooterCountAggregateInputType | true
    _avg?: FooterAvgAggregateInputType
    _sum?: FooterSumAggregateInputType
    _min?: FooterMinAggregateInputType
    _max?: FooterMaxAggregateInputType
  }

  export type FooterGroupByOutputType = {
    id: string
    name: string
    type: $Enums.FooterType
    visible: boolean
    order: number
    created_at: Date
    updated_at: Date
    _count: FooterCountAggregateOutputType | null
    _avg: FooterAvgAggregateOutputType | null
    _sum: FooterSumAggregateOutputType | null
    _min: FooterMinAggregateOutputType | null
    _max: FooterMaxAggregateOutputType | null
  }

  type GetFooterGroupByPayload<T extends FooterGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<FooterGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof FooterGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], FooterGroupByOutputType[P]>
            : GetScalarType<T[P], FooterGroupByOutputType[P]>
        }
      >
    >


  export type FooterSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    type?: boolean
    visible?: boolean
    order?: boolean
    created_at?: boolean
    updated_at?: boolean
    FooterItem?: boolean | Footer$FooterItemArgs<ExtArgs>
    _count?: boolean | FooterCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["footer"]>


  export type FooterSelectScalar = {
    id?: boolean
    name?: boolean
    type?: boolean
    visible?: boolean
    order?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type FooterInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    FooterItem?: boolean | Footer$FooterItemArgs<ExtArgs>
    _count?: boolean | FooterCountOutputTypeDefaultArgs<ExtArgs>
  }

  export type $FooterPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Footer"
    objects: {
      FooterItem: Prisma.$FooterItemPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      type: $Enums.FooterType
      visible: boolean
      order: number
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["footer"]>
    composites: {}
  }

  type FooterGetPayload<S extends boolean | null | undefined | FooterDefaultArgs> = $Result.GetResult<Prisma.$FooterPayload, S>

  type FooterCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<FooterFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: FooterCountAggregateInputType | true
    }

  export interface FooterDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Footer'], meta: { name: 'Footer' } }
    /**
     * Find zero or one Footer that matches the filter.
     * @param {FooterFindUniqueArgs} args - Arguments to find a Footer
     * @example
     * // Get one Footer
     * const footer = await prisma.footer.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends FooterFindUniqueArgs>(args: SelectSubset<T, FooterFindUniqueArgs<ExtArgs>>): Prisma__FooterClient<$Result.GetResult<Prisma.$FooterPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one Footer that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {FooterFindUniqueOrThrowArgs} args - Arguments to find a Footer
     * @example
     * // Get one Footer
     * const footer = await prisma.footer.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends FooterFindUniqueOrThrowArgs>(args: SelectSubset<T, FooterFindUniqueOrThrowArgs<ExtArgs>>): Prisma__FooterClient<$Result.GetResult<Prisma.$FooterPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first Footer that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FooterFindFirstArgs} args - Arguments to find a Footer
     * @example
     * // Get one Footer
     * const footer = await prisma.footer.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends FooterFindFirstArgs>(args?: SelectSubset<T, FooterFindFirstArgs<ExtArgs>>): Prisma__FooterClient<$Result.GetResult<Prisma.$FooterPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Footer 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 {FooterFindFirstOrThrowArgs} args - Arguments to find a Footer
     * @example
     * // Get one Footer
     * const footer = await prisma.footer.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends FooterFindFirstOrThrowArgs>(args?: SelectSubset<T, FooterFindFirstOrThrowArgs<ExtArgs>>): Prisma__FooterClient<$Result.GetResult<Prisma.$FooterPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Footers that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FooterFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Footers
     * const footers = await prisma.footer.findMany()
     * 
     * // Get first 10 Footers
     * const footers = await prisma.footer.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const footerWithIdOnly = await prisma.footer.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends FooterFindManyArgs>(args?: SelectSubset<T, FooterFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$FooterPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Footer.
     * @param {FooterCreateArgs} args - Arguments to create a Footer.
     * @example
     * // Create one Footer
     * const Footer = await prisma.footer.create({
     *   data: {
     *     // ... data to create a Footer
     *   }
     * })
     * 
     */
    create<T extends FooterCreateArgs>(args: SelectSubset<T, FooterCreateArgs<ExtArgs>>): Prisma__FooterClient<$Result.GetResult<Prisma.$FooterPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many Footers.
     * @param {FooterCreateManyArgs} args - Arguments to create many Footers.
     * @example
     * // Create many Footers
     * const footer = await prisma.footer.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends FooterCreateManyArgs>(args?: SelectSubset<T, FooterCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Footer.
     * @param {FooterDeleteArgs} args - Arguments to delete one Footer.
     * @example
     * // Delete one Footer
     * const Footer = await prisma.footer.delete({
     *   where: {
     *     // ... filter to delete one Footer
     *   }
     * })
     * 
     */
    delete<T extends FooterDeleteArgs>(args: SelectSubset<T, FooterDeleteArgs<ExtArgs>>): Prisma__FooterClient<$Result.GetResult<Prisma.$FooterPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Footer.
     * @param {FooterUpdateArgs} args - Arguments to update one Footer.
     * @example
     * // Update one Footer
     * const footer = await prisma.footer.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends FooterUpdateArgs>(args: SelectSubset<T, FooterUpdateArgs<ExtArgs>>): Prisma__FooterClient<$Result.GetResult<Prisma.$FooterPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more Footers.
     * @param {FooterDeleteManyArgs} args - Arguments to filter Footers to delete.
     * @example
     * // Delete a few Footers
     * const { count } = await prisma.footer.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends FooterDeleteManyArgs>(args?: SelectSubset<T, FooterDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Footers.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FooterUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Footers
     * const footer = await prisma.footer.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends FooterUpdateManyArgs>(args: SelectSubset<T, FooterUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Footer.
     * @param {FooterUpsertArgs} args - Arguments to update or create a Footer.
     * @example
     * // Update or create a Footer
     * const footer = await prisma.footer.upsert({
     *   create: {
     *     // ... data to create a Footer
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Footer we want to update
     *   }
     * })
     */
    upsert<T extends FooterUpsertArgs>(args: SelectSubset<T, FooterUpsertArgs<ExtArgs>>): Prisma__FooterClient<$Result.GetResult<Prisma.$FooterPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of Footers.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FooterCountArgs} args - Arguments to filter Footers to count.
     * @example
     * // Count the number of Footers
     * const count = await prisma.footer.count({
     *   where: {
     *     // ... the filter for the Footers we want to count
     *   }
     * })
    **/
    count<T extends FooterCountArgs>(
      args?: Subset<T, FooterCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], FooterCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Footer.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FooterAggregateArgs} 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 FooterAggregateArgs>(args: Subset<T, FooterAggregateArgs>): Prisma.PrismaPromise<GetFooterAggregateType<T>>

    /**
     * Group by Footer.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FooterGroupByArgs} 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 FooterGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: FooterGroupByArgs['orderBy'] }
        : { orderBy?: FooterGroupByArgs['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, FooterGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetFooterGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Footer model
   */
  readonly fields: FooterFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Footer.
   * 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__FooterClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    FooterItem<T extends Footer$FooterItemArgs<ExtArgs> = {}>(args?: Subset<T, Footer$FooterItemArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$FooterItemPayload<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 Footer model
   */ 
  interface FooterFieldRefs {
    readonly id: FieldRef<"Footer", 'String'>
    readonly name: FieldRef<"Footer", 'String'>
    readonly type: FieldRef<"Footer", 'FooterType'>
    readonly visible: FieldRef<"Footer", 'Boolean'>
    readonly order: FieldRef<"Footer", 'Int'>
    readonly created_at: FieldRef<"Footer", 'DateTime'>
    readonly updated_at: FieldRef<"Footer", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Footer findUnique
   */
  export type FooterFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Footer
     */
    select?: FooterSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FooterInclude<ExtArgs> | null
    /**
     * Filter, which Footer to fetch.
     */
    where: FooterWhereUniqueInput
  }

  /**
   * Footer findUniqueOrThrow
   */
  export type FooterFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Footer
     */
    select?: FooterSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FooterInclude<ExtArgs> | null
    /**
     * Filter, which Footer to fetch.
     */
    where: FooterWhereUniqueInput
  }

  /**
   * Footer findFirst
   */
  export type FooterFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Footer
     */
    select?: FooterSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FooterInclude<ExtArgs> | null
    /**
     * Filter, which Footer to fetch.
     */
    where?: FooterWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Footers to fetch.
     */
    orderBy?: FooterOrderByWithRelationInput | FooterOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Footers.
     */
    cursor?: FooterWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Footers from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Footers.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Footers.
     */
    distinct?: FooterScalarFieldEnum | FooterScalarFieldEnum[]
  }

  /**
   * Footer findFirstOrThrow
   */
  export type FooterFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Footer
     */
    select?: FooterSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FooterInclude<ExtArgs> | null
    /**
     * Filter, which Footer to fetch.
     */
    where?: FooterWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Footers to fetch.
     */
    orderBy?: FooterOrderByWithRelationInput | FooterOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Footers.
     */
    cursor?: FooterWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Footers from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Footers.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Footers.
     */
    distinct?: FooterScalarFieldEnum | FooterScalarFieldEnum[]
  }

  /**
   * Footer findMany
   */
  export type FooterFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Footer
     */
    select?: FooterSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FooterInclude<ExtArgs> | null
    /**
     * Filter, which Footers to fetch.
     */
    where?: FooterWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Footers to fetch.
     */
    orderBy?: FooterOrderByWithRelationInput | FooterOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Footers.
     */
    cursor?: FooterWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Footers from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Footers.
     */
    skip?: number
    distinct?: FooterScalarFieldEnum | FooterScalarFieldEnum[]
  }

  /**
   * Footer create
   */
  export type FooterCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Footer
     */
    select?: FooterSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FooterInclude<ExtArgs> | null
    /**
     * The data needed to create a Footer.
     */
    data: XOR<FooterCreateInput, FooterUncheckedCreateInput>
  }

  /**
   * Footer createMany
   */
  export type FooterCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Footers.
     */
    data: FooterCreateManyInput | FooterCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Footer update
   */
  export type FooterUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Footer
     */
    select?: FooterSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FooterInclude<ExtArgs> | null
    /**
     * The data needed to update a Footer.
     */
    data: XOR<FooterUpdateInput, FooterUncheckedUpdateInput>
    /**
     * Choose, which Footer to update.
     */
    where: FooterWhereUniqueInput
  }

  /**
   * Footer updateMany
   */
  export type FooterUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Footers.
     */
    data: XOR<FooterUpdateManyMutationInput, FooterUncheckedUpdateManyInput>
    /**
     * Filter which Footers to update
     */
    where?: FooterWhereInput
  }

  /**
   * Footer upsert
   */
  export type FooterUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Footer
     */
    select?: FooterSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FooterInclude<ExtArgs> | null
    /**
     * The filter to search for the Footer to update in case it exists.
     */
    where: FooterWhereUniqueInput
    /**
     * In case the Footer found by the `where` argument doesn't exist, create a new Footer with this data.
     */
    create: XOR<FooterCreateInput, FooterUncheckedCreateInput>
    /**
     * In case the Footer was found with the provided `where` argument, update it with this data.
     */
    update: XOR<FooterUpdateInput, FooterUncheckedUpdateInput>
  }

  /**
   * Footer delete
   */
  export type FooterDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Footer
     */
    select?: FooterSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FooterInclude<ExtArgs> | null
    /**
     * Filter which Footer to delete.
     */
    where: FooterWhereUniqueInput
  }

  /**
   * Footer deleteMany
   */
  export type FooterDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Footers to delete
     */
    where?: FooterWhereInput
  }

  /**
   * Footer.FooterItem
   */
  export type Footer$FooterItemArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FooterItem
     */
    select?: FooterItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FooterItemInclude<ExtArgs> | null
    where?: FooterItemWhereInput
    orderBy?: FooterItemOrderByWithRelationInput | FooterItemOrderByWithRelationInput[]
    cursor?: FooterItemWhereUniqueInput
    take?: number
    skip?: number
    distinct?: FooterItemScalarFieldEnum | FooterItemScalarFieldEnum[]
  }

  /**
   * Footer without action
   */
  export type FooterDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Footer
     */
    select?: FooterSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FooterInclude<ExtArgs> | null
  }


  /**
   * Model FooterItem
   */

  export type AggregateFooterItem = {
    _count: FooterItemCountAggregateOutputType | null
    _min: FooterItemMinAggregateOutputType | null
    _max: FooterItemMaxAggregateOutputType | null
  }

  export type FooterItemMinAggregateOutputType = {
    id: string | null
    footer_id: string | null
    name: string | null
    url: string | null
    visible: boolean | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type FooterItemMaxAggregateOutputType = {
    id: string | null
    footer_id: string | null
    name: string | null
    url: string | null
    visible: boolean | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type FooterItemCountAggregateOutputType = {
    id: number
    footer_id: number
    name: number
    url: number
    visible: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type FooterItemMinAggregateInputType = {
    id?: true
    footer_id?: true
    name?: true
    url?: true
    visible?: true
    created_at?: true
    updated_at?: true
  }

  export type FooterItemMaxAggregateInputType = {
    id?: true
    footer_id?: true
    name?: true
    url?: true
    visible?: true
    created_at?: true
    updated_at?: true
  }

  export type FooterItemCountAggregateInputType = {
    id?: true
    footer_id?: true
    name?: true
    url?: true
    visible?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type FooterItemAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which FooterItem to aggregate.
     */
    where?: FooterItemWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of FooterItems to fetch.
     */
    orderBy?: FooterItemOrderByWithRelationInput | FooterItemOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: FooterItemWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` FooterItems from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` FooterItems.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned FooterItems
    **/
    _count?: true | FooterItemCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: FooterItemMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: FooterItemMaxAggregateInputType
  }

  export type GetFooterItemAggregateType<T extends FooterItemAggregateArgs> = {
        [P in keyof T & keyof AggregateFooterItem]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateFooterItem[P]>
      : GetScalarType<T[P], AggregateFooterItem[P]>
  }




  export type FooterItemGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: FooterItemWhereInput
    orderBy?: FooterItemOrderByWithAggregationInput | FooterItemOrderByWithAggregationInput[]
    by: FooterItemScalarFieldEnum[] | FooterItemScalarFieldEnum
    having?: FooterItemScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: FooterItemCountAggregateInputType | true
    _min?: FooterItemMinAggregateInputType
    _max?: FooterItemMaxAggregateInputType
  }

  export type FooterItemGroupByOutputType = {
    id: string
    footer_id: string
    name: string
    url: string
    visible: boolean
    created_at: Date
    updated_at: Date
    _count: FooterItemCountAggregateOutputType | null
    _min: FooterItemMinAggregateOutputType | null
    _max: FooterItemMaxAggregateOutputType | null
  }

  type GetFooterItemGroupByPayload<T extends FooterItemGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<FooterItemGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof FooterItemGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], FooterItemGroupByOutputType[P]>
            : GetScalarType<T[P], FooterItemGroupByOutputType[P]>
        }
      >
    >


  export type FooterItemSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    footer_id?: boolean
    name?: boolean
    url?: boolean
    visible?: boolean
    created_at?: boolean
    updated_at?: boolean
    Footer?: boolean | FooterDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["footerItem"]>


  export type FooterItemSelectScalar = {
    id?: boolean
    footer_id?: boolean
    name?: boolean
    url?: boolean
    visible?: boolean
    created_at?: boolean
    updated_at?: boolean
  }

  export type FooterItemInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    Footer?: boolean | FooterDefaultArgs<ExtArgs>
  }

  export type $FooterItemPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "FooterItem"
    objects: {
      Footer: Prisma.$FooterPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      footer_id: string
      name: string
      url: string
      visible: boolean
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["footerItem"]>
    composites: {}
  }

  type FooterItemGetPayload<S extends boolean | null | undefined | FooterItemDefaultArgs> = $Result.GetResult<Prisma.$FooterItemPayload, S>

  type FooterItemCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<FooterItemFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: FooterItemCountAggregateInputType | true
    }

  export interface FooterItemDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['FooterItem'], meta: { name: 'FooterItem' } }
    /**
     * Find zero or one FooterItem that matches the filter.
     * @param {FooterItemFindUniqueArgs} args - Arguments to find a FooterItem
     * @example
     * // Get one FooterItem
     * const footerItem = await prisma.footerItem.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends FooterItemFindUniqueArgs>(args: SelectSubset<T, FooterItemFindUniqueArgs<ExtArgs>>): Prisma__FooterItemClient<$Result.GetResult<Prisma.$FooterItemPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one FooterItem that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {FooterItemFindUniqueOrThrowArgs} args - Arguments to find a FooterItem
     * @example
     * // Get one FooterItem
     * const footerItem = await prisma.footerItem.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends FooterItemFindUniqueOrThrowArgs>(args: SelectSubset<T, FooterItemFindUniqueOrThrowArgs<ExtArgs>>): Prisma__FooterItemClient<$Result.GetResult<Prisma.$FooterItemPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first FooterItem that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FooterItemFindFirstArgs} args - Arguments to find a FooterItem
     * @example
     * // Get one FooterItem
     * const footerItem = await prisma.footerItem.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends FooterItemFindFirstArgs>(args?: SelectSubset<T, FooterItemFindFirstArgs<ExtArgs>>): Prisma__FooterItemClient<$Result.GetResult<Prisma.$FooterItemPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first FooterItem 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 {FooterItemFindFirstOrThrowArgs} args - Arguments to find a FooterItem
     * @example
     * // Get one FooterItem
     * const footerItem = await prisma.footerItem.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends FooterItemFindFirstOrThrowArgs>(args?: SelectSubset<T, FooterItemFindFirstOrThrowArgs<ExtArgs>>): Prisma__FooterItemClient<$Result.GetResult<Prisma.$FooterItemPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more FooterItems that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FooterItemFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all FooterItems
     * const footerItems = await prisma.footerItem.findMany()
     * 
     * // Get first 10 FooterItems
     * const footerItems = await prisma.footerItem.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const footerItemWithIdOnly = await prisma.footerItem.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends FooterItemFindManyArgs>(args?: SelectSubset<T, FooterItemFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$FooterItemPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a FooterItem.
     * @param {FooterItemCreateArgs} args - Arguments to create a FooterItem.
     * @example
     * // Create one FooterItem
     * const FooterItem = await prisma.footerItem.create({
     *   data: {
     *     // ... data to create a FooterItem
     *   }
     * })
     * 
     */
    create<T extends FooterItemCreateArgs>(args: SelectSubset<T, FooterItemCreateArgs<ExtArgs>>): Prisma__FooterItemClient<$Result.GetResult<Prisma.$FooterItemPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many FooterItems.
     * @param {FooterItemCreateManyArgs} args - Arguments to create many FooterItems.
     * @example
     * // Create many FooterItems
     * const footerItem = await prisma.footerItem.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends FooterItemCreateManyArgs>(args?: SelectSubset<T, FooterItemCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a FooterItem.
     * @param {FooterItemDeleteArgs} args - Arguments to delete one FooterItem.
     * @example
     * // Delete one FooterItem
     * const FooterItem = await prisma.footerItem.delete({
     *   where: {
     *     // ... filter to delete one FooterItem
     *   }
     * })
     * 
     */
    delete<T extends FooterItemDeleteArgs>(args: SelectSubset<T, FooterItemDeleteArgs<ExtArgs>>): Prisma__FooterItemClient<$Result.GetResult<Prisma.$FooterItemPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one FooterItem.
     * @param {FooterItemUpdateArgs} args - Arguments to update one FooterItem.
     * @example
     * // Update one FooterItem
     * const footerItem = await prisma.footerItem.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends FooterItemUpdateArgs>(args: SelectSubset<T, FooterItemUpdateArgs<ExtArgs>>): Prisma__FooterItemClient<$Result.GetResult<Prisma.$FooterItemPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more FooterItems.
     * @param {FooterItemDeleteManyArgs} args - Arguments to filter FooterItems to delete.
     * @example
     * // Delete a few FooterItems
     * const { count } = await prisma.footerItem.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends FooterItemDeleteManyArgs>(args?: SelectSubset<T, FooterItemDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more FooterItems.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FooterItemUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many FooterItems
     * const footerItem = await prisma.footerItem.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends FooterItemUpdateManyArgs>(args: SelectSubset<T, FooterItemUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one FooterItem.
     * @param {FooterItemUpsertArgs} args - Arguments to update or create a FooterItem.
     * @example
     * // Update or create a FooterItem
     * const footerItem = await prisma.footerItem.upsert({
     *   create: {
     *     // ... data to create a FooterItem
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the FooterItem we want to update
     *   }
     * })
     */
    upsert<T extends FooterItemUpsertArgs>(args: SelectSubset<T, FooterItemUpsertArgs<ExtArgs>>): Prisma__FooterItemClient<$Result.GetResult<Prisma.$FooterItemPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of FooterItems.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FooterItemCountArgs} args - Arguments to filter FooterItems to count.
     * @example
     * // Count the number of FooterItems
     * const count = await prisma.footerItem.count({
     *   where: {
     *     // ... the filter for the FooterItems we want to count
     *   }
     * })
    **/
    count<T extends FooterItemCountArgs>(
      args?: Subset<T, FooterItemCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], FooterItemCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a FooterItem.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FooterItemAggregateArgs} 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 FooterItemAggregateArgs>(args: Subset<T, FooterItemAggregateArgs>): Prisma.PrismaPromise<GetFooterItemAggregateType<T>>

    /**
     * Group by FooterItem.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {FooterItemGroupByArgs} 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 FooterItemGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: FooterItemGroupByArgs['orderBy'] }
        : { orderBy?: FooterItemGroupByArgs['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, FooterItemGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetFooterItemGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the FooterItem model
   */
  readonly fields: FooterItemFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for FooterItem.
   * 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__FooterItemClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    Footer<T extends FooterDefaultArgs<ExtArgs> = {}>(args?: Subset<T, FooterDefaultArgs<ExtArgs>>): Prisma__FooterClient<$Result.GetResult<Prisma.$FooterPayload<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 FooterItem model
   */ 
  interface FooterItemFieldRefs {
    readonly id: FieldRef<"FooterItem", 'String'>
    readonly footer_id: FieldRef<"FooterItem", 'String'>
    readonly name: FieldRef<"FooterItem", 'String'>
    readonly url: FieldRef<"FooterItem", 'String'>
    readonly visible: FieldRef<"FooterItem", 'Boolean'>
    readonly created_at: FieldRef<"FooterItem", 'DateTime'>
    readonly updated_at: FieldRef<"FooterItem", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * FooterItem findUnique
   */
  export type FooterItemFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FooterItem
     */
    select?: FooterItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FooterItemInclude<ExtArgs> | null
    /**
     * Filter, which FooterItem to fetch.
     */
    where: FooterItemWhereUniqueInput
  }

  /**
   * FooterItem findUniqueOrThrow
   */
  export type FooterItemFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FooterItem
     */
    select?: FooterItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FooterItemInclude<ExtArgs> | null
    /**
     * Filter, which FooterItem to fetch.
     */
    where: FooterItemWhereUniqueInput
  }

  /**
   * FooterItem findFirst
   */
  export type FooterItemFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FooterItem
     */
    select?: FooterItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FooterItemInclude<ExtArgs> | null
    /**
     * Filter, which FooterItem to fetch.
     */
    where?: FooterItemWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of FooterItems to fetch.
     */
    orderBy?: FooterItemOrderByWithRelationInput | FooterItemOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for FooterItems.
     */
    cursor?: FooterItemWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` FooterItems from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` FooterItems.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of FooterItems.
     */
    distinct?: FooterItemScalarFieldEnum | FooterItemScalarFieldEnum[]
  }

  /**
   * FooterItem findFirstOrThrow
   */
  export type FooterItemFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FooterItem
     */
    select?: FooterItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FooterItemInclude<ExtArgs> | null
    /**
     * Filter, which FooterItem to fetch.
     */
    where?: FooterItemWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of FooterItems to fetch.
     */
    orderBy?: FooterItemOrderByWithRelationInput | FooterItemOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for FooterItems.
     */
    cursor?: FooterItemWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` FooterItems from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` FooterItems.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of FooterItems.
     */
    distinct?: FooterItemScalarFieldEnum | FooterItemScalarFieldEnum[]
  }

  /**
   * FooterItem findMany
   */
  export type FooterItemFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FooterItem
     */
    select?: FooterItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FooterItemInclude<ExtArgs> | null
    /**
     * Filter, which FooterItems to fetch.
     */
    where?: FooterItemWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of FooterItems to fetch.
     */
    orderBy?: FooterItemOrderByWithRelationInput | FooterItemOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing FooterItems.
     */
    cursor?: FooterItemWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` FooterItems from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` FooterItems.
     */
    skip?: number
    distinct?: FooterItemScalarFieldEnum | FooterItemScalarFieldEnum[]
  }

  /**
   * FooterItem create
   */
  export type FooterItemCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FooterItem
     */
    select?: FooterItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FooterItemInclude<ExtArgs> | null
    /**
     * The data needed to create a FooterItem.
     */
    data: XOR<FooterItemCreateInput, FooterItemUncheckedCreateInput>
  }

  /**
   * FooterItem createMany
   */
  export type FooterItemCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many FooterItems.
     */
    data: FooterItemCreateManyInput | FooterItemCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * FooterItem update
   */
  export type FooterItemUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FooterItem
     */
    select?: FooterItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FooterItemInclude<ExtArgs> | null
    /**
     * The data needed to update a FooterItem.
     */
    data: XOR<FooterItemUpdateInput, FooterItemUncheckedUpdateInput>
    /**
     * Choose, which FooterItem to update.
     */
    where: FooterItemWhereUniqueInput
  }

  /**
   * FooterItem updateMany
   */
  export type FooterItemUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update FooterItems.
     */
    data: XOR<FooterItemUpdateManyMutationInput, FooterItemUncheckedUpdateManyInput>
    /**
     * Filter which FooterItems to update
     */
    where?: FooterItemWhereInput
  }

  /**
   * FooterItem upsert
   */
  export type FooterItemUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FooterItem
     */
    select?: FooterItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FooterItemInclude<ExtArgs> | null
    /**
     * The filter to search for the FooterItem to update in case it exists.
     */
    where: FooterItemWhereUniqueInput
    /**
     * In case the FooterItem found by the `where` argument doesn't exist, create a new FooterItem with this data.
     */
    create: XOR<FooterItemCreateInput, FooterItemUncheckedCreateInput>
    /**
     * In case the FooterItem was found with the provided `where` argument, update it with this data.
     */
    update: XOR<FooterItemUpdateInput, FooterItemUncheckedUpdateInput>
  }

  /**
   * FooterItem delete
   */
  export type FooterItemDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FooterItem
     */
    select?: FooterItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FooterItemInclude<ExtArgs> | null
    /**
     * Filter which FooterItem to delete.
     */
    where: FooterItemWhereUniqueInput
  }

  /**
   * FooterItem deleteMany
   */
  export type FooterItemDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which FooterItems to delete
     */
    where?: FooterItemWhereInput
  }

  /**
   * FooterItem without action
   */
  export type FooterItemDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the FooterItem
     */
    select?: FooterItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: FooterItemInclude<ExtArgs> | null
  }


  /**
   * Model Color
   */

  export type AggregateColor = {
    _count: ColorCountAggregateOutputType | null
    _min: ColorMinAggregateOutputType | null
    _max: ColorMaxAggregateOutputType | null
  }

  export type ColorMinAggregateOutputType = {
    id: string | null
    name: string | null
    hex: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type ColorMaxAggregateOutputType = {
    id: string | null
    name: string | null
    hex: string | null
    created_at: Date | null
    updated_at: Date | null
  }

  export type ColorCountAggregateOutputType = {
    id: number
    name: number
    hex: number
    created_at: number
    updated_at: number
    _all: number
  }


  export type ColorMinAggregateInputType = {
    id?: true
    name?: true
    hex?: true
    created_at?: true
    updated_at?: true
  }

  export type ColorMaxAggregateInputType = {
    id?: true
    name?: true
    hex?: true
    created_at?: true
    updated_at?: true
  }

  export type ColorCountAggregateInputType = {
    id?: true
    name?: true
    hex?: true
    created_at?: true
    updated_at?: true
    _all?: true
  }

  export type ColorAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Color to aggregate.
     */
    where?: ColorWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Colors to fetch.
     */
    orderBy?: ColorOrderByWithRelationInput | ColorOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ColorWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Colors from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Colors.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Colors
    **/
    _count?: true | ColorCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ColorMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ColorMaxAggregateInputType
  }

  export type GetColorAggregateType<T extends ColorAggregateArgs> = {
        [P in keyof T & keyof AggregateColor]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateColor[P]>
      : GetScalarType<T[P], AggregateColor[P]>
  }




  export type ColorGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ColorWhereInput
    orderBy?: ColorOrderByWithAggregationInput | ColorOrderByWithAggregationInput[]
    by: ColorScalarFieldEnum[] | ColorScalarFieldEnum
    having?: ColorScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ColorCountAggregateInputType | true
    _min?: ColorMinAggregateInputType
    _max?: ColorMaxAggregateInputType
  }

  export type ColorGroupByOutputType = {
    id: string
    name: string
    hex: string
    created_at: Date
    updated_at: Date
    _count: ColorCountAggregateOutputType | null
    _min: ColorMinAggregateOutputType | null
    _max: ColorMaxAggregateOutputType | null
  }

  type GetColorGroupByPayload<T extends ColorGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<ColorGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof ColorGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], ColorGroupByOutputType[P]>
            : GetScalarType<T[P], ColorGroupByOutputType[P]>
        }
      >
    >


  export type ColorSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    hex?: boolean
    created_at?: boolean
    updated_at?: boolean
  }, ExtArgs["result"]["color"]>


  export type ColorSelectScalar = {
    id?: boolean
    name?: boolean
    hex?: boolean
    created_at?: boolean
    updated_at?: boolean
  }


  export type $ColorPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Color"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      hex: string
      created_at: Date
      updated_at: Date
    }, ExtArgs["result"]["color"]>
    composites: {}
  }

  type ColorGetPayload<S extends boolean | null | undefined | ColorDefaultArgs> = $Result.GetResult<Prisma.$ColorPayload, S>

  type ColorCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<ColorFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: ColorCountAggregateInputType | true
    }

  export interface ColorDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Color'], meta: { name: 'Color' } }
    /**
     * Find zero or one Color that matches the filter.
     * @param {ColorFindUniqueArgs} args - Arguments to find a Color
     * @example
     * // Get one Color
     * const color = await prisma.color.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends ColorFindUniqueArgs>(args: SelectSubset<T, ColorFindUniqueArgs<ExtArgs>>): Prisma__ColorClient<$Result.GetResult<Prisma.$ColorPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one Color that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {ColorFindUniqueOrThrowArgs} args - Arguments to find a Color
     * @example
     * // Get one Color
     * const color = await prisma.color.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends ColorFindUniqueOrThrowArgs>(args: SelectSubset<T, ColorFindUniqueOrThrowArgs<ExtArgs>>): Prisma__ColorClient<$Result.GetResult<Prisma.$ColorPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first Color that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ColorFindFirstArgs} args - Arguments to find a Color
     * @example
     * // Get one Color
     * const color = await prisma.color.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends ColorFindFirstArgs>(args?: SelectSubset<T, ColorFindFirstArgs<ExtArgs>>): Prisma__ColorClient<$Result.GetResult<Prisma.$ColorPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Color 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 {ColorFindFirstOrThrowArgs} args - Arguments to find a Color
     * @example
     * // Get one Color
     * const color = await prisma.color.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends ColorFindFirstOrThrowArgs>(args?: SelectSubset<T, ColorFindFirstOrThrowArgs<ExtArgs>>): Prisma__ColorClient<$Result.GetResult<Prisma.$ColorPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Colors that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ColorFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Colors
     * const colors = await prisma.color.findMany()
     * 
     * // Get first 10 Colors
     * const colors = await prisma.color.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const colorWithIdOnly = await prisma.color.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends ColorFindManyArgs>(args?: SelectSubset<T, ColorFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ColorPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Color.
     * @param {ColorCreateArgs} args - Arguments to create a Color.
     * @example
     * // Create one Color
     * const Color = await prisma.color.create({
     *   data: {
     *     // ... data to create a Color
     *   }
     * })
     * 
     */
    create<T extends ColorCreateArgs>(args: SelectSubset<T, ColorCreateArgs<ExtArgs>>): Prisma__ColorClient<$Result.GetResult<Prisma.$ColorPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many Colors.
     * @param {ColorCreateManyArgs} args - Arguments to create many Colors.
     * @example
     * // Create many Colors
     * const color = await prisma.color.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends ColorCreateManyArgs>(args?: SelectSubset<T, ColorCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Delete a Color.
     * @param {ColorDeleteArgs} args - Arguments to delete one Color.
     * @example
     * // Delete one Color
     * const Color = await prisma.color.delete({
     *   where: {
     *     // ... filter to delete one Color
     *   }
     * })
     * 
     */
    delete<T extends ColorDeleteArgs>(args: SelectSubset<T, ColorDeleteArgs<ExtArgs>>): Prisma__ColorClient<$Result.GetResult<Prisma.$ColorPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Color.
     * @param {ColorUpdateArgs} args - Arguments to update one Color.
     * @example
     * // Update one Color
     * const color = await prisma.color.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends ColorUpdateArgs>(args: SelectSubset<T, ColorUpdateArgs<ExtArgs>>): Prisma__ColorClient<$Result.GetResult<Prisma.$ColorPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more Colors.
     * @param {ColorDeleteManyArgs} args - Arguments to filter Colors to delete.
     * @example
     * // Delete a few Colors
     * const { count } = await prisma.color.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends ColorDeleteManyArgs>(args?: SelectSubset<T, ColorDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Colors.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ColorUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Colors
     * const color = await prisma.color.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends ColorUpdateManyArgs>(args: SelectSubset<T, ColorUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Color.
     * @param {ColorUpsertArgs} args - Arguments to update or create a Color.
     * @example
     * // Update or create a Color
     * const color = await prisma.color.upsert({
     *   create: {
     *     // ... data to create a Color
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Color we want to update
     *   }
     * })
     */
    upsert<T extends ColorUpsertArgs>(args: SelectSubset<T, ColorUpsertArgs<ExtArgs>>): Prisma__ColorClient<$Result.GetResult<Prisma.$ColorPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of Colors.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ColorCountArgs} args - Arguments to filter Colors to count.
     * @example
     * // Count the number of Colors
     * const count = await prisma.color.count({
     *   where: {
     *     // ... the filter for the Colors we want to count
     *   }
     * })
    **/
    count<T extends ColorCountArgs>(
      args?: Subset<T, ColorCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], ColorCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Color.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ColorAggregateArgs} 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 ColorAggregateArgs>(args: Subset<T, ColorAggregateArgs>): Prisma.PrismaPromise<GetColorAggregateType<T>>

    /**
     * Group by Color.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {ColorGroupByArgs} 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 ColorGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: ColorGroupByArgs['orderBy'] }
        : { orderBy?: ColorGroupByArgs['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, ColorGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetColorGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Color model
   */
  readonly fields: ColorFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Color.
   * 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__ColorClient<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 Color model
   */ 
  interface ColorFieldRefs {
    readonly id: FieldRef<"Color", 'String'>
    readonly name: FieldRef<"Color", 'String'>
    readonly hex: FieldRef<"Color", 'String'>
    readonly created_at: FieldRef<"Color", 'DateTime'>
    readonly updated_at: FieldRef<"Color", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Color findUnique
   */
  export type ColorFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Color
     */
    select?: ColorSelect<ExtArgs> | null
    /**
     * Filter, which Color to fetch.
     */
    where: ColorWhereUniqueInput
  }

  /**
   * Color findUniqueOrThrow
   */
  export type ColorFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Color
     */
    select?: ColorSelect<ExtArgs> | null
    /**
     * Filter, which Color to fetch.
     */
    where: ColorWhereUniqueInput
  }

  /**
   * Color findFirst
   */
  export type ColorFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Color
     */
    select?: ColorSelect<ExtArgs> | null
    /**
     * Filter, which Color to fetch.
     */
    where?: ColorWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Colors to fetch.
     */
    orderBy?: ColorOrderByWithRelationInput | ColorOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Colors.
     */
    cursor?: ColorWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Colors from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Colors.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Colors.
     */
    distinct?: ColorScalarFieldEnum | ColorScalarFieldEnum[]
  }

  /**
   * Color findFirstOrThrow
   */
  export type ColorFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Color
     */
    select?: ColorSelect<ExtArgs> | null
    /**
     * Filter, which Color to fetch.
     */
    where?: ColorWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Colors to fetch.
     */
    orderBy?: ColorOrderByWithRelationInput | ColorOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Colors.
     */
    cursor?: ColorWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Colors from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Colors.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Colors.
     */
    distinct?: ColorScalarFieldEnum | ColorScalarFieldEnum[]
  }

  /**
   * Color findMany
   */
  export type ColorFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Color
     */
    select?: ColorSelect<ExtArgs> | null
    /**
     * Filter, which Colors to fetch.
     */
    where?: ColorWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Colors to fetch.
     */
    orderBy?: ColorOrderByWithRelationInput | ColorOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Colors.
     */
    cursor?: ColorWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Colors from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Colors.
     */
    skip?: number
    distinct?: ColorScalarFieldEnum | ColorScalarFieldEnum[]
  }

  /**
   * Color create
   */
  export type ColorCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Color
     */
    select?: ColorSelect<ExtArgs> | null
    /**
     * The data needed to create a Color.
     */
    data: XOR<ColorCreateInput, ColorUncheckedCreateInput>
  }

  /**
   * Color createMany
   */
  export type ColorCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Colors.
     */
    data: ColorCreateManyInput | ColorCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Color update
   */
  export type ColorUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Color
     */
    select?: ColorSelect<ExtArgs> | null
    /**
     * The data needed to update a Color.
     */
    data: XOR<ColorUpdateInput, ColorUncheckedUpdateInput>
    /**
     * Choose, which Color to update.
     */
    where: ColorWhereUniqueInput
  }

  /**
   * Color updateMany
   */
  export type ColorUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Colors.
     */
    data: XOR<ColorUpdateManyMutationInput, ColorUncheckedUpdateManyInput>
    /**
     * Filter which Colors to update
     */
    where?: ColorWhereInput
  }

  /**
   * Color upsert
   */
  export type ColorUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Color
     */
    select?: ColorSelect<ExtArgs> | null
    /**
     * The filter to search for the Color to update in case it exists.
     */
    where: ColorWhereUniqueInput
    /**
     * In case the Color found by the `where` argument doesn't exist, create a new Color with this data.
     */
    create: XOR<ColorCreateInput, ColorUncheckedCreateInput>
    /**
     * In case the Color was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ColorUpdateInput, ColorUncheckedUpdateInput>
  }

  /**
   * Color delete
   */
  export type ColorDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Color
     */
    select?: ColorSelect<ExtArgs> | null
    /**
     * Filter which Color to delete.
     */
    where: ColorWhereUniqueInput
  }

  /**
   * Color deleteMany
   */
  export type ColorDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Colors to delete
     */
    where?: ColorWhereInput
  }

  /**
   * Color without action
   */
  export type ColorDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Color
     */
    select?: ColorSelect<ExtArgs> | null
  }


  /**
   * Enums
   */

  export const TransactionIsolationLevel: {
    ReadUncommitted: 'ReadUncommitted',
    ReadCommitted: 'ReadCommitted',
    RepeatableRead: 'RepeatableRead',
    Serializable: 'Serializable'
  };

  export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel]


  export const UserScalarFieldEnum: {
    id: 'id',
    email: 'email',
    full_name: 'full_name',
    password: 'password',
    whatsapp_number: 'whatsapp_number',
    role: 'role',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type UserScalarFieldEnum = (typeof UserScalarFieldEnum)[keyof typeof UserScalarFieldEnum]


  export const MitraRequestScalarFieldEnum: {
    id: 'id',
    user_id: 'user_id',
    ktp: 'ktp',
    upgrade_amount: 'upgrade_amount',
    payment_proof: 'payment_proof',
    status: 'status',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type MitraRequestScalarFieldEnum = (typeof MitraRequestScalarFieldEnum)[keyof typeof MitraRequestScalarFieldEnum]


  export const UserPackageScalarFieldEnum: {
    id: 'id',
    transportation_id: 'transportation_id',
    flight_id: 'flight_id',
    hotel_mekkah_id: 'hotel_mekkah_id',
    hotel_madinah_id: 'hotel_madinah_id',
    muthawif_id: 'muthawif_id',
    handling_id: 'handling_id',
    number_of_pax: 'number_of_pax',
    travel_duration: 'travel_duration',
    mekkah_duration: 'mekkah_duration',
    madinah_duration: 'madinah_duration',
    per_pax_price: 'per_pax_price',
    total_price: 'total_price',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type UserPackageScalarFieldEnum = (typeof UserPackageScalarFieldEnum)[keyof typeof UserPackageScalarFieldEnum]


  export const PackageTypeScalarFieldEnum: {
    id: 'id',
    name: 'name',
    is_public: 'is_public',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type PackageTypeScalarFieldEnum = (typeof PackageTypeScalarFieldEnum)[keyof typeof PackageTypeScalarFieldEnum]


  export const UserPackageOptionScalarFieldEnum: {
    id: 'id',
    package_type_id: 'package_type_id',
    name: 'name',
    price: 'price',
    order_number: 'order_number',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type UserPackageOptionScalarFieldEnum = (typeof UserPackageOptionScalarFieldEnum)[keyof typeof UserPackageOptionScalarFieldEnum]


  export const UserPackageOrderScalarFieldEnum: {
    id: 'id',
    full_name: 'full_name',
    email: 'email',
    whatsapp_number: 'whatsapp_number',
    user_package_id: 'user_package_id',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type UserPackageOrderScalarFieldEnum = (typeof UserPackageOrderScalarFieldEnum)[keyof typeof UserPackageOrderScalarFieldEnum]


  export const CategoryScalarFieldEnum: {
    id: 'id',
    name: 'name',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type CategoryScalarFieldEnum = (typeof CategoryScalarFieldEnum)[keyof typeof CategoryScalarFieldEnum]


  export const ProductScalarFieldEnum: {
    id: 'id',
    name: 'name',
    description: 'description',
    price: 'price',
    has_variation: 'has_variation',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type ProductScalarFieldEnum = (typeof ProductScalarFieldEnum)[keyof typeof ProductScalarFieldEnum]


  export const ProductThumbnailScalarFieldEnum: {
    id: 'id',
    increment: 'increment',
    product_id: 'product_id',
    image_url: 'image_url'
  };

  export type ProductThumbnailScalarFieldEnum = (typeof ProductThumbnailScalarFieldEnum)[keyof typeof ProductThumbnailScalarFieldEnum]


  export const ProductCategoryScalarFieldEnum: {
    id: 'id',
    product_id: 'product_id',
    category_id: 'category_id'
  };

  export type ProductCategoryScalarFieldEnum = (typeof ProductCategoryScalarFieldEnum)[keyof typeof ProductCategoryScalarFieldEnum]


  export const ProductVariationScalarFieldEnum: {
    id: 'id',
    increment: 'increment',
    product_id: 'product_id',
    name: 'name',
    price: 'price',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type ProductVariationScalarFieldEnum = (typeof ProductVariationScalarFieldEnum)[keyof typeof ProductVariationScalarFieldEnum]


  export const ProductIncludeScalarFieldEnum: {
    id: 'id',
    increment: 'increment',
    product_id: 'product_id',
    description: 'description'
  };

  export type ProductIncludeScalarFieldEnum = (typeof ProductIncludeScalarFieldEnum)[keyof typeof ProductIncludeScalarFieldEnum]


  export const ProductExcludeScalarFieldEnum: {
    id: 'id',
    increment: 'increment',
    product_id: 'product_id',
    description: 'description'
  };

  export type ProductExcludeScalarFieldEnum = (typeof ProductExcludeScalarFieldEnum)[keyof typeof ProductExcludeScalarFieldEnum]


  export const ProductOrderScalarFieldEnum: {
    id: 'id',
    user_id: 'user_id',
    product_id: 'product_id',
    variation_id: 'variation_id',
    departure: 'departure',
    number_of_pax: 'number_of_pax',
    per_pax_price: 'per_pax_price',
    total_price: 'total_price',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type ProductOrderScalarFieldEnum = (typeof ProductOrderScalarFieldEnum)[keyof typeof ProductOrderScalarFieldEnum]


  export const VendorScalarFieldEnum: {
    id: 'id',
    name: 'name',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type VendorScalarFieldEnum = (typeof VendorScalarFieldEnum)[keyof typeof VendorScalarFieldEnum]


  export const HotelScalarFieldEnum: {
    id: 'id',
    vendor_id: 'vendor_id',
    name: 'name',
    city: 'city',
    order_number: 'order_number',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type HotelScalarFieldEnum = (typeof HotelScalarFieldEnum)[keyof typeof HotelScalarFieldEnum]


  export const PeriodScalarFieldEnum: {
    id: 'id',
    category: 'category',
    start_date: 'start_date',
    end_date: 'end_date',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type PeriodScalarFieldEnum = (typeof PeriodScalarFieldEnum)[keyof typeof PeriodScalarFieldEnum]


  export const HotelPeriodPriceScalarFieldEnum: {
    id: 'id',
    hotel_id: 'hotel_id',
    period_id: 'period_id',
    price_double: 'price_double',
    price_triple: 'price_triple',
    price_quad: 'price_quad',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type HotelPeriodPriceScalarFieldEnum = (typeof HotelPeriodPriceScalarFieldEnum)[keyof typeof HotelPeriodPriceScalarFieldEnum]


  export const AirlineScalarFieldEnum: {
    id: 'id',
    name: 'name',
    price_idr: 'price_idr',
    order_number: 'order_number',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type AirlineScalarFieldEnum = (typeof AirlineScalarFieldEnum)[keyof typeof AirlineScalarFieldEnum]


  export const VisaScalarFieldEnum: {
    id: 'id',
    name: 'name',
    price_idr: 'price_idr',
    order_number: 'order_number',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type VisaScalarFieldEnum = (typeof VisaScalarFieldEnum)[keyof typeof VisaScalarFieldEnum]


  export const TransportationScalarFieldEnum: {
    id: 'id',
    name: 'name',
    price_idr: 'price_idr',
    order_number: 'order_number',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type TransportationScalarFieldEnum = (typeof TransportationScalarFieldEnum)[keyof typeof TransportationScalarFieldEnum]


  export const MuthawifScalarFieldEnum: {
    id: 'id',
    name: 'name',
    price_idr: 'price_idr',
    order_number: 'order_number',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type MuthawifScalarFieldEnum = (typeof MuthawifScalarFieldEnum)[keyof typeof MuthawifScalarFieldEnum]


  export const HandlingSaudiScalarFieldEnum: {
    id: 'id',
    name: 'name',
    price_idr: 'price_idr',
    order_number: 'order_number',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type HandlingSaudiScalarFieldEnum = (typeof HandlingSaudiScalarFieldEnum)[keyof typeof HandlingSaudiScalarFieldEnum]


  export const HandlingDomesticScalarFieldEnum: {
    id: 'id',
    name: 'name',
    price_idr: 'price_idr',
    order_number: 'order_number',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type HandlingDomesticScalarFieldEnum = (typeof HandlingDomesticScalarFieldEnum)[keyof typeof HandlingDomesticScalarFieldEnum]


  export const SiskopatuhScalarFieldEnum: {
    id: 'id',
    name: 'name',
    price_idr: 'price_idr',
    order_number: 'order_number',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type SiskopatuhScalarFieldEnum = (typeof SiskopatuhScalarFieldEnum)[keyof typeof SiskopatuhScalarFieldEnum]


  export const EquipmentScalarFieldEnum: {
    id: 'id',
    name: 'name',
    price_idr: 'price_idr',
    order_number: 'order_number',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type EquipmentScalarFieldEnum = (typeof EquipmentScalarFieldEnum)[keyof typeof EquipmentScalarFieldEnum]


  export const TourPlusScalarFieldEnum: {
    id: 'id',
    name: 'name',
    price_idr: 'price_idr',
    order_number: 'order_number',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type TourPlusScalarFieldEnum = (typeof TourPlusScalarFieldEnum)[keyof typeof TourPlusScalarFieldEnum]


  export const ManasikScalarFieldEnum: {
    id: 'id',
    name: 'name',
    price_idr: 'price_idr',
    order_number: 'order_number',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type ManasikScalarFieldEnum = (typeof ManasikScalarFieldEnum)[keyof typeof ManasikScalarFieldEnum]


  export const MitraPackageScalarFieldEnum: {
    id: 'id',
    period_id: 'period_id',
    airline_id: 'airline_id',
    vendor_id: 'vendor_id',
    hotel_mekkah_id: 'hotel_mekkah_id',
    hotel_madinah_id: 'hotel_madinah_id',
    visa_id: 'visa_id',
    transportation_id: 'transportation_id',
    muthawif_id: 'muthawif_id',
    handling_saudi_id: 'handling_saudi_id',
    handling_domestic_id: 'handling_domestic_id',
    siskopatuh_id: 'siskopatuh_id',
    equipment_id: 'equipment_id',
    tour_plus_id: 'tour_plus_id',
    manasik_id: 'manasik_id',
    number_of_pax: 'number_of_pax',
    departure_date: 'departure_date',
    travel_duration: 'travel_duration',
    mekkah_duration: 'mekkah_duration',
    madinah_duration: 'madinah_duration',
    tour_leader: 'tour_leader',
    margin: 'margin',
    per_pax_price_double: 'per_pax_price_double',
    per_pax_price_triple: 'per_pax_price_triple',
    per_pax_price_quad: 'per_pax_price_quad',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type MitraPackageScalarFieldEnum = (typeof MitraPackageScalarFieldEnum)[keyof typeof MitraPackageScalarFieldEnum]


  export const MitraPackageOrderScalarFieldEnum: {
    id: 'id',
    user_id: 'user_id',
    mitra_package_id: 'mitra_package_id',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type MitraPackageOrderScalarFieldEnum = (typeof MitraPackageOrderScalarFieldEnum)[keyof typeof MitraPackageOrderScalarFieldEnum]


  export const ExchangeRateScalarFieldEnum: {
    id: 'id',
    currency: 'currency',
    rate_idr: 'rate_idr',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type ExchangeRateScalarFieldEnum = (typeof ExchangeRateScalarFieldEnum)[keyof typeof ExchangeRateScalarFieldEnum]


  export const ContactScalarFieldEnum: {
    id: 'id',
    name: 'name',
    value: 'value',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type ContactScalarFieldEnum = (typeof ContactScalarFieldEnum)[keyof typeof ContactScalarFieldEnum]


  export const FaqScalarFieldEnum: {
    id: 'id',
    question: 'question',
    answer: 'answer',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type FaqScalarFieldEnum = (typeof FaqScalarFieldEnum)[keyof typeof FaqScalarFieldEnum]


  export const ContentScalarFieldEnum: {
    id: 'id',
    page: 'page',
    section: 'section',
    type: 'type',
    key: 'key',
    value: 'value',
    visible: 'visible',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type ContentScalarFieldEnum = (typeof ContentScalarFieldEnum)[keyof typeof ContentScalarFieldEnum]


  export const MenuItemScalarFieldEnum: {
    id: 'id',
    name: 'name',
    url: 'url',
    visible: 'visible',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type MenuItemScalarFieldEnum = (typeof MenuItemScalarFieldEnum)[keyof typeof MenuItemScalarFieldEnum]


  export const FooterScalarFieldEnum: {
    id: 'id',
    name: 'name',
    type: 'type',
    visible: 'visible',
    order: 'order',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type FooterScalarFieldEnum = (typeof FooterScalarFieldEnum)[keyof typeof FooterScalarFieldEnum]


  export const FooterItemScalarFieldEnum: {
    id: 'id',
    footer_id: 'footer_id',
    name: 'name',
    url: 'url',
    visible: 'visible',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type FooterItemScalarFieldEnum = (typeof FooterItemScalarFieldEnum)[keyof typeof FooterItemScalarFieldEnum]


  export const ColorScalarFieldEnum: {
    id: 'id',
    name: 'name',
    hex: 'hex',
    created_at: 'created_at',
    updated_at: 'updated_at'
  };

  export type ColorScalarFieldEnum = (typeof ColorScalarFieldEnum)[keyof typeof ColorScalarFieldEnum]


  export const SortOrder: {
    asc: 'asc',
    desc: 'desc'
  };

  export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder]


  export const JsonNullValueInput: {
    JsonNull: typeof JsonNull
  };

  export type JsonNullValueInput = (typeof JsonNullValueInput)[keyof typeof JsonNullValueInput]


  export const NullsOrder: {
    first: 'first',
    last: 'last'
  };

  export type NullsOrder = (typeof NullsOrder)[keyof typeof NullsOrder]


  export const JsonNullValueFilter: {
    DbNull: typeof DbNull,
    JsonNull: typeof JsonNull,
    AnyNull: typeof AnyNull
  };

  export type JsonNullValueFilter = (typeof JsonNullValueFilter)[keyof typeof JsonNullValueFilter]


  /**
   * Field references 
   */


  /**
   * Reference to a field of type 'String'
   */
  export type StringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String'>
    


  /**
   * Reference to a field of type 'Role'
   */
  export type EnumRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Role'>
    


  /**
   * Reference to a field of type 'DateTime'
   */
  export type DateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime'>
    


  /**
   * Reference to a field of type 'Decimal'
   */
  export type DecimalFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Decimal'>
    


  /**
   * Reference to a field of type 'RequestStatus'
   */
  export type EnumRequestStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'RequestStatus'>
    


  /**
   * Reference to a field of type 'Int'
   */
  export type IntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int'>
    


  /**
   * Reference to a field of type 'Boolean'
   */
  export type BooleanFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Boolean'>
    


  /**
   * Reference to a field of type 'City'
   */
  export type EnumCityFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'City'>
    


  /**
   * Reference to a field of type 'PeriodCategory'
   */
  export type EnumPeriodCategoryFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'PeriodCategory'>
    


  /**
   * Reference to a field of type 'ContentType'
   */
  export type EnumContentTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ContentType'>
    


  /**
   * Reference to a field of type 'Json'
   */
  export type JsonFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Json'>
    


  /**
   * Reference to a field of type 'FooterType'
   */
  export type EnumFooterTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'FooterType'>
    


  /**
   * Reference to a field of type 'Float'
   */
  export type FloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float'>
    
  /**
   * Deep Input Types
   */


  export type UserWhereInput = {
    AND?: UserWhereInput | UserWhereInput[]
    OR?: UserWhereInput[]
    NOT?: UserWhereInput | UserWhereInput[]
    id?: StringFilter<"User"> | string
    email?: StringFilter<"User"> | string
    full_name?: StringFilter<"User"> | string
    password?: StringFilter<"User"> | string
    whatsapp_number?: StringFilter<"User"> | string
    role?: EnumRoleFilter<"User"> | $Enums.Role
    created_at?: DateTimeFilter<"User"> | Date | string
    updated_at?: DateTimeFilter<"User"> | Date | string
    ProductOrders?: ProductOrderListRelationFilter
    MitraPackageOrder?: MitraPackageOrderListRelationFilter
    MitraRequest?: MitraRequestListRelationFilter
  }

  export type UserOrderByWithRelationInput = {
    id?: SortOrder
    email?: SortOrder
    full_name?: SortOrder
    password?: SortOrder
    whatsapp_number?: SortOrder
    role?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    ProductOrders?: ProductOrderOrderByRelationAggregateInput
    MitraPackageOrder?: MitraPackageOrderOrderByRelationAggregateInput
    MitraRequest?: MitraRequestOrderByRelationAggregateInput
  }

  export type UserWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    email?: string
    AND?: UserWhereInput | UserWhereInput[]
    OR?: UserWhereInput[]
    NOT?: UserWhereInput | UserWhereInput[]
    full_name?: StringFilter<"User"> | string
    password?: StringFilter<"User"> | string
    whatsapp_number?: StringFilter<"User"> | string
    role?: EnumRoleFilter<"User"> | $Enums.Role
    created_at?: DateTimeFilter<"User"> | Date | string
    updated_at?: DateTimeFilter<"User"> | Date | string
    ProductOrders?: ProductOrderListRelationFilter
    MitraPackageOrder?: MitraPackageOrderListRelationFilter
    MitraRequest?: MitraRequestListRelationFilter
  }, "id" | "email">

  export type UserOrderByWithAggregationInput = {
    id?: SortOrder
    email?: SortOrder
    full_name?: SortOrder
    password?: SortOrder
    whatsapp_number?: SortOrder
    role?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: UserCountOrderByAggregateInput
    _max?: UserMaxOrderByAggregateInput
    _min?: UserMinOrderByAggregateInput
  }

  export type UserScalarWhereWithAggregatesInput = {
    AND?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
    OR?: UserScalarWhereWithAggregatesInput[]
    NOT?: UserScalarWhereWithAggregatesInput | UserScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"User"> | string
    email?: StringWithAggregatesFilter<"User"> | string
    full_name?: StringWithAggregatesFilter<"User"> | string
    password?: StringWithAggregatesFilter<"User"> | string
    whatsapp_number?: StringWithAggregatesFilter<"User"> | string
    role?: EnumRoleWithAggregatesFilter<"User"> | $Enums.Role
    created_at?: DateTimeWithAggregatesFilter<"User"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"User"> | Date | string
  }

  export type MitraRequestWhereInput = {
    AND?: MitraRequestWhereInput | MitraRequestWhereInput[]
    OR?: MitraRequestWhereInput[]
    NOT?: MitraRequestWhereInput | MitraRequestWhereInput[]
    id?: StringFilter<"MitraRequest"> | string
    user_id?: StringFilter<"MitraRequest"> | string
    ktp?: StringFilter<"MitraRequest"> | string
    upgrade_amount?: DecimalFilter<"MitraRequest"> | Decimal | DecimalJsLike | number | string
    payment_proof?: StringFilter<"MitraRequest"> | string
    status?: EnumRequestStatusFilter<"MitraRequest"> | $Enums.RequestStatus
    created_at?: DateTimeFilter<"MitraRequest"> | Date | string
    updated_at?: DateTimeFilter<"MitraRequest"> | Date | string
    User?: XOR<UserRelationFilter, UserWhereInput>
  }

  export type MitraRequestOrderByWithRelationInput = {
    id?: SortOrder
    user_id?: SortOrder
    ktp?: SortOrder
    upgrade_amount?: SortOrder
    payment_proof?: SortOrder
    status?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    User?: UserOrderByWithRelationInput
  }

  export type MitraRequestWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: MitraRequestWhereInput | MitraRequestWhereInput[]
    OR?: MitraRequestWhereInput[]
    NOT?: MitraRequestWhereInput | MitraRequestWhereInput[]
    user_id?: StringFilter<"MitraRequest"> | string
    ktp?: StringFilter<"MitraRequest"> | string
    upgrade_amount?: DecimalFilter<"MitraRequest"> | Decimal | DecimalJsLike | number | string
    payment_proof?: StringFilter<"MitraRequest"> | string
    status?: EnumRequestStatusFilter<"MitraRequest"> | $Enums.RequestStatus
    created_at?: DateTimeFilter<"MitraRequest"> | Date | string
    updated_at?: DateTimeFilter<"MitraRequest"> | Date | string
    User?: XOR<UserRelationFilter, UserWhereInput>
  }, "id">

  export type MitraRequestOrderByWithAggregationInput = {
    id?: SortOrder
    user_id?: SortOrder
    ktp?: SortOrder
    upgrade_amount?: SortOrder
    payment_proof?: SortOrder
    status?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: MitraRequestCountOrderByAggregateInput
    _avg?: MitraRequestAvgOrderByAggregateInput
    _max?: MitraRequestMaxOrderByAggregateInput
    _min?: MitraRequestMinOrderByAggregateInput
    _sum?: MitraRequestSumOrderByAggregateInput
  }

  export type MitraRequestScalarWhereWithAggregatesInput = {
    AND?: MitraRequestScalarWhereWithAggregatesInput | MitraRequestScalarWhereWithAggregatesInput[]
    OR?: MitraRequestScalarWhereWithAggregatesInput[]
    NOT?: MitraRequestScalarWhereWithAggregatesInput | MitraRequestScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"MitraRequest"> | string
    user_id?: StringWithAggregatesFilter<"MitraRequest"> | string
    ktp?: StringWithAggregatesFilter<"MitraRequest"> | string
    upgrade_amount?: DecimalWithAggregatesFilter<"MitraRequest"> | Decimal | DecimalJsLike | number | string
    payment_proof?: StringWithAggregatesFilter<"MitraRequest"> | string
    status?: EnumRequestStatusWithAggregatesFilter<"MitraRequest"> | $Enums.RequestStatus
    created_at?: DateTimeWithAggregatesFilter<"MitraRequest"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"MitraRequest"> | Date | string
  }

  export type UserPackageWhereInput = {
    AND?: UserPackageWhereInput | UserPackageWhereInput[]
    OR?: UserPackageWhereInput[]
    NOT?: UserPackageWhereInput | UserPackageWhereInput[]
    id?: StringFilter<"UserPackage"> | string
    transportation_id?: StringNullableFilter<"UserPackage"> | string | null
    flight_id?: StringNullableFilter<"UserPackage"> | string | null
    hotel_mekkah_id?: StringNullableFilter<"UserPackage"> | string | null
    hotel_madinah_id?: StringNullableFilter<"UserPackage"> | string | null
    muthawif_id?: StringNullableFilter<"UserPackage"> | string | null
    handling_id?: StringNullableFilter<"UserPackage"> | string | null
    number_of_pax?: IntFilter<"UserPackage"> | number
    travel_duration?: IntFilter<"UserPackage"> | number
    mekkah_duration?: IntFilter<"UserPackage"> | number
    madinah_duration?: IntFilter<"UserPackage"> | number
    per_pax_price?: DecimalFilter<"UserPackage"> | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFilter<"UserPackage"> | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFilter<"UserPackage"> | Date | string
    updated_at?: DateTimeFilter<"UserPackage"> | Date | string
    UserPackageOrders?: UserPackageOrderListRelationFilter
    transportation?: XOR<UserPackageOptionNullableRelationFilter, UserPackageOptionWhereInput> | null
    flight?: XOR<UserPackageOptionNullableRelationFilter, UserPackageOptionWhereInput> | null
    hotelMekkah?: XOR<UserPackageOptionNullableRelationFilter, UserPackageOptionWhereInput> | null
    hotelMadinah?: XOR<UserPackageOptionNullableRelationFilter, UserPackageOptionWhereInput> | null
    muthawif?: XOR<UserPackageOptionNullableRelationFilter, UserPackageOptionWhereInput> | null
    handling?: XOR<UserPackageOptionNullableRelationFilter, UserPackageOptionWhereInput> | null
  }

  export type UserPackageOrderByWithRelationInput = {
    id?: SortOrder
    transportation_id?: SortOrderInput | SortOrder
    flight_id?: SortOrderInput | SortOrder
    hotel_mekkah_id?: SortOrderInput | SortOrder
    hotel_madinah_id?: SortOrderInput | SortOrder
    muthawif_id?: SortOrderInput | SortOrder
    handling_id?: SortOrderInput | SortOrder
    number_of_pax?: SortOrder
    travel_duration?: SortOrder
    mekkah_duration?: SortOrder
    madinah_duration?: SortOrder
    per_pax_price?: SortOrder
    total_price?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    UserPackageOrders?: UserPackageOrderOrderByRelationAggregateInput
    transportation?: UserPackageOptionOrderByWithRelationInput
    flight?: UserPackageOptionOrderByWithRelationInput
    hotelMekkah?: UserPackageOptionOrderByWithRelationInput
    hotelMadinah?: UserPackageOptionOrderByWithRelationInput
    muthawif?: UserPackageOptionOrderByWithRelationInput
    handling?: UserPackageOptionOrderByWithRelationInput
  }

  export type UserPackageWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: UserPackageWhereInput | UserPackageWhereInput[]
    OR?: UserPackageWhereInput[]
    NOT?: UserPackageWhereInput | UserPackageWhereInput[]
    transportation_id?: StringNullableFilter<"UserPackage"> | string | null
    flight_id?: StringNullableFilter<"UserPackage"> | string | null
    hotel_mekkah_id?: StringNullableFilter<"UserPackage"> | string | null
    hotel_madinah_id?: StringNullableFilter<"UserPackage"> | string | null
    muthawif_id?: StringNullableFilter<"UserPackage"> | string | null
    handling_id?: StringNullableFilter<"UserPackage"> | string | null
    number_of_pax?: IntFilter<"UserPackage"> | number
    travel_duration?: IntFilter<"UserPackage"> | number
    mekkah_duration?: IntFilter<"UserPackage"> | number
    madinah_duration?: IntFilter<"UserPackage"> | number
    per_pax_price?: DecimalFilter<"UserPackage"> | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFilter<"UserPackage"> | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFilter<"UserPackage"> | Date | string
    updated_at?: DateTimeFilter<"UserPackage"> | Date | string
    UserPackageOrders?: UserPackageOrderListRelationFilter
    transportation?: XOR<UserPackageOptionNullableRelationFilter, UserPackageOptionWhereInput> | null
    flight?: XOR<UserPackageOptionNullableRelationFilter, UserPackageOptionWhereInput> | null
    hotelMekkah?: XOR<UserPackageOptionNullableRelationFilter, UserPackageOptionWhereInput> | null
    hotelMadinah?: XOR<UserPackageOptionNullableRelationFilter, UserPackageOptionWhereInput> | null
    muthawif?: XOR<UserPackageOptionNullableRelationFilter, UserPackageOptionWhereInput> | null
    handling?: XOR<UserPackageOptionNullableRelationFilter, UserPackageOptionWhereInput> | null
  }, "id">

  export type UserPackageOrderByWithAggregationInput = {
    id?: SortOrder
    transportation_id?: SortOrderInput | SortOrder
    flight_id?: SortOrderInput | SortOrder
    hotel_mekkah_id?: SortOrderInput | SortOrder
    hotel_madinah_id?: SortOrderInput | SortOrder
    muthawif_id?: SortOrderInput | SortOrder
    handling_id?: SortOrderInput | SortOrder
    number_of_pax?: SortOrder
    travel_duration?: SortOrder
    mekkah_duration?: SortOrder
    madinah_duration?: SortOrder
    per_pax_price?: SortOrder
    total_price?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: UserPackageCountOrderByAggregateInput
    _avg?: UserPackageAvgOrderByAggregateInput
    _max?: UserPackageMaxOrderByAggregateInput
    _min?: UserPackageMinOrderByAggregateInput
    _sum?: UserPackageSumOrderByAggregateInput
  }

  export type UserPackageScalarWhereWithAggregatesInput = {
    AND?: UserPackageScalarWhereWithAggregatesInput | UserPackageScalarWhereWithAggregatesInput[]
    OR?: UserPackageScalarWhereWithAggregatesInput[]
    NOT?: UserPackageScalarWhereWithAggregatesInput | UserPackageScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"UserPackage"> | string
    transportation_id?: StringNullableWithAggregatesFilter<"UserPackage"> | string | null
    flight_id?: StringNullableWithAggregatesFilter<"UserPackage"> | string | null
    hotel_mekkah_id?: StringNullableWithAggregatesFilter<"UserPackage"> | string | null
    hotel_madinah_id?: StringNullableWithAggregatesFilter<"UserPackage"> | string | null
    muthawif_id?: StringNullableWithAggregatesFilter<"UserPackage"> | string | null
    handling_id?: StringNullableWithAggregatesFilter<"UserPackage"> | string | null
    number_of_pax?: IntWithAggregatesFilter<"UserPackage"> | number
    travel_duration?: IntWithAggregatesFilter<"UserPackage"> | number
    mekkah_duration?: IntWithAggregatesFilter<"UserPackage"> | number
    madinah_duration?: IntWithAggregatesFilter<"UserPackage"> | number
    per_pax_price?: DecimalWithAggregatesFilter<"UserPackage"> | Decimal | DecimalJsLike | number | string
    total_price?: DecimalWithAggregatesFilter<"UserPackage"> | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeWithAggregatesFilter<"UserPackage"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"UserPackage"> | Date | string
  }

  export type PackageTypeWhereInput = {
    AND?: PackageTypeWhereInput | PackageTypeWhereInput[]
    OR?: PackageTypeWhereInput[]
    NOT?: PackageTypeWhereInput | PackageTypeWhereInput[]
    id?: StringFilter<"PackageType"> | string
    name?: StringFilter<"PackageType"> | string
    is_public?: BoolFilter<"PackageType"> | boolean
    created_at?: DateTimeFilter<"PackageType"> | Date | string
    updated_at?: DateTimeFilter<"PackageType"> | Date | string
    UserPackageOptions?: UserPackageOptionListRelationFilter
  }

  export type PackageTypeOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    is_public?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    UserPackageOptions?: UserPackageOptionOrderByRelationAggregateInput
  }

  export type PackageTypeWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: PackageTypeWhereInput | PackageTypeWhereInput[]
    OR?: PackageTypeWhereInput[]
    NOT?: PackageTypeWhereInput | PackageTypeWhereInput[]
    name?: StringFilter<"PackageType"> | string
    is_public?: BoolFilter<"PackageType"> | boolean
    created_at?: DateTimeFilter<"PackageType"> | Date | string
    updated_at?: DateTimeFilter<"PackageType"> | Date | string
    UserPackageOptions?: UserPackageOptionListRelationFilter
  }, "id">

  export type PackageTypeOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    is_public?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: PackageTypeCountOrderByAggregateInput
    _max?: PackageTypeMaxOrderByAggregateInput
    _min?: PackageTypeMinOrderByAggregateInput
  }

  export type PackageTypeScalarWhereWithAggregatesInput = {
    AND?: PackageTypeScalarWhereWithAggregatesInput | PackageTypeScalarWhereWithAggregatesInput[]
    OR?: PackageTypeScalarWhereWithAggregatesInput[]
    NOT?: PackageTypeScalarWhereWithAggregatesInput | PackageTypeScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"PackageType"> | string
    name?: StringWithAggregatesFilter<"PackageType"> | string
    is_public?: BoolWithAggregatesFilter<"PackageType"> | boolean
    created_at?: DateTimeWithAggregatesFilter<"PackageType"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"PackageType"> | Date | string
  }

  export type UserPackageOptionWhereInput = {
    AND?: UserPackageOptionWhereInput | UserPackageOptionWhereInput[]
    OR?: UserPackageOptionWhereInput[]
    NOT?: UserPackageOptionWhereInput | UserPackageOptionWhereInput[]
    id?: StringFilter<"UserPackageOption"> | string
    package_type_id?: StringFilter<"UserPackageOption"> | string
    name?: StringFilter<"UserPackageOption"> | string
    price?: DecimalFilter<"UserPackageOption"> | Decimal | DecimalJsLike | number | string
    order_number?: IntFilter<"UserPackageOption"> | number
    created_at?: DateTimeFilter<"UserPackageOption"> | Date | string
    updated_at?: DateTimeFilter<"UserPackageOption"> | Date | string
    transportations?: UserPackageListRelationFilter
    flights?: UserPackageListRelationFilter
    hotelMekkahs?: UserPackageListRelationFilter
    hotelMadinahs?: UserPackageListRelationFilter
    muthawifs?: UserPackageListRelationFilter
    handlings?: UserPackageListRelationFilter
    PackageType?: XOR<PackageTypeRelationFilter, PackageTypeWhereInput>
  }

  export type UserPackageOptionOrderByWithRelationInput = {
    id?: SortOrder
    package_type_id?: SortOrder
    name?: SortOrder
    price?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    transportations?: UserPackageOrderByRelationAggregateInput
    flights?: UserPackageOrderByRelationAggregateInput
    hotelMekkahs?: UserPackageOrderByRelationAggregateInput
    hotelMadinahs?: UserPackageOrderByRelationAggregateInput
    muthawifs?: UserPackageOrderByRelationAggregateInput
    handlings?: UserPackageOrderByRelationAggregateInput
    PackageType?: PackageTypeOrderByWithRelationInput
  }

  export type UserPackageOptionWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: UserPackageOptionWhereInput | UserPackageOptionWhereInput[]
    OR?: UserPackageOptionWhereInput[]
    NOT?: UserPackageOptionWhereInput | UserPackageOptionWhereInput[]
    package_type_id?: StringFilter<"UserPackageOption"> | string
    name?: StringFilter<"UserPackageOption"> | string
    price?: DecimalFilter<"UserPackageOption"> | Decimal | DecimalJsLike | number | string
    order_number?: IntFilter<"UserPackageOption"> | number
    created_at?: DateTimeFilter<"UserPackageOption"> | Date | string
    updated_at?: DateTimeFilter<"UserPackageOption"> | Date | string
    transportations?: UserPackageListRelationFilter
    flights?: UserPackageListRelationFilter
    hotelMekkahs?: UserPackageListRelationFilter
    hotelMadinahs?: UserPackageListRelationFilter
    muthawifs?: UserPackageListRelationFilter
    handlings?: UserPackageListRelationFilter
    PackageType?: XOR<PackageTypeRelationFilter, PackageTypeWhereInput>
  }, "id">

  export type UserPackageOptionOrderByWithAggregationInput = {
    id?: SortOrder
    package_type_id?: SortOrder
    name?: SortOrder
    price?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: UserPackageOptionCountOrderByAggregateInput
    _avg?: UserPackageOptionAvgOrderByAggregateInput
    _max?: UserPackageOptionMaxOrderByAggregateInput
    _min?: UserPackageOptionMinOrderByAggregateInput
    _sum?: UserPackageOptionSumOrderByAggregateInput
  }

  export type UserPackageOptionScalarWhereWithAggregatesInput = {
    AND?: UserPackageOptionScalarWhereWithAggregatesInput | UserPackageOptionScalarWhereWithAggregatesInput[]
    OR?: UserPackageOptionScalarWhereWithAggregatesInput[]
    NOT?: UserPackageOptionScalarWhereWithAggregatesInput | UserPackageOptionScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"UserPackageOption"> | string
    package_type_id?: StringWithAggregatesFilter<"UserPackageOption"> | string
    name?: StringWithAggregatesFilter<"UserPackageOption"> | string
    price?: DecimalWithAggregatesFilter<"UserPackageOption"> | Decimal | DecimalJsLike | number | string
    order_number?: IntWithAggregatesFilter<"UserPackageOption"> | number
    created_at?: DateTimeWithAggregatesFilter<"UserPackageOption"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"UserPackageOption"> | Date | string
  }

  export type UserPackageOrderWhereInput = {
    AND?: UserPackageOrderWhereInput | UserPackageOrderWhereInput[]
    OR?: UserPackageOrderWhereInput[]
    NOT?: UserPackageOrderWhereInput | UserPackageOrderWhereInput[]
    id?: StringFilter<"UserPackageOrder"> | string
    full_name?: StringFilter<"UserPackageOrder"> | string
    email?: StringFilter<"UserPackageOrder"> | string
    whatsapp_number?: StringFilter<"UserPackageOrder"> | string
    user_package_id?: StringFilter<"UserPackageOrder"> | string
    created_at?: DateTimeFilter<"UserPackageOrder"> | Date | string
    updated_at?: DateTimeFilter<"UserPackageOrder"> | Date | string
    UserPackage?: XOR<UserPackageRelationFilter, UserPackageWhereInput>
  }

  export type UserPackageOrderOrderByWithRelationInput = {
    id?: SortOrder
    full_name?: SortOrder
    email?: SortOrder
    whatsapp_number?: SortOrder
    user_package_id?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    UserPackage?: UserPackageOrderByWithRelationInput
  }

  export type UserPackageOrderWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: UserPackageOrderWhereInput | UserPackageOrderWhereInput[]
    OR?: UserPackageOrderWhereInput[]
    NOT?: UserPackageOrderWhereInput | UserPackageOrderWhereInput[]
    full_name?: StringFilter<"UserPackageOrder"> | string
    email?: StringFilter<"UserPackageOrder"> | string
    whatsapp_number?: StringFilter<"UserPackageOrder"> | string
    user_package_id?: StringFilter<"UserPackageOrder"> | string
    created_at?: DateTimeFilter<"UserPackageOrder"> | Date | string
    updated_at?: DateTimeFilter<"UserPackageOrder"> | Date | string
    UserPackage?: XOR<UserPackageRelationFilter, UserPackageWhereInput>
  }, "id">

  export type UserPackageOrderOrderByWithAggregationInput = {
    id?: SortOrder
    full_name?: SortOrder
    email?: SortOrder
    whatsapp_number?: SortOrder
    user_package_id?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: UserPackageOrderCountOrderByAggregateInput
    _max?: UserPackageOrderMaxOrderByAggregateInput
    _min?: UserPackageOrderMinOrderByAggregateInput
  }

  export type UserPackageOrderScalarWhereWithAggregatesInput = {
    AND?: UserPackageOrderScalarWhereWithAggregatesInput | UserPackageOrderScalarWhereWithAggregatesInput[]
    OR?: UserPackageOrderScalarWhereWithAggregatesInput[]
    NOT?: UserPackageOrderScalarWhereWithAggregatesInput | UserPackageOrderScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"UserPackageOrder"> | string
    full_name?: StringWithAggregatesFilter<"UserPackageOrder"> | string
    email?: StringWithAggregatesFilter<"UserPackageOrder"> | string
    whatsapp_number?: StringWithAggregatesFilter<"UserPackageOrder"> | string
    user_package_id?: StringWithAggregatesFilter<"UserPackageOrder"> | string
    created_at?: DateTimeWithAggregatesFilter<"UserPackageOrder"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"UserPackageOrder"> | Date | string
  }

  export type CategoryWhereInput = {
    AND?: CategoryWhereInput | CategoryWhereInput[]
    OR?: CategoryWhereInput[]
    NOT?: CategoryWhereInput | CategoryWhereInput[]
    id?: StringFilter<"Category"> | string
    name?: StringFilter<"Category"> | string
    created_at?: DateTimeFilter<"Category"> | Date | string
    updated_at?: DateTimeFilter<"Category"> | Date | string
    ProductCategories?: ProductCategoryListRelationFilter
  }

  export type CategoryOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    ProductCategories?: ProductCategoryOrderByRelationAggregateInput
  }

  export type CategoryWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: CategoryWhereInput | CategoryWhereInput[]
    OR?: CategoryWhereInput[]
    NOT?: CategoryWhereInput | CategoryWhereInput[]
    name?: StringFilter<"Category"> | string
    created_at?: DateTimeFilter<"Category"> | Date | string
    updated_at?: DateTimeFilter<"Category"> | Date | string
    ProductCategories?: ProductCategoryListRelationFilter
  }, "id">

  export type CategoryOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: CategoryCountOrderByAggregateInput
    _max?: CategoryMaxOrderByAggregateInput
    _min?: CategoryMinOrderByAggregateInput
  }

  export type CategoryScalarWhereWithAggregatesInput = {
    AND?: CategoryScalarWhereWithAggregatesInput | CategoryScalarWhereWithAggregatesInput[]
    OR?: CategoryScalarWhereWithAggregatesInput[]
    NOT?: CategoryScalarWhereWithAggregatesInput | CategoryScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Category"> | string
    name?: StringWithAggregatesFilter<"Category"> | string
    created_at?: DateTimeWithAggregatesFilter<"Category"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"Category"> | Date | string
  }

  export type ProductWhereInput = {
    AND?: ProductWhereInput | ProductWhereInput[]
    OR?: ProductWhereInput[]
    NOT?: ProductWhereInput | ProductWhereInput[]
    id?: StringFilter<"Product"> | string
    name?: StringFilter<"Product"> | string
    description?: StringNullableFilter<"Product"> | string | null
    price?: DecimalFilter<"Product"> | Decimal | DecimalJsLike | number | string
    has_variation?: BoolFilter<"Product"> | boolean
    created_at?: DateTimeFilter<"Product"> | Date | string
    updated_at?: DateTimeFilter<"Product"> | Date | string
    ProductThumbnails?: ProductThumbnailListRelationFilter
    ProductCategories?: ProductCategoryListRelationFilter
    ProductVariations?: ProductVariationListRelationFilter
    ProductIncludes?: ProductIncludeListRelationFilter
    ProductExcludes?: ProductExcludeListRelationFilter
    ProductOrders?: ProductOrderListRelationFilter
  }

  export type ProductOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrderInput | SortOrder
    price?: SortOrder
    has_variation?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    ProductThumbnails?: ProductThumbnailOrderByRelationAggregateInput
    ProductCategories?: ProductCategoryOrderByRelationAggregateInput
    ProductVariations?: ProductVariationOrderByRelationAggregateInput
    ProductIncludes?: ProductIncludeOrderByRelationAggregateInput
    ProductExcludes?: ProductExcludeOrderByRelationAggregateInput
    ProductOrders?: ProductOrderOrderByRelationAggregateInput
  }

  export type ProductWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: ProductWhereInput | ProductWhereInput[]
    OR?: ProductWhereInput[]
    NOT?: ProductWhereInput | ProductWhereInput[]
    name?: StringFilter<"Product"> | string
    description?: StringNullableFilter<"Product"> | string | null
    price?: DecimalFilter<"Product"> | Decimal | DecimalJsLike | number | string
    has_variation?: BoolFilter<"Product"> | boolean
    created_at?: DateTimeFilter<"Product"> | Date | string
    updated_at?: DateTimeFilter<"Product"> | Date | string
    ProductThumbnails?: ProductThumbnailListRelationFilter
    ProductCategories?: ProductCategoryListRelationFilter
    ProductVariations?: ProductVariationListRelationFilter
    ProductIncludes?: ProductIncludeListRelationFilter
    ProductExcludes?: ProductExcludeListRelationFilter
    ProductOrders?: ProductOrderListRelationFilter
  }, "id">

  export type ProductOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrderInput | SortOrder
    price?: SortOrder
    has_variation?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: ProductCountOrderByAggregateInput
    _avg?: ProductAvgOrderByAggregateInput
    _max?: ProductMaxOrderByAggregateInput
    _min?: ProductMinOrderByAggregateInput
    _sum?: ProductSumOrderByAggregateInput
  }

  export type ProductScalarWhereWithAggregatesInput = {
    AND?: ProductScalarWhereWithAggregatesInput | ProductScalarWhereWithAggregatesInput[]
    OR?: ProductScalarWhereWithAggregatesInput[]
    NOT?: ProductScalarWhereWithAggregatesInput | ProductScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Product"> | string
    name?: StringWithAggregatesFilter<"Product"> | string
    description?: StringNullableWithAggregatesFilter<"Product"> | string | null
    price?: DecimalWithAggregatesFilter<"Product"> | Decimal | DecimalJsLike | number | string
    has_variation?: BoolWithAggregatesFilter<"Product"> | boolean
    created_at?: DateTimeWithAggregatesFilter<"Product"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"Product"> | Date | string
  }

  export type ProductThumbnailWhereInput = {
    AND?: ProductThumbnailWhereInput | ProductThumbnailWhereInput[]
    OR?: ProductThumbnailWhereInput[]
    NOT?: ProductThumbnailWhereInput | ProductThumbnailWhereInput[]
    id?: StringFilter<"ProductThumbnail"> | string
    increment?: IntFilter<"ProductThumbnail"> | number
    product_id?: StringFilter<"ProductThumbnail"> | string
    image_url?: StringFilter<"ProductThumbnail"> | string
    Product?: XOR<ProductRelationFilter, ProductWhereInput>
  }

  export type ProductThumbnailOrderByWithRelationInput = {
    id?: SortOrder
    increment?: SortOrder
    product_id?: SortOrder
    image_url?: SortOrder
    Product?: ProductOrderByWithRelationInput
  }

  export type ProductThumbnailWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    increment?: number
    AND?: ProductThumbnailWhereInput | ProductThumbnailWhereInput[]
    OR?: ProductThumbnailWhereInput[]
    NOT?: ProductThumbnailWhereInput | ProductThumbnailWhereInput[]
    product_id?: StringFilter<"ProductThumbnail"> | string
    image_url?: StringFilter<"ProductThumbnail"> | string
    Product?: XOR<ProductRelationFilter, ProductWhereInput>
  }, "id" | "increment">

  export type ProductThumbnailOrderByWithAggregationInput = {
    id?: SortOrder
    increment?: SortOrder
    product_id?: SortOrder
    image_url?: SortOrder
    _count?: ProductThumbnailCountOrderByAggregateInput
    _avg?: ProductThumbnailAvgOrderByAggregateInput
    _max?: ProductThumbnailMaxOrderByAggregateInput
    _min?: ProductThumbnailMinOrderByAggregateInput
    _sum?: ProductThumbnailSumOrderByAggregateInput
  }

  export type ProductThumbnailScalarWhereWithAggregatesInput = {
    AND?: ProductThumbnailScalarWhereWithAggregatesInput | ProductThumbnailScalarWhereWithAggregatesInput[]
    OR?: ProductThumbnailScalarWhereWithAggregatesInput[]
    NOT?: ProductThumbnailScalarWhereWithAggregatesInput | ProductThumbnailScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"ProductThumbnail"> | string
    increment?: IntWithAggregatesFilter<"ProductThumbnail"> | number
    product_id?: StringWithAggregatesFilter<"ProductThumbnail"> | string
    image_url?: StringWithAggregatesFilter<"ProductThumbnail"> | string
  }

  export type ProductCategoryWhereInput = {
    AND?: ProductCategoryWhereInput | ProductCategoryWhereInput[]
    OR?: ProductCategoryWhereInput[]
    NOT?: ProductCategoryWhereInput | ProductCategoryWhereInput[]
    id?: StringFilter<"ProductCategory"> | string
    product_id?: StringFilter<"ProductCategory"> | string
    category_id?: StringFilter<"ProductCategory"> | string
    Product?: XOR<ProductRelationFilter, ProductWhereInput>
    Category?: XOR<CategoryRelationFilter, CategoryWhereInput>
  }

  export type ProductCategoryOrderByWithRelationInput = {
    id?: SortOrder
    product_id?: SortOrder
    category_id?: SortOrder
    Product?: ProductOrderByWithRelationInput
    Category?: CategoryOrderByWithRelationInput
  }

  export type ProductCategoryWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: ProductCategoryWhereInput | ProductCategoryWhereInput[]
    OR?: ProductCategoryWhereInput[]
    NOT?: ProductCategoryWhereInput | ProductCategoryWhereInput[]
    product_id?: StringFilter<"ProductCategory"> | string
    category_id?: StringFilter<"ProductCategory"> | string
    Product?: XOR<ProductRelationFilter, ProductWhereInput>
    Category?: XOR<CategoryRelationFilter, CategoryWhereInput>
  }, "id">

  export type ProductCategoryOrderByWithAggregationInput = {
    id?: SortOrder
    product_id?: SortOrder
    category_id?: SortOrder
    _count?: ProductCategoryCountOrderByAggregateInput
    _max?: ProductCategoryMaxOrderByAggregateInput
    _min?: ProductCategoryMinOrderByAggregateInput
  }

  export type ProductCategoryScalarWhereWithAggregatesInput = {
    AND?: ProductCategoryScalarWhereWithAggregatesInput | ProductCategoryScalarWhereWithAggregatesInput[]
    OR?: ProductCategoryScalarWhereWithAggregatesInput[]
    NOT?: ProductCategoryScalarWhereWithAggregatesInput | ProductCategoryScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"ProductCategory"> | string
    product_id?: StringWithAggregatesFilter<"ProductCategory"> | string
    category_id?: StringWithAggregatesFilter<"ProductCategory"> | string
  }

  export type ProductVariationWhereInput = {
    AND?: ProductVariationWhereInput | ProductVariationWhereInput[]
    OR?: ProductVariationWhereInput[]
    NOT?: ProductVariationWhereInput | ProductVariationWhereInput[]
    id?: StringFilter<"ProductVariation"> | string
    increment?: IntFilter<"ProductVariation"> | number
    product_id?: StringFilter<"ProductVariation"> | string
    name?: StringFilter<"ProductVariation"> | string
    price?: DecimalFilter<"ProductVariation"> | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFilter<"ProductVariation"> | Date | string
    updated_at?: DateTimeFilter<"ProductVariation"> | Date | string
    ProductOrders?: ProductOrderListRelationFilter
    Product?: XOR<ProductRelationFilter, ProductWhereInput>
  }

  export type ProductVariationOrderByWithRelationInput = {
    id?: SortOrder
    increment?: SortOrder
    product_id?: SortOrder
    name?: SortOrder
    price?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    ProductOrders?: ProductOrderOrderByRelationAggregateInput
    Product?: ProductOrderByWithRelationInput
  }

  export type ProductVariationWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    increment?: number
    AND?: ProductVariationWhereInput | ProductVariationWhereInput[]
    OR?: ProductVariationWhereInput[]
    NOT?: ProductVariationWhereInput | ProductVariationWhereInput[]
    product_id?: StringFilter<"ProductVariation"> | string
    name?: StringFilter<"ProductVariation"> | string
    price?: DecimalFilter<"ProductVariation"> | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFilter<"ProductVariation"> | Date | string
    updated_at?: DateTimeFilter<"ProductVariation"> | Date | string
    ProductOrders?: ProductOrderListRelationFilter
    Product?: XOR<ProductRelationFilter, ProductWhereInput>
  }, "id" | "increment">

  export type ProductVariationOrderByWithAggregationInput = {
    id?: SortOrder
    increment?: SortOrder
    product_id?: SortOrder
    name?: SortOrder
    price?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: ProductVariationCountOrderByAggregateInput
    _avg?: ProductVariationAvgOrderByAggregateInput
    _max?: ProductVariationMaxOrderByAggregateInput
    _min?: ProductVariationMinOrderByAggregateInput
    _sum?: ProductVariationSumOrderByAggregateInput
  }

  export type ProductVariationScalarWhereWithAggregatesInput = {
    AND?: ProductVariationScalarWhereWithAggregatesInput | ProductVariationScalarWhereWithAggregatesInput[]
    OR?: ProductVariationScalarWhereWithAggregatesInput[]
    NOT?: ProductVariationScalarWhereWithAggregatesInput | ProductVariationScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"ProductVariation"> | string
    increment?: IntWithAggregatesFilter<"ProductVariation"> | number
    product_id?: StringWithAggregatesFilter<"ProductVariation"> | string
    name?: StringWithAggregatesFilter<"ProductVariation"> | string
    price?: DecimalWithAggregatesFilter<"ProductVariation"> | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeWithAggregatesFilter<"ProductVariation"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"ProductVariation"> | Date | string
  }

  export type ProductIncludeWhereInput = {
    AND?: ProductIncludeWhereInput | ProductIncludeWhereInput[]
    OR?: ProductIncludeWhereInput[]
    NOT?: ProductIncludeWhereInput | ProductIncludeWhereInput[]
    id?: StringFilter<"ProductInclude"> | string
    increment?: IntFilter<"ProductInclude"> | number
    product_id?: StringFilter<"ProductInclude"> | string
    description?: StringFilter<"ProductInclude"> | string
    Product?: XOR<ProductRelationFilter, ProductWhereInput>
  }

  export type ProductIncludeOrderByWithRelationInput = {
    id?: SortOrder
    increment?: SortOrder
    product_id?: SortOrder
    description?: SortOrder
    Product?: ProductOrderByWithRelationInput
  }

  export type ProductIncludeWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    increment?: number
    AND?: ProductIncludeWhereInput | ProductIncludeWhereInput[]
    OR?: ProductIncludeWhereInput[]
    NOT?: ProductIncludeWhereInput | ProductIncludeWhereInput[]
    product_id?: StringFilter<"ProductInclude"> | string
    description?: StringFilter<"ProductInclude"> | string
    Product?: XOR<ProductRelationFilter, ProductWhereInput>
  }, "id" | "increment">

  export type ProductIncludeOrderByWithAggregationInput = {
    id?: SortOrder
    increment?: SortOrder
    product_id?: SortOrder
    description?: SortOrder
    _count?: ProductIncludeCountOrderByAggregateInput
    _avg?: ProductIncludeAvgOrderByAggregateInput
    _max?: ProductIncludeMaxOrderByAggregateInput
    _min?: ProductIncludeMinOrderByAggregateInput
    _sum?: ProductIncludeSumOrderByAggregateInput
  }

  export type ProductIncludeScalarWhereWithAggregatesInput = {
    AND?: ProductIncludeScalarWhereWithAggregatesInput | ProductIncludeScalarWhereWithAggregatesInput[]
    OR?: ProductIncludeScalarWhereWithAggregatesInput[]
    NOT?: ProductIncludeScalarWhereWithAggregatesInput | ProductIncludeScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"ProductInclude"> | string
    increment?: IntWithAggregatesFilter<"ProductInclude"> | number
    product_id?: StringWithAggregatesFilter<"ProductInclude"> | string
    description?: StringWithAggregatesFilter<"ProductInclude"> | string
  }

  export type ProductExcludeWhereInput = {
    AND?: ProductExcludeWhereInput | ProductExcludeWhereInput[]
    OR?: ProductExcludeWhereInput[]
    NOT?: ProductExcludeWhereInput | ProductExcludeWhereInput[]
    id?: StringFilter<"ProductExclude"> | string
    increment?: IntFilter<"ProductExclude"> | number
    product_id?: StringFilter<"ProductExclude"> | string
    description?: StringFilter<"ProductExclude"> | string
    Product?: XOR<ProductRelationFilter, ProductWhereInput>
  }

  export type ProductExcludeOrderByWithRelationInput = {
    id?: SortOrder
    increment?: SortOrder
    product_id?: SortOrder
    description?: SortOrder
    Product?: ProductOrderByWithRelationInput
  }

  export type ProductExcludeWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    increment?: number
    AND?: ProductExcludeWhereInput | ProductExcludeWhereInput[]
    OR?: ProductExcludeWhereInput[]
    NOT?: ProductExcludeWhereInput | ProductExcludeWhereInput[]
    product_id?: StringFilter<"ProductExclude"> | string
    description?: StringFilter<"ProductExclude"> | string
    Product?: XOR<ProductRelationFilter, ProductWhereInput>
  }, "id" | "increment">

  export type ProductExcludeOrderByWithAggregationInput = {
    id?: SortOrder
    increment?: SortOrder
    product_id?: SortOrder
    description?: SortOrder
    _count?: ProductExcludeCountOrderByAggregateInput
    _avg?: ProductExcludeAvgOrderByAggregateInput
    _max?: ProductExcludeMaxOrderByAggregateInput
    _min?: ProductExcludeMinOrderByAggregateInput
    _sum?: ProductExcludeSumOrderByAggregateInput
  }

  export type ProductExcludeScalarWhereWithAggregatesInput = {
    AND?: ProductExcludeScalarWhereWithAggregatesInput | ProductExcludeScalarWhereWithAggregatesInput[]
    OR?: ProductExcludeScalarWhereWithAggregatesInput[]
    NOT?: ProductExcludeScalarWhereWithAggregatesInput | ProductExcludeScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"ProductExclude"> | string
    increment?: IntWithAggregatesFilter<"ProductExclude"> | number
    product_id?: StringWithAggregatesFilter<"ProductExclude"> | string
    description?: StringWithAggregatesFilter<"ProductExclude"> | string
  }

  export type ProductOrderWhereInput = {
    AND?: ProductOrderWhereInput | ProductOrderWhereInput[]
    OR?: ProductOrderWhereInput[]
    NOT?: ProductOrderWhereInput | ProductOrderWhereInput[]
    id?: StringFilter<"ProductOrder"> | string
    user_id?: StringFilter<"ProductOrder"> | string
    product_id?: StringFilter<"ProductOrder"> | string
    variation_id?: StringNullableFilter<"ProductOrder"> | string | null
    departure?: DateTimeFilter<"ProductOrder"> | Date | string
    number_of_pax?: IntFilter<"ProductOrder"> | number
    per_pax_price?: DecimalFilter<"ProductOrder"> | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFilter<"ProductOrder"> | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFilter<"ProductOrder"> | Date | string
    updated_at?: DateTimeFilter<"ProductOrder"> | Date | string
    User?: XOR<UserRelationFilter, UserWhereInput>
    Product?: XOR<ProductRelationFilter, ProductWhereInput>
    ProductVariation?: XOR<ProductVariationNullableRelationFilter, ProductVariationWhereInput> | null
  }

  export type ProductOrderOrderByWithRelationInput = {
    id?: SortOrder
    user_id?: SortOrder
    product_id?: SortOrder
    variation_id?: SortOrderInput | SortOrder
    departure?: SortOrder
    number_of_pax?: SortOrder
    per_pax_price?: SortOrder
    total_price?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    User?: UserOrderByWithRelationInput
    Product?: ProductOrderByWithRelationInput
    ProductVariation?: ProductVariationOrderByWithRelationInput
  }

  export type ProductOrderWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: ProductOrderWhereInput | ProductOrderWhereInput[]
    OR?: ProductOrderWhereInput[]
    NOT?: ProductOrderWhereInput | ProductOrderWhereInput[]
    user_id?: StringFilter<"ProductOrder"> | string
    product_id?: StringFilter<"ProductOrder"> | string
    variation_id?: StringNullableFilter<"ProductOrder"> | string | null
    departure?: DateTimeFilter<"ProductOrder"> | Date | string
    number_of_pax?: IntFilter<"ProductOrder"> | number
    per_pax_price?: DecimalFilter<"ProductOrder"> | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFilter<"ProductOrder"> | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFilter<"ProductOrder"> | Date | string
    updated_at?: DateTimeFilter<"ProductOrder"> | Date | string
    User?: XOR<UserRelationFilter, UserWhereInput>
    Product?: XOR<ProductRelationFilter, ProductWhereInput>
    ProductVariation?: XOR<ProductVariationNullableRelationFilter, ProductVariationWhereInput> | null
  }, "id">

  export type ProductOrderOrderByWithAggregationInput = {
    id?: SortOrder
    user_id?: SortOrder
    product_id?: SortOrder
    variation_id?: SortOrderInput | SortOrder
    departure?: SortOrder
    number_of_pax?: SortOrder
    per_pax_price?: SortOrder
    total_price?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: ProductOrderCountOrderByAggregateInput
    _avg?: ProductOrderAvgOrderByAggregateInput
    _max?: ProductOrderMaxOrderByAggregateInput
    _min?: ProductOrderMinOrderByAggregateInput
    _sum?: ProductOrderSumOrderByAggregateInput
  }

  export type ProductOrderScalarWhereWithAggregatesInput = {
    AND?: ProductOrderScalarWhereWithAggregatesInput | ProductOrderScalarWhereWithAggregatesInput[]
    OR?: ProductOrderScalarWhereWithAggregatesInput[]
    NOT?: ProductOrderScalarWhereWithAggregatesInput | ProductOrderScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"ProductOrder"> | string
    user_id?: StringWithAggregatesFilter<"ProductOrder"> | string
    product_id?: StringWithAggregatesFilter<"ProductOrder"> | string
    variation_id?: StringNullableWithAggregatesFilter<"ProductOrder"> | string | null
    departure?: DateTimeWithAggregatesFilter<"ProductOrder"> | Date | string
    number_of_pax?: IntWithAggregatesFilter<"ProductOrder"> | number
    per_pax_price?: DecimalWithAggregatesFilter<"ProductOrder"> | Decimal | DecimalJsLike | number | string
    total_price?: DecimalWithAggregatesFilter<"ProductOrder"> | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeWithAggregatesFilter<"ProductOrder"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"ProductOrder"> | Date | string
  }

  export type VendorWhereInput = {
    AND?: VendorWhereInput | VendorWhereInput[]
    OR?: VendorWhereInput[]
    NOT?: VendorWhereInput | VendorWhereInput[]
    id?: StringFilter<"Vendor"> | string
    name?: StringFilter<"Vendor"> | string
    created_at?: DateTimeFilter<"Vendor"> | Date | string
    updated_at?: DateTimeFilter<"Vendor"> | Date | string
    Hotels?: HotelListRelationFilter
    MitraPackages?: MitraPackageListRelationFilter
  }

  export type VendorOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    Hotels?: HotelOrderByRelationAggregateInput
    MitraPackages?: MitraPackageOrderByRelationAggregateInput
  }

  export type VendorWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: VendorWhereInput | VendorWhereInput[]
    OR?: VendorWhereInput[]
    NOT?: VendorWhereInput | VendorWhereInput[]
    name?: StringFilter<"Vendor"> | string
    created_at?: DateTimeFilter<"Vendor"> | Date | string
    updated_at?: DateTimeFilter<"Vendor"> | Date | string
    Hotels?: HotelListRelationFilter
    MitraPackages?: MitraPackageListRelationFilter
  }, "id">

  export type VendorOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: VendorCountOrderByAggregateInput
    _max?: VendorMaxOrderByAggregateInput
    _min?: VendorMinOrderByAggregateInput
  }

  export type VendorScalarWhereWithAggregatesInput = {
    AND?: VendorScalarWhereWithAggregatesInput | VendorScalarWhereWithAggregatesInput[]
    OR?: VendorScalarWhereWithAggregatesInput[]
    NOT?: VendorScalarWhereWithAggregatesInput | VendorScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Vendor"> | string
    name?: StringWithAggregatesFilter<"Vendor"> | string
    created_at?: DateTimeWithAggregatesFilter<"Vendor"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"Vendor"> | Date | string
  }

  export type HotelWhereInput = {
    AND?: HotelWhereInput | HotelWhereInput[]
    OR?: HotelWhereInput[]
    NOT?: HotelWhereInput | HotelWhereInput[]
    id?: StringFilter<"Hotel"> | string
    vendor_id?: StringFilter<"Hotel"> | string
    name?: StringFilter<"Hotel"> | string
    city?: EnumCityFilter<"Hotel"> | $Enums.City
    order_number?: IntFilter<"Hotel"> | number
    created_at?: DateTimeFilter<"Hotel"> | Date | string
    updated_at?: DateTimeFilter<"Hotel"> | Date | string
    Vendor?: XOR<VendorRelationFilter, VendorWhereInput>
    HotelPeriodPrices?: HotelPeriodPriceListRelationFilter
    MitraPackagesMekkah?: MitraPackageListRelationFilter
    MitraPackagesMadinah?: MitraPackageListRelationFilter
  }

  export type HotelOrderByWithRelationInput = {
    id?: SortOrder
    vendor_id?: SortOrder
    name?: SortOrder
    city?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    Vendor?: VendorOrderByWithRelationInput
    HotelPeriodPrices?: HotelPeriodPriceOrderByRelationAggregateInput
    MitraPackagesMekkah?: MitraPackageOrderByRelationAggregateInput
    MitraPackagesMadinah?: MitraPackageOrderByRelationAggregateInput
  }

  export type HotelWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: HotelWhereInput | HotelWhereInput[]
    OR?: HotelWhereInput[]
    NOT?: HotelWhereInput | HotelWhereInput[]
    vendor_id?: StringFilter<"Hotel"> | string
    name?: StringFilter<"Hotel"> | string
    city?: EnumCityFilter<"Hotel"> | $Enums.City
    order_number?: IntFilter<"Hotel"> | number
    created_at?: DateTimeFilter<"Hotel"> | Date | string
    updated_at?: DateTimeFilter<"Hotel"> | Date | string
    Vendor?: XOR<VendorRelationFilter, VendorWhereInput>
    HotelPeriodPrices?: HotelPeriodPriceListRelationFilter
    MitraPackagesMekkah?: MitraPackageListRelationFilter
    MitraPackagesMadinah?: MitraPackageListRelationFilter
  }, "id">

  export type HotelOrderByWithAggregationInput = {
    id?: SortOrder
    vendor_id?: SortOrder
    name?: SortOrder
    city?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: HotelCountOrderByAggregateInput
    _avg?: HotelAvgOrderByAggregateInput
    _max?: HotelMaxOrderByAggregateInput
    _min?: HotelMinOrderByAggregateInput
    _sum?: HotelSumOrderByAggregateInput
  }

  export type HotelScalarWhereWithAggregatesInput = {
    AND?: HotelScalarWhereWithAggregatesInput | HotelScalarWhereWithAggregatesInput[]
    OR?: HotelScalarWhereWithAggregatesInput[]
    NOT?: HotelScalarWhereWithAggregatesInput | HotelScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Hotel"> | string
    vendor_id?: StringWithAggregatesFilter<"Hotel"> | string
    name?: StringWithAggregatesFilter<"Hotel"> | string
    city?: EnumCityWithAggregatesFilter<"Hotel"> | $Enums.City
    order_number?: IntWithAggregatesFilter<"Hotel"> | number
    created_at?: DateTimeWithAggregatesFilter<"Hotel"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"Hotel"> | Date | string
  }

  export type PeriodWhereInput = {
    AND?: PeriodWhereInput | PeriodWhereInput[]
    OR?: PeriodWhereInput[]
    NOT?: PeriodWhereInput | PeriodWhereInput[]
    id?: StringFilter<"Period"> | string
    category?: EnumPeriodCategoryFilter<"Period"> | $Enums.PeriodCategory
    start_date?: DateTimeFilter<"Period"> | Date | string
    end_date?: DateTimeFilter<"Period"> | Date | string
    created_at?: DateTimeFilter<"Period"> | Date | string
    updated_at?: DateTimeFilter<"Period"> | Date | string
    HotelPeriodPrices?: HotelPeriodPriceListRelationFilter
    MitraPackages?: MitraPackageListRelationFilter
  }

  export type PeriodOrderByWithRelationInput = {
    id?: SortOrder
    category?: SortOrder
    start_date?: SortOrder
    end_date?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    HotelPeriodPrices?: HotelPeriodPriceOrderByRelationAggregateInput
    MitraPackages?: MitraPackageOrderByRelationAggregateInput
  }

  export type PeriodWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: PeriodWhereInput | PeriodWhereInput[]
    OR?: PeriodWhereInput[]
    NOT?: PeriodWhereInput | PeriodWhereInput[]
    category?: EnumPeriodCategoryFilter<"Period"> | $Enums.PeriodCategory
    start_date?: DateTimeFilter<"Period"> | Date | string
    end_date?: DateTimeFilter<"Period"> | Date | string
    created_at?: DateTimeFilter<"Period"> | Date | string
    updated_at?: DateTimeFilter<"Period"> | Date | string
    HotelPeriodPrices?: HotelPeriodPriceListRelationFilter
    MitraPackages?: MitraPackageListRelationFilter
  }, "id">

  export type PeriodOrderByWithAggregationInput = {
    id?: SortOrder
    category?: SortOrder
    start_date?: SortOrder
    end_date?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: PeriodCountOrderByAggregateInput
    _max?: PeriodMaxOrderByAggregateInput
    _min?: PeriodMinOrderByAggregateInput
  }

  export type PeriodScalarWhereWithAggregatesInput = {
    AND?: PeriodScalarWhereWithAggregatesInput | PeriodScalarWhereWithAggregatesInput[]
    OR?: PeriodScalarWhereWithAggregatesInput[]
    NOT?: PeriodScalarWhereWithAggregatesInput | PeriodScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Period"> | string
    category?: EnumPeriodCategoryWithAggregatesFilter<"Period"> | $Enums.PeriodCategory
    start_date?: DateTimeWithAggregatesFilter<"Period"> | Date | string
    end_date?: DateTimeWithAggregatesFilter<"Period"> | Date | string
    created_at?: DateTimeWithAggregatesFilter<"Period"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"Period"> | Date | string
  }

  export type HotelPeriodPriceWhereInput = {
    AND?: HotelPeriodPriceWhereInput | HotelPeriodPriceWhereInput[]
    OR?: HotelPeriodPriceWhereInput[]
    NOT?: HotelPeriodPriceWhereInput | HotelPeriodPriceWhereInput[]
    id?: StringFilter<"HotelPeriodPrice"> | string
    hotel_id?: StringFilter<"HotelPeriodPrice"> | string
    period_id?: StringFilter<"HotelPeriodPrice"> | string
    price_double?: DecimalFilter<"HotelPeriodPrice"> | Decimal | DecimalJsLike | number | string
    price_triple?: DecimalFilter<"HotelPeriodPrice"> | Decimal | DecimalJsLike | number | string
    price_quad?: DecimalFilter<"HotelPeriodPrice"> | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFilter<"HotelPeriodPrice"> | Date | string
    updated_at?: DateTimeFilter<"HotelPeriodPrice"> | Date | string
    Hotel?: XOR<HotelRelationFilter, HotelWhereInput>
    Period?: XOR<PeriodRelationFilter, PeriodWhereInput>
  }

  export type HotelPeriodPriceOrderByWithRelationInput = {
    id?: SortOrder
    hotel_id?: SortOrder
    period_id?: SortOrder
    price_double?: SortOrder
    price_triple?: SortOrder
    price_quad?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    Hotel?: HotelOrderByWithRelationInput
    Period?: PeriodOrderByWithRelationInput
  }

  export type HotelPeriodPriceWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    hotel_id_period_id?: HotelPeriodPriceHotel_idPeriod_idCompoundUniqueInput
    AND?: HotelPeriodPriceWhereInput | HotelPeriodPriceWhereInput[]
    OR?: HotelPeriodPriceWhereInput[]
    NOT?: HotelPeriodPriceWhereInput | HotelPeriodPriceWhereInput[]
    hotel_id?: StringFilter<"HotelPeriodPrice"> | string
    period_id?: StringFilter<"HotelPeriodPrice"> | string
    price_double?: DecimalFilter<"HotelPeriodPrice"> | Decimal | DecimalJsLike | number | string
    price_triple?: DecimalFilter<"HotelPeriodPrice"> | Decimal | DecimalJsLike | number | string
    price_quad?: DecimalFilter<"HotelPeriodPrice"> | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFilter<"HotelPeriodPrice"> | Date | string
    updated_at?: DateTimeFilter<"HotelPeriodPrice"> | Date | string
    Hotel?: XOR<HotelRelationFilter, HotelWhereInput>
    Period?: XOR<PeriodRelationFilter, PeriodWhereInput>
  }, "id" | "hotel_id_period_id">

  export type HotelPeriodPriceOrderByWithAggregationInput = {
    id?: SortOrder
    hotel_id?: SortOrder
    period_id?: SortOrder
    price_double?: SortOrder
    price_triple?: SortOrder
    price_quad?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: HotelPeriodPriceCountOrderByAggregateInput
    _avg?: HotelPeriodPriceAvgOrderByAggregateInput
    _max?: HotelPeriodPriceMaxOrderByAggregateInput
    _min?: HotelPeriodPriceMinOrderByAggregateInput
    _sum?: HotelPeriodPriceSumOrderByAggregateInput
  }

  export type HotelPeriodPriceScalarWhereWithAggregatesInput = {
    AND?: HotelPeriodPriceScalarWhereWithAggregatesInput | HotelPeriodPriceScalarWhereWithAggregatesInput[]
    OR?: HotelPeriodPriceScalarWhereWithAggregatesInput[]
    NOT?: HotelPeriodPriceScalarWhereWithAggregatesInput | HotelPeriodPriceScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"HotelPeriodPrice"> | string
    hotel_id?: StringWithAggregatesFilter<"HotelPeriodPrice"> | string
    period_id?: StringWithAggregatesFilter<"HotelPeriodPrice"> | string
    price_double?: DecimalWithAggregatesFilter<"HotelPeriodPrice"> | Decimal | DecimalJsLike | number | string
    price_triple?: DecimalWithAggregatesFilter<"HotelPeriodPrice"> | Decimal | DecimalJsLike | number | string
    price_quad?: DecimalWithAggregatesFilter<"HotelPeriodPrice"> | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeWithAggregatesFilter<"HotelPeriodPrice"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"HotelPeriodPrice"> | Date | string
  }

  export type AirlineWhereInput = {
    AND?: AirlineWhereInput | AirlineWhereInput[]
    OR?: AirlineWhereInput[]
    NOT?: AirlineWhereInput | AirlineWhereInput[]
    id?: StringFilter<"Airline"> | string
    name?: StringFilter<"Airline"> | string
    price_idr?: DecimalFilter<"Airline"> | Decimal | DecimalJsLike | number | string
    order_number?: IntFilter<"Airline"> | number
    created_at?: DateTimeFilter<"Airline"> | Date | string
    updated_at?: DateTimeFilter<"Airline"> | Date | string
    MitraPackages?: MitraPackageListRelationFilter
  }

  export type AirlineOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    MitraPackages?: MitraPackageOrderByRelationAggregateInput
  }

  export type AirlineWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: AirlineWhereInput | AirlineWhereInput[]
    OR?: AirlineWhereInput[]
    NOT?: AirlineWhereInput | AirlineWhereInput[]
    name?: StringFilter<"Airline"> | string
    price_idr?: DecimalFilter<"Airline"> | Decimal | DecimalJsLike | number | string
    order_number?: IntFilter<"Airline"> | number
    created_at?: DateTimeFilter<"Airline"> | Date | string
    updated_at?: DateTimeFilter<"Airline"> | Date | string
    MitraPackages?: MitraPackageListRelationFilter
  }, "id">

  export type AirlineOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: AirlineCountOrderByAggregateInput
    _avg?: AirlineAvgOrderByAggregateInput
    _max?: AirlineMaxOrderByAggregateInput
    _min?: AirlineMinOrderByAggregateInput
    _sum?: AirlineSumOrderByAggregateInput
  }

  export type AirlineScalarWhereWithAggregatesInput = {
    AND?: AirlineScalarWhereWithAggregatesInput | AirlineScalarWhereWithAggregatesInput[]
    OR?: AirlineScalarWhereWithAggregatesInput[]
    NOT?: AirlineScalarWhereWithAggregatesInput | AirlineScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Airline"> | string
    name?: StringWithAggregatesFilter<"Airline"> | string
    price_idr?: DecimalWithAggregatesFilter<"Airline"> | Decimal | DecimalJsLike | number | string
    order_number?: IntWithAggregatesFilter<"Airline"> | number
    created_at?: DateTimeWithAggregatesFilter<"Airline"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"Airline"> | Date | string
  }

  export type VisaWhereInput = {
    AND?: VisaWhereInput | VisaWhereInput[]
    OR?: VisaWhereInput[]
    NOT?: VisaWhereInput | VisaWhereInput[]
    id?: StringFilter<"Visa"> | string
    name?: StringFilter<"Visa"> | string
    price_idr?: DecimalFilter<"Visa"> | Decimal | DecimalJsLike | number | string
    order_number?: IntFilter<"Visa"> | number
    created_at?: DateTimeFilter<"Visa"> | Date | string
    updated_at?: DateTimeFilter<"Visa"> | Date | string
    MitraPackages?: MitraPackageListRelationFilter
  }

  export type VisaOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    MitraPackages?: MitraPackageOrderByRelationAggregateInput
  }

  export type VisaWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: VisaWhereInput | VisaWhereInput[]
    OR?: VisaWhereInput[]
    NOT?: VisaWhereInput | VisaWhereInput[]
    name?: StringFilter<"Visa"> | string
    price_idr?: DecimalFilter<"Visa"> | Decimal | DecimalJsLike | number | string
    order_number?: IntFilter<"Visa"> | number
    created_at?: DateTimeFilter<"Visa"> | Date | string
    updated_at?: DateTimeFilter<"Visa"> | Date | string
    MitraPackages?: MitraPackageListRelationFilter
  }, "id">

  export type VisaOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: VisaCountOrderByAggregateInput
    _avg?: VisaAvgOrderByAggregateInput
    _max?: VisaMaxOrderByAggregateInput
    _min?: VisaMinOrderByAggregateInput
    _sum?: VisaSumOrderByAggregateInput
  }

  export type VisaScalarWhereWithAggregatesInput = {
    AND?: VisaScalarWhereWithAggregatesInput | VisaScalarWhereWithAggregatesInput[]
    OR?: VisaScalarWhereWithAggregatesInput[]
    NOT?: VisaScalarWhereWithAggregatesInput | VisaScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Visa"> | string
    name?: StringWithAggregatesFilter<"Visa"> | string
    price_idr?: DecimalWithAggregatesFilter<"Visa"> | Decimal | DecimalJsLike | number | string
    order_number?: IntWithAggregatesFilter<"Visa"> | number
    created_at?: DateTimeWithAggregatesFilter<"Visa"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"Visa"> | Date | string
  }

  export type TransportationWhereInput = {
    AND?: TransportationWhereInput | TransportationWhereInput[]
    OR?: TransportationWhereInput[]
    NOT?: TransportationWhereInput | TransportationWhereInput[]
    id?: StringFilter<"Transportation"> | string
    name?: StringFilter<"Transportation"> | string
    price_idr?: DecimalFilter<"Transportation"> | Decimal | DecimalJsLike | number | string
    order_number?: IntFilter<"Transportation"> | number
    created_at?: DateTimeFilter<"Transportation"> | Date | string
    updated_at?: DateTimeFilter<"Transportation"> | Date | string
    MitraPackage?: MitraPackageListRelationFilter
  }

  export type TransportationOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    MitraPackage?: MitraPackageOrderByRelationAggregateInput
  }

  export type TransportationWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: TransportationWhereInput | TransportationWhereInput[]
    OR?: TransportationWhereInput[]
    NOT?: TransportationWhereInput | TransportationWhereInput[]
    name?: StringFilter<"Transportation"> | string
    price_idr?: DecimalFilter<"Transportation"> | Decimal | DecimalJsLike | number | string
    order_number?: IntFilter<"Transportation"> | number
    created_at?: DateTimeFilter<"Transportation"> | Date | string
    updated_at?: DateTimeFilter<"Transportation"> | Date | string
    MitraPackage?: MitraPackageListRelationFilter
  }, "id">

  export type TransportationOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: TransportationCountOrderByAggregateInput
    _avg?: TransportationAvgOrderByAggregateInput
    _max?: TransportationMaxOrderByAggregateInput
    _min?: TransportationMinOrderByAggregateInput
    _sum?: TransportationSumOrderByAggregateInput
  }

  export type TransportationScalarWhereWithAggregatesInput = {
    AND?: TransportationScalarWhereWithAggregatesInput | TransportationScalarWhereWithAggregatesInput[]
    OR?: TransportationScalarWhereWithAggregatesInput[]
    NOT?: TransportationScalarWhereWithAggregatesInput | TransportationScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Transportation"> | string
    name?: StringWithAggregatesFilter<"Transportation"> | string
    price_idr?: DecimalWithAggregatesFilter<"Transportation"> | Decimal | DecimalJsLike | number | string
    order_number?: IntWithAggregatesFilter<"Transportation"> | number
    created_at?: DateTimeWithAggregatesFilter<"Transportation"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"Transportation"> | Date | string
  }

  export type MuthawifWhereInput = {
    AND?: MuthawifWhereInput | MuthawifWhereInput[]
    OR?: MuthawifWhereInput[]
    NOT?: MuthawifWhereInput | MuthawifWhereInput[]
    id?: StringFilter<"Muthawif"> | string
    name?: StringFilter<"Muthawif"> | string
    price_idr?: DecimalFilter<"Muthawif"> | Decimal | DecimalJsLike | number | string
    order_number?: IntFilter<"Muthawif"> | number
    created_at?: DateTimeFilter<"Muthawif"> | Date | string
    updated_at?: DateTimeFilter<"Muthawif"> | Date | string
    MitraPackages?: MitraPackageListRelationFilter
  }

  export type MuthawifOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    MitraPackages?: MitraPackageOrderByRelationAggregateInput
  }

  export type MuthawifWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: MuthawifWhereInput | MuthawifWhereInput[]
    OR?: MuthawifWhereInput[]
    NOT?: MuthawifWhereInput | MuthawifWhereInput[]
    name?: StringFilter<"Muthawif"> | string
    price_idr?: DecimalFilter<"Muthawif"> | Decimal | DecimalJsLike | number | string
    order_number?: IntFilter<"Muthawif"> | number
    created_at?: DateTimeFilter<"Muthawif"> | Date | string
    updated_at?: DateTimeFilter<"Muthawif"> | Date | string
    MitraPackages?: MitraPackageListRelationFilter
  }, "id">

  export type MuthawifOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: MuthawifCountOrderByAggregateInput
    _avg?: MuthawifAvgOrderByAggregateInput
    _max?: MuthawifMaxOrderByAggregateInput
    _min?: MuthawifMinOrderByAggregateInput
    _sum?: MuthawifSumOrderByAggregateInput
  }

  export type MuthawifScalarWhereWithAggregatesInput = {
    AND?: MuthawifScalarWhereWithAggregatesInput | MuthawifScalarWhereWithAggregatesInput[]
    OR?: MuthawifScalarWhereWithAggregatesInput[]
    NOT?: MuthawifScalarWhereWithAggregatesInput | MuthawifScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Muthawif"> | string
    name?: StringWithAggregatesFilter<"Muthawif"> | string
    price_idr?: DecimalWithAggregatesFilter<"Muthawif"> | Decimal | DecimalJsLike | number | string
    order_number?: IntWithAggregatesFilter<"Muthawif"> | number
    created_at?: DateTimeWithAggregatesFilter<"Muthawif"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"Muthawif"> | Date | string
  }

  export type HandlingSaudiWhereInput = {
    AND?: HandlingSaudiWhereInput | HandlingSaudiWhereInput[]
    OR?: HandlingSaudiWhereInput[]
    NOT?: HandlingSaudiWhereInput | HandlingSaudiWhereInput[]
    id?: StringFilter<"HandlingSaudi"> | string
    name?: StringFilter<"HandlingSaudi"> | string
    price_idr?: DecimalFilter<"HandlingSaudi"> | Decimal | DecimalJsLike | number | string
    order_number?: IntFilter<"HandlingSaudi"> | number
    created_at?: DateTimeFilter<"HandlingSaudi"> | Date | string
    updated_at?: DateTimeFilter<"HandlingSaudi"> | Date | string
    MitraPackages?: MitraPackageListRelationFilter
  }

  export type HandlingSaudiOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    MitraPackages?: MitraPackageOrderByRelationAggregateInput
  }

  export type HandlingSaudiWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: HandlingSaudiWhereInput | HandlingSaudiWhereInput[]
    OR?: HandlingSaudiWhereInput[]
    NOT?: HandlingSaudiWhereInput | HandlingSaudiWhereInput[]
    name?: StringFilter<"HandlingSaudi"> | string
    price_idr?: DecimalFilter<"HandlingSaudi"> | Decimal | DecimalJsLike | number | string
    order_number?: IntFilter<"HandlingSaudi"> | number
    created_at?: DateTimeFilter<"HandlingSaudi"> | Date | string
    updated_at?: DateTimeFilter<"HandlingSaudi"> | Date | string
    MitraPackages?: MitraPackageListRelationFilter
  }, "id">

  export type HandlingSaudiOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: HandlingSaudiCountOrderByAggregateInput
    _avg?: HandlingSaudiAvgOrderByAggregateInput
    _max?: HandlingSaudiMaxOrderByAggregateInput
    _min?: HandlingSaudiMinOrderByAggregateInput
    _sum?: HandlingSaudiSumOrderByAggregateInput
  }

  export type HandlingSaudiScalarWhereWithAggregatesInput = {
    AND?: HandlingSaudiScalarWhereWithAggregatesInput | HandlingSaudiScalarWhereWithAggregatesInput[]
    OR?: HandlingSaudiScalarWhereWithAggregatesInput[]
    NOT?: HandlingSaudiScalarWhereWithAggregatesInput | HandlingSaudiScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"HandlingSaudi"> | string
    name?: StringWithAggregatesFilter<"HandlingSaudi"> | string
    price_idr?: DecimalWithAggregatesFilter<"HandlingSaudi"> | Decimal | DecimalJsLike | number | string
    order_number?: IntWithAggregatesFilter<"HandlingSaudi"> | number
    created_at?: DateTimeWithAggregatesFilter<"HandlingSaudi"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"HandlingSaudi"> | Date | string
  }

  export type HandlingDomesticWhereInput = {
    AND?: HandlingDomesticWhereInput | HandlingDomesticWhereInput[]
    OR?: HandlingDomesticWhereInput[]
    NOT?: HandlingDomesticWhereInput | HandlingDomesticWhereInput[]
    id?: StringFilter<"HandlingDomestic"> | string
    name?: StringFilter<"HandlingDomestic"> | string
    price_idr?: DecimalFilter<"HandlingDomestic"> | Decimal | DecimalJsLike | number | string
    order_number?: IntFilter<"HandlingDomestic"> | number
    created_at?: DateTimeFilter<"HandlingDomestic"> | Date | string
    updated_at?: DateTimeFilter<"HandlingDomestic"> | Date | string
    MitraPackages?: MitraPackageListRelationFilter
  }

  export type HandlingDomesticOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    MitraPackages?: MitraPackageOrderByRelationAggregateInput
  }

  export type HandlingDomesticWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: HandlingDomesticWhereInput | HandlingDomesticWhereInput[]
    OR?: HandlingDomesticWhereInput[]
    NOT?: HandlingDomesticWhereInput | HandlingDomesticWhereInput[]
    name?: StringFilter<"HandlingDomestic"> | string
    price_idr?: DecimalFilter<"HandlingDomestic"> | Decimal | DecimalJsLike | number | string
    order_number?: IntFilter<"HandlingDomestic"> | number
    created_at?: DateTimeFilter<"HandlingDomestic"> | Date | string
    updated_at?: DateTimeFilter<"HandlingDomestic"> | Date | string
    MitraPackages?: MitraPackageListRelationFilter
  }, "id">

  export type HandlingDomesticOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: HandlingDomesticCountOrderByAggregateInput
    _avg?: HandlingDomesticAvgOrderByAggregateInput
    _max?: HandlingDomesticMaxOrderByAggregateInput
    _min?: HandlingDomesticMinOrderByAggregateInput
    _sum?: HandlingDomesticSumOrderByAggregateInput
  }

  export type HandlingDomesticScalarWhereWithAggregatesInput = {
    AND?: HandlingDomesticScalarWhereWithAggregatesInput | HandlingDomesticScalarWhereWithAggregatesInput[]
    OR?: HandlingDomesticScalarWhereWithAggregatesInput[]
    NOT?: HandlingDomesticScalarWhereWithAggregatesInput | HandlingDomesticScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"HandlingDomestic"> | string
    name?: StringWithAggregatesFilter<"HandlingDomestic"> | string
    price_idr?: DecimalWithAggregatesFilter<"HandlingDomestic"> | Decimal | DecimalJsLike | number | string
    order_number?: IntWithAggregatesFilter<"HandlingDomestic"> | number
    created_at?: DateTimeWithAggregatesFilter<"HandlingDomestic"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"HandlingDomestic"> | Date | string
  }

  export type SiskopatuhWhereInput = {
    AND?: SiskopatuhWhereInput | SiskopatuhWhereInput[]
    OR?: SiskopatuhWhereInput[]
    NOT?: SiskopatuhWhereInput | SiskopatuhWhereInput[]
    id?: StringFilter<"Siskopatuh"> | string
    name?: StringFilter<"Siskopatuh"> | string
    price_idr?: DecimalFilter<"Siskopatuh"> | Decimal | DecimalJsLike | number | string
    order_number?: IntFilter<"Siskopatuh"> | number
    created_at?: DateTimeFilter<"Siskopatuh"> | Date | string
    updated_at?: DateTimeFilter<"Siskopatuh"> | Date | string
    MitraPackages?: MitraPackageListRelationFilter
  }

  export type SiskopatuhOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    MitraPackages?: MitraPackageOrderByRelationAggregateInput
  }

  export type SiskopatuhWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: SiskopatuhWhereInput | SiskopatuhWhereInput[]
    OR?: SiskopatuhWhereInput[]
    NOT?: SiskopatuhWhereInput | SiskopatuhWhereInput[]
    name?: StringFilter<"Siskopatuh"> | string
    price_idr?: DecimalFilter<"Siskopatuh"> | Decimal | DecimalJsLike | number | string
    order_number?: IntFilter<"Siskopatuh"> | number
    created_at?: DateTimeFilter<"Siskopatuh"> | Date | string
    updated_at?: DateTimeFilter<"Siskopatuh"> | Date | string
    MitraPackages?: MitraPackageListRelationFilter
  }, "id">

  export type SiskopatuhOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: SiskopatuhCountOrderByAggregateInput
    _avg?: SiskopatuhAvgOrderByAggregateInput
    _max?: SiskopatuhMaxOrderByAggregateInput
    _min?: SiskopatuhMinOrderByAggregateInput
    _sum?: SiskopatuhSumOrderByAggregateInput
  }

  export type SiskopatuhScalarWhereWithAggregatesInput = {
    AND?: SiskopatuhScalarWhereWithAggregatesInput | SiskopatuhScalarWhereWithAggregatesInput[]
    OR?: SiskopatuhScalarWhereWithAggregatesInput[]
    NOT?: SiskopatuhScalarWhereWithAggregatesInput | SiskopatuhScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Siskopatuh"> | string
    name?: StringWithAggregatesFilter<"Siskopatuh"> | string
    price_idr?: DecimalWithAggregatesFilter<"Siskopatuh"> | Decimal | DecimalJsLike | number | string
    order_number?: IntWithAggregatesFilter<"Siskopatuh"> | number
    created_at?: DateTimeWithAggregatesFilter<"Siskopatuh"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"Siskopatuh"> | Date | string
  }

  export type EquipmentWhereInput = {
    AND?: EquipmentWhereInput | EquipmentWhereInput[]
    OR?: EquipmentWhereInput[]
    NOT?: EquipmentWhereInput | EquipmentWhereInput[]
    id?: StringFilter<"Equipment"> | string
    name?: StringFilter<"Equipment"> | string
    price_idr?: DecimalFilter<"Equipment"> | Decimal | DecimalJsLike | number | string
    order_number?: IntFilter<"Equipment"> | number
    created_at?: DateTimeFilter<"Equipment"> | Date | string
    updated_at?: DateTimeFilter<"Equipment"> | Date | string
    MitraPackages?: MitraPackageListRelationFilter
  }

  export type EquipmentOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    MitraPackages?: MitraPackageOrderByRelationAggregateInput
  }

  export type EquipmentWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: EquipmentWhereInput | EquipmentWhereInput[]
    OR?: EquipmentWhereInput[]
    NOT?: EquipmentWhereInput | EquipmentWhereInput[]
    name?: StringFilter<"Equipment"> | string
    price_idr?: DecimalFilter<"Equipment"> | Decimal | DecimalJsLike | number | string
    order_number?: IntFilter<"Equipment"> | number
    created_at?: DateTimeFilter<"Equipment"> | Date | string
    updated_at?: DateTimeFilter<"Equipment"> | Date | string
    MitraPackages?: MitraPackageListRelationFilter
  }, "id">

  export type EquipmentOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: EquipmentCountOrderByAggregateInput
    _avg?: EquipmentAvgOrderByAggregateInput
    _max?: EquipmentMaxOrderByAggregateInput
    _min?: EquipmentMinOrderByAggregateInput
    _sum?: EquipmentSumOrderByAggregateInput
  }

  export type EquipmentScalarWhereWithAggregatesInput = {
    AND?: EquipmentScalarWhereWithAggregatesInput | EquipmentScalarWhereWithAggregatesInput[]
    OR?: EquipmentScalarWhereWithAggregatesInput[]
    NOT?: EquipmentScalarWhereWithAggregatesInput | EquipmentScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Equipment"> | string
    name?: StringWithAggregatesFilter<"Equipment"> | string
    price_idr?: DecimalWithAggregatesFilter<"Equipment"> | Decimal | DecimalJsLike | number | string
    order_number?: IntWithAggregatesFilter<"Equipment"> | number
    created_at?: DateTimeWithAggregatesFilter<"Equipment"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"Equipment"> | Date | string
  }

  export type TourPlusWhereInput = {
    AND?: TourPlusWhereInput | TourPlusWhereInput[]
    OR?: TourPlusWhereInput[]
    NOT?: TourPlusWhereInput | TourPlusWhereInput[]
    id?: StringFilter<"TourPlus"> | string
    name?: StringFilter<"TourPlus"> | string
    price_idr?: DecimalFilter<"TourPlus"> | Decimal | DecimalJsLike | number | string
    order_number?: IntFilter<"TourPlus"> | number
    created_at?: DateTimeFilter<"TourPlus"> | Date | string
    updated_at?: DateTimeFilter<"TourPlus"> | Date | string
    MitraPackages?: MitraPackageListRelationFilter
  }

  export type TourPlusOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    MitraPackages?: MitraPackageOrderByRelationAggregateInput
  }

  export type TourPlusWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: TourPlusWhereInput | TourPlusWhereInput[]
    OR?: TourPlusWhereInput[]
    NOT?: TourPlusWhereInput | TourPlusWhereInput[]
    name?: StringFilter<"TourPlus"> | string
    price_idr?: DecimalFilter<"TourPlus"> | Decimal | DecimalJsLike | number | string
    order_number?: IntFilter<"TourPlus"> | number
    created_at?: DateTimeFilter<"TourPlus"> | Date | string
    updated_at?: DateTimeFilter<"TourPlus"> | Date | string
    MitraPackages?: MitraPackageListRelationFilter
  }, "id">

  export type TourPlusOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: TourPlusCountOrderByAggregateInput
    _avg?: TourPlusAvgOrderByAggregateInput
    _max?: TourPlusMaxOrderByAggregateInput
    _min?: TourPlusMinOrderByAggregateInput
    _sum?: TourPlusSumOrderByAggregateInput
  }

  export type TourPlusScalarWhereWithAggregatesInput = {
    AND?: TourPlusScalarWhereWithAggregatesInput | TourPlusScalarWhereWithAggregatesInput[]
    OR?: TourPlusScalarWhereWithAggregatesInput[]
    NOT?: TourPlusScalarWhereWithAggregatesInput | TourPlusScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"TourPlus"> | string
    name?: StringWithAggregatesFilter<"TourPlus"> | string
    price_idr?: DecimalWithAggregatesFilter<"TourPlus"> | Decimal | DecimalJsLike | number | string
    order_number?: IntWithAggregatesFilter<"TourPlus"> | number
    created_at?: DateTimeWithAggregatesFilter<"TourPlus"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"TourPlus"> | Date | string
  }

  export type ManasikWhereInput = {
    AND?: ManasikWhereInput | ManasikWhereInput[]
    OR?: ManasikWhereInput[]
    NOT?: ManasikWhereInput | ManasikWhereInput[]
    id?: StringFilter<"Manasik"> | string
    name?: StringFilter<"Manasik"> | string
    price_idr?: DecimalFilter<"Manasik"> | Decimal | DecimalJsLike | number | string
    order_number?: IntFilter<"Manasik"> | number
    created_at?: DateTimeFilter<"Manasik"> | Date | string
    updated_at?: DateTimeFilter<"Manasik"> | Date | string
    MitraPackages?: MitraPackageListRelationFilter
  }

  export type ManasikOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    MitraPackages?: MitraPackageOrderByRelationAggregateInput
  }

  export type ManasikWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: ManasikWhereInput | ManasikWhereInput[]
    OR?: ManasikWhereInput[]
    NOT?: ManasikWhereInput | ManasikWhereInput[]
    name?: StringFilter<"Manasik"> | string
    price_idr?: DecimalFilter<"Manasik"> | Decimal | DecimalJsLike | number | string
    order_number?: IntFilter<"Manasik"> | number
    created_at?: DateTimeFilter<"Manasik"> | Date | string
    updated_at?: DateTimeFilter<"Manasik"> | Date | string
    MitraPackages?: MitraPackageListRelationFilter
  }, "id">

  export type ManasikOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: ManasikCountOrderByAggregateInput
    _avg?: ManasikAvgOrderByAggregateInput
    _max?: ManasikMaxOrderByAggregateInput
    _min?: ManasikMinOrderByAggregateInput
    _sum?: ManasikSumOrderByAggregateInput
  }

  export type ManasikScalarWhereWithAggregatesInput = {
    AND?: ManasikScalarWhereWithAggregatesInput | ManasikScalarWhereWithAggregatesInput[]
    OR?: ManasikScalarWhereWithAggregatesInput[]
    NOT?: ManasikScalarWhereWithAggregatesInput | ManasikScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Manasik"> | string
    name?: StringWithAggregatesFilter<"Manasik"> | string
    price_idr?: DecimalWithAggregatesFilter<"Manasik"> | Decimal | DecimalJsLike | number | string
    order_number?: IntWithAggregatesFilter<"Manasik"> | number
    created_at?: DateTimeWithAggregatesFilter<"Manasik"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"Manasik"> | Date | string
  }

  export type MitraPackageWhereInput = {
    AND?: MitraPackageWhereInput | MitraPackageWhereInput[]
    OR?: MitraPackageWhereInput[]
    NOT?: MitraPackageWhereInput | MitraPackageWhereInput[]
    id?: StringFilter<"MitraPackage"> | string
    period_id?: StringNullableFilter<"MitraPackage"> | string | null
    airline_id?: StringNullableFilter<"MitraPackage"> | string | null
    vendor_id?: StringNullableFilter<"MitraPackage"> | string | null
    hotel_mekkah_id?: StringNullableFilter<"MitraPackage"> | string | null
    hotel_madinah_id?: StringNullableFilter<"MitraPackage"> | string | null
    visa_id?: StringNullableFilter<"MitraPackage"> | string | null
    transportation_id?: StringNullableFilter<"MitraPackage"> | string | null
    muthawif_id?: StringNullableFilter<"MitraPackage"> | string | null
    handling_saudi_id?: StringNullableFilter<"MitraPackage"> | string | null
    handling_domestic_id?: StringNullableFilter<"MitraPackage"> | string | null
    siskopatuh_id?: StringNullableFilter<"MitraPackage"> | string | null
    equipment_id?: StringNullableFilter<"MitraPackage"> | string | null
    tour_plus_id?: StringNullableFilter<"MitraPackage"> | string | null
    manasik_id?: StringNullableFilter<"MitraPackage"> | string | null
    number_of_pax?: IntFilter<"MitraPackage"> | number
    departure_date?: DateTimeFilter<"MitraPackage"> | Date | string
    travel_duration?: IntFilter<"MitraPackage"> | number
    mekkah_duration?: IntFilter<"MitraPackage"> | number
    madinah_duration?: IntFilter<"MitraPackage"> | number
    tour_leader?: IntFilter<"MitraPackage"> | number
    margin?: DecimalFilter<"MitraPackage"> | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFilter<"MitraPackage"> | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFilter<"MitraPackage"> | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFilter<"MitraPackage"> | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFilter<"MitraPackage"> | Date | string
    updated_at?: DateTimeFilter<"MitraPackage"> | Date | string
    MitraPackageOrders?: MitraPackageOrderListRelationFilter
    period?: XOR<PeriodNullableRelationFilter, PeriodWhereInput> | null
    airline?: XOR<AirlineNullableRelationFilter, AirlineWhereInput> | null
    vendor?: XOR<VendorNullableRelationFilter, VendorWhereInput> | null
    hotelMekkah?: XOR<HotelNullableRelationFilter, HotelWhereInput> | null
    hotelMadinah?: XOR<HotelNullableRelationFilter, HotelWhereInput> | null
    visa?: XOR<VisaNullableRelationFilter, VisaWhereInput> | null
    transportation?: XOR<TransportationNullableRelationFilter, TransportationWhereInput> | null
    muthawif?: XOR<MuthawifNullableRelationFilter, MuthawifWhereInput> | null
    handlingSaudi?: XOR<HandlingSaudiNullableRelationFilter, HandlingSaudiWhereInput> | null
    handlingDomestic?: XOR<HandlingDomesticNullableRelationFilter, HandlingDomesticWhereInput> | null
    siskopatuh?: XOR<SiskopatuhNullableRelationFilter, SiskopatuhWhereInput> | null
    equipment?: XOR<EquipmentNullableRelationFilter, EquipmentWhereInput> | null
    tourPlus?: XOR<TourPlusNullableRelationFilter, TourPlusWhereInput> | null
    manasik?: XOR<ManasikNullableRelationFilter, ManasikWhereInput> | null
  }

  export type MitraPackageOrderByWithRelationInput = {
    id?: SortOrder
    period_id?: SortOrderInput | SortOrder
    airline_id?: SortOrderInput | SortOrder
    vendor_id?: SortOrderInput | SortOrder
    hotel_mekkah_id?: SortOrderInput | SortOrder
    hotel_madinah_id?: SortOrderInput | SortOrder
    visa_id?: SortOrderInput | SortOrder
    transportation_id?: SortOrderInput | SortOrder
    muthawif_id?: SortOrderInput | SortOrder
    handling_saudi_id?: SortOrderInput | SortOrder
    handling_domestic_id?: SortOrderInput | SortOrder
    siskopatuh_id?: SortOrderInput | SortOrder
    equipment_id?: SortOrderInput | SortOrder
    tour_plus_id?: SortOrderInput | SortOrder
    manasik_id?: SortOrderInput | SortOrder
    number_of_pax?: SortOrder
    departure_date?: SortOrder
    travel_duration?: SortOrder
    mekkah_duration?: SortOrder
    madinah_duration?: SortOrder
    tour_leader?: SortOrder
    margin?: SortOrder
    per_pax_price_double?: SortOrder
    per_pax_price_triple?: SortOrder
    per_pax_price_quad?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    MitraPackageOrders?: MitraPackageOrderOrderByRelationAggregateInput
    period?: PeriodOrderByWithRelationInput
    airline?: AirlineOrderByWithRelationInput
    vendor?: VendorOrderByWithRelationInput
    hotelMekkah?: HotelOrderByWithRelationInput
    hotelMadinah?: HotelOrderByWithRelationInput
    visa?: VisaOrderByWithRelationInput
    transportation?: TransportationOrderByWithRelationInput
    muthawif?: MuthawifOrderByWithRelationInput
    handlingSaudi?: HandlingSaudiOrderByWithRelationInput
    handlingDomestic?: HandlingDomesticOrderByWithRelationInput
    siskopatuh?: SiskopatuhOrderByWithRelationInput
    equipment?: EquipmentOrderByWithRelationInput
    tourPlus?: TourPlusOrderByWithRelationInput
    manasik?: ManasikOrderByWithRelationInput
  }

  export type MitraPackageWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: MitraPackageWhereInput | MitraPackageWhereInput[]
    OR?: MitraPackageWhereInput[]
    NOT?: MitraPackageWhereInput | MitraPackageWhereInput[]
    period_id?: StringNullableFilter<"MitraPackage"> | string | null
    airline_id?: StringNullableFilter<"MitraPackage"> | string | null
    vendor_id?: StringNullableFilter<"MitraPackage"> | string | null
    hotel_mekkah_id?: StringNullableFilter<"MitraPackage"> | string | null
    hotel_madinah_id?: StringNullableFilter<"MitraPackage"> | string | null
    visa_id?: StringNullableFilter<"MitraPackage"> | string | null
    transportation_id?: StringNullableFilter<"MitraPackage"> | string | null
    muthawif_id?: StringNullableFilter<"MitraPackage"> | string | null
    handling_saudi_id?: StringNullableFilter<"MitraPackage"> | string | null
    handling_domestic_id?: StringNullableFilter<"MitraPackage"> | string | null
    siskopatuh_id?: StringNullableFilter<"MitraPackage"> | string | null
    equipment_id?: StringNullableFilter<"MitraPackage"> | string | null
    tour_plus_id?: StringNullableFilter<"MitraPackage"> | string | null
    manasik_id?: StringNullableFilter<"MitraPackage"> | string | null
    number_of_pax?: IntFilter<"MitraPackage"> | number
    departure_date?: DateTimeFilter<"MitraPackage"> | Date | string
    travel_duration?: IntFilter<"MitraPackage"> | number
    mekkah_duration?: IntFilter<"MitraPackage"> | number
    madinah_duration?: IntFilter<"MitraPackage"> | number
    tour_leader?: IntFilter<"MitraPackage"> | number
    margin?: DecimalFilter<"MitraPackage"> | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFilter<"MitraPackage"> | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFilter<"MitraPackage"> | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFilter<"MitraPackage"> | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFilter<"MitraPackage"> | Date | string
    updated_at?: DateTimeFilter<"MitraPackage"> | Date | string
    MitraPackageOrders?: MitraPackageOrderListRelationFilter
    period?: XOR<PeriodNullableRelationFilter, PeriodWhereInput> | null
    airline?: XOR<AirlineNullableRelationFilter, AirlineWhereInput> | null
    vendor?: XOR<VendorNullableRelationFilter, VendorWhereInput> | null
    hotelMekkah?: XOR<HotelNullableRelationFilter, HotelWhereInput> | null
    hotelMadinah?: XOR<HotelNullableRelationFilter, HotelWhereInput> | null
    visa?: XOR<VisaNullableRelationFilter, VisaWhereInput> | null
    transportation?: XOR<TransportationNullableRelationFilter, TransportationWhereInput> | null
    muthawif?: XOR<MuthawifNullableRelationFilter, MuthawifWhereInput> | null
    handlingSaudi?: XOR<HandlingSaudiNullableRelationFilter, HandlingSaudiWhereInput> | null
    handlingDomestic?: XOR<HandlingDomesticNullableRelationFilter, HandlingDomesticWhereInput> | null
    siskopatuh?: XOR<SiskopatuhNullableRelationFilter, SiskopatuhWhereInput> | null
    equipment?: XOR<EquipmentNullableRelationFilter, EquipmentWhereInput> | null
    tourPlus?: XOR<TourPlusNullableRelationFilter, TourPlusWhereInput> | null
    manasik?: XOR<ManasikNullableRelationFilter, ManasikWhereInput> | null
  }, "id">

  export type MitraPackageOrderByWithAggregationInput = {
    id?: SortOrder
    period_id?: SortOrderInput | SortOrder
    airline_id?: SortOrderInput | SortOrder
    vendor_id?: SortOrderInput | SortOrder
    hotel_mekkah_id?: SortOrderInput | SortOrder
    hotel_madinah_id?: SortOrderInput | SortOrder
    visa_id?: SortOrderInput | SortOrder
    transportation_id?: SortOrderInput | SortOrder
    muthawif_id?: SortOrderInput | SortOrder
    handling_saudi_id?: SortOrderInput | SortOrder
    handling_domestic_id?: SortOrderInput | SortOrder
    siskopatuh_id?: SortOrderInput | SortOrder
    equipment_id?: SortOrderInput | SortOrder
    tour_plus_id?: SortOrderInput | SortOrder
    manasik_id?: SortOrderInput | SortOrder
    number_of_pax?: SortOrder
    departure_date?: SortOrder
    travel_duration?: SortOrder
    mekkah_duration?: SortOrder
    madinah_duration?: SortOrder
    tour_leader?: SortOrder
    margin?: SortOrder
    per_pax_price_double?: SortOrder
    per_pax_price_triple?: SortOrder
    per_pax_price_quad?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: MitraPackageCountOrderByAggregateInput
    _avg?: MitraPackageAvgOrderByAggregateInput
    _max?: MitraPackageMaxOrderByAggregateInput
    _min?: MitraPackageMinOrderByAggregateInput
    _sum?: MitraPackageSumOrderByAggregateInput
  }

  export type MitraPackageScalarWhereWithAggregatesInput = {
    AND?: MitraPackageScalarWhereWithAggregatesInput | MitraPackageScalarWhereWithAggregatesInput[]
    OR?: MitraPackageScalarWhereWithAggregatesInput[]
    NOT?: MitraPackageScalarWhereWithAggregatesInput | MitraPackageScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"MitraPackage"> | string
    period_id?: StringNullableWithAggregatesFilter<"MitraPackage"> | string | null
    airline_id?: StringNullableWithAggregatesFilter<"MitraPackage"> | string | null
    vendor_id?: StringNullableWithAggregatesFilter<"MitraPackage"> | string | null
    hotel_mekkah_id?: StringNullableWithAggregatesFilter<"MitraPackage"> | string | null
    hotel_madinah_id?: StringNullableWithAggregatesFilter<"MitraPackage"> | string | null
    visa_id?: StringNullableWithAggregatesFilter<"MitraPackage"> | string | null
    transportation_id?: StringNullableWithAggregatesFilter<"MitraPackage"> | string | null
    muthawif_id?: StringNullableWithAggregatesFilter<"MitraPackage"> | string | null
    handling_saudi_id?: StringNullableWithAggregatesFilter<"MitraPackage"> | string | null
    handling_domestic_id?: StringNullableWithAggregatesFilter<"MitraPackage"> | string | null
    siskopatuh_id?: StringNullableWithAggregatesFilter<"MitraPackage"> | string | null
    equipment_id?: StringNullableWithAggregatesFilter<"MitraPackage"> | string | null
    tour_plus_id?: StringNullableWithAggregatesFilter<"MitraPackage"> | string | null
    manasik_id?: StringNullableWithAggregatesFilter<"MitraPackage"> | string | null
    number_of_pax?: IntWithAggregatesFilter<"MitraPackage"> | number
    departure_date?: DateTimeWithAggregatesFilter<"MitraPackage"> | Date | string
    travel_duration?: IntWithAggregatesFilter<"MitraPackage"> | number
    mekkah_duration?: IntWithAggregatesFilter<"MitraPackage"> | number
    madinah_duration?: IntWithAggregatesFilter<"MitraPackage"> | number
    tour_leader?: IntWithAggregatesFilter<"MitraPackage"> | number
    margin?: DecimalWithAggregatesFilter<"MitraPackage"> | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalWithAggregatesFilter<"MitraPackage"> | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalWithAggregatesFilter<"MitraPackage"> | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalWithAggregatesFilter<"MitraPackage"> | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeWithAggregatesFilter<"MitraPackage"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"MitraPackage"> | Date | string
  }

  export type MitraPackageOrderWhereInput = {
    AND?: MitraPackageOrderWhereInput | MitraPackageOrderWhereInput[]
    OR?: MitraPackageOrderWhereInput[]
    NOT?: MitraPackageOrderWhereInput | MitraPackageOrderWhereInput[]
    id?: StringFilter<"MitraPackageOrder"> | string
    user_id?: StringFilter<"MitraPackageOrder"> | string
    mitra_package_id?: StringFilter<"MitraPackageOrder"> | string
    created_at?: DateTimeFilter<"MitraPackageOrder"> | Date | string
    updated_at?: DateTimeFilter<"MitraPackageOrder"> | Date | string
    MitraPackage?: XOR<MitraPackageRelationFilter, MitraPackageWhereInput>
    User?: XOR<UserRelationFilter, UserWhereInput>
  }

  export type MitraPackageOrderOrderByWithRelationInput = {
    id?: SortOrder
    user_id?: SortOrder
    mitra_package_id?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    MitraPackage?: MitraPackageOrderByWithRelationInput
    User?: UserOrderByWithRelationInput
  }

  export type MitraPackageOrderWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: MitraPackageOrderWhereInput | MitraPackageOrderWhereInput[]
    OR?: MitraPackageOrderWhereInput[]
    NOT?: MitraPackageOrderWhereInput | MitraPackageOrderWhereInput[]
    user_id?: StringFilter<"MitraPackageOrder"> | string
    mitra_package_id?: StringFilter<"MitraPackageOrder"> | string
    created_at?: DateTimeFilter<"MitraPackageOrder"> | Date | string
    updated_at?: DateTimeFilter<"MitraPackageOrder"> | Date | string
    MitraPackage?: XOR<MitraPackageRelationFilter, MitraPackageWhereInput>
    User?: XOR<UserRelationFilter, UserWhereInput>
  }, "id">

  export type MitraPackageOrderOrderByWithAggregationInput = {
    id?: SortOrder
    user_id?: SortOrder
    mitra_package_id?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: MitraPackageOrderCountOrderByAggregateInput
    _max?: MitraPackageOrderMaxOrderByAggregateInput
    _min?: MitraPackageOrderMinOrderByAggregateInput
  }

  export type MitraPackageOrderScalarWhereWithAggregatesInput = {
    AND?: MitraPackageOrderScalarWhereWithAggregatesInput | MitraPackageOrderScalarWhereWithAggregatesInput[]
    OR?: MitraPackageOrderScalarWhereWithAggregatesInput[]
    NOT?: MitraPackageOrderScalarWhereWithAggregatesInput | MitraPackageOrderScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"MitraPackageOrder"> | string
    user_id?: StringWithAggregatesFilter<"MitraPackageOrder"> | string
    mitra_package_id?: StringWithAggregatesFilter<"MitraPackageOrder"> | string
    created_at?: DateTimeWithAggregatesFilter<"MitraPackageOrder"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"MitraPackageOrder"> | Date | string
  }

  export type ExchangeRateWhereInput = {
    AND?: ExchangeRateWhereInput | ExchangeRateWhereInput[]
    OR?: ExchangeRateWhereInput[]
    NOT?: ExchangeRateWhereInput | ExchangeRateWhereInput[]
    id?: StringFilter<"ExchangeRate"> | string
    currency?: StringFilter<"ExchangeRate"> | string
    rate_idr?: DecimalFilter<"ExchangeRate"> | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFilter<"ExchangeRate"> | Date | string
    updated_at?: DateTimeFilter<"ExchangeRate"> | Date | string
  }

  export type ExchangeRateOrderByWithRelationInput = {
    id?: SortOrder
    currency?: SortOrder
    rate_idr?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ExchangeRateWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: ExchangeRateWhereInput | ExchangeRateWhereInput[]
    OR?: ExchangeRateWhereInput[]
    NOT?: ExchangeRateWhereInput | ExchangeRateWhereInput[]
    currency?: StringFilter<"ExchangeRate"> | string
    rate_idr?: DecimalFilter<"ExchangeRate"> | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFilter<"ExchangeRate"> | Date | string
    updated_at?: DateTimeFilter<"ExchangeRate"> | Date | string
  }, "id">

  export type ExchangeRateOrderByWithAggregationInput = {
    id?: SortOrder
    currency?: SortOrder
    rate_idr?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: ExchangeRateCountOrderByAggregateInput
    _avg?: ExchangeRateAvgOrderByAggregateInput
    _max?: ExchangeRateMaxOrderByAggregateInput
    _min?: ExchangeRateMinOrderByAggregateInput
    _sum?: ExchangeRateSumOrderByAggregateInput
  }

  export type ExchangeRateScalarWhereWithAggregatesInput = {
    AND?: ExchangeRateScalarWhereWithAggregatesInput | ExchangeRateScalarWhereWithAggregatesInput[]
    OR?: ExchangeRateScalarWhereWithAggregatesInput[]
    NOT?: ExchangeRateScalarWhereWithAggregatesInput | ExchangeRateScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"ExchangeRate"> | string
    currency?: StringWithAggregatesFilter<"ExchangeRate"> | string
    rate_idr?: DecimalWithAggregatesFilter<"ExchangeRate"> | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeWithAggregatesFilter<"ExchangeRate"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"ExchangeRate"> | Date | string
  }

  export type ContactWhereInput = {
    AND?: ContactWhereInput | ContactWhereInput[]
    OR?: ContactWhereInput[]
    NOT?: ContactWhereInput | ContactWhereInput[]
    id?: StringFilter<"Contact"> | string
    name?: StringFilter<"Contact"> | string
    value?: StringNullableFilter<"Contact"> | string | null
    created_at?: DateTimeFilter<"Contact"> | Date | string
    updated_at?: DateTimeFilter<"Contact"> | Date | string
  }

  export type ContactOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    value?: SortOrderInput | SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ContactWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: ContactWhereInput | ContactWhereInput[]
    OR?: ContactWhereInput[]
    NOT?: ContactWhereInput | ContactWhereInput[]
    name?: StringFilter<"Contact"> | string
    value?: StringNullableFilter<"Contact"> | string | null
    created_at?: DateTimeFilter<"Contact"> | Date | string
    updated_at?: DateTimeFilter<"Contact"> | Date | string
  }, "id">

  export type ContactOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    value?: SortOrderInput | SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: ContactCountOrderByAggregateInput
    _max?: ContactMaxOrderByAggregateInput
    _min?: ContactMinOrderByAggregateInput
  }

  export type ContactScalarWhereWithAggregatesInput = {
    AND?: ContactScalarWhereWithAggregatesInput | ContactScalarWhereWithAggregatesInput[]
    OR?: ContactScalarWhereWithAggregatesInput[]
    NOT?: ContactScalarWhereWithAggregatesInput | ContactScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Contact"> | string
    name?: StringWithAggregatesFilter<"Contact"> | string
    value?: StringNullableWithAggregatesFilter<"Contact"> | string | null
    created_at?: DateTimeWithAggregatesFilter<"Contact"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"Contact"> | Date | string
  }

  export type FaqWhereInput = {
    AND?: FaqWhereInput | FaqWhereInput[]
    OR?: FaqWhereInput[]
    NOT?: FaqWhereInput | FaqWhereInput[]
    id?: StringFilter<"Faq"> | string
    question?: StringFilter<"Faq"> | string
    answer?: StringFilter<"Faq"> | string
    created_at?: DateTimeFilter<"Faq"> | Date | string
    updated_at?: DateTimeFilter<"Faq"> | Date | string
  }

  export type FaqOrderByWithRelationInput = {
    id?: SortOrder
    question?: SortOrder
    answer?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type FaqWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: FaqWhereInput | FaqWhereInput[]
    OR?: FaqWhereInput[]
    NOT?: FaqWhereInput | FaqWhereInput[]
    question?: StringFilter<"Faq"> | string
    answer?: StringFilter<"Faq"> | string
    created_at?: DateTimeFilter<"Faq"> | Date | string
    updated_at?: DateTimeFilter<"Faq"> | Date | string
  }, "id">

  export type FaqOrderByWithAggregationInput = {
    id?: SortOrder
    question?: SortOrder
    answer?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: FaqCountOrderByAggregateInput
    _max?: FaqMaxOrderByAggregateInput
    _min?: FaqMinOrderByAggregateInput
  }

  export type FaqScalarWhereWithAggregatesInput = {
    AND?: FaqScalarWhereWithAggregatesInput | FaqScalarWhereWithAggregatesInput[]
    OR?: FaqScalarWhereWithAggregatesInput[]
    NOT?: FaqScalarWhereWithAggregatesInput | FaqScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Faq"> | string
    question?: StringWithAggregatesFilter<"Faq"> | string
    answer?: StringWithAggregatesFilter<"Faq"> | string
    created_at?: DateTimeWithAggregatesFilter<"Faq"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"Faq"> | Date | string
  }

  export type ContentWhereInput = {
    AND?: ContentWhereInput | ContentWhereInput[]
    OR?: ContentWhereInput[]
    NOT?: ContentWhereInput | ContentWhereInput[]
    id?: StringFilter<"Content"> | string
    page?: StringFilter<"Content"> | string
    section?: StringFilter<"Content"> | string
    type?: EnumContentTypeFilter<"Content"> | $Enums.ContentType
    key?: StringFilter<"Content"> | string
    value?: JsonFilter<"Content">
    visible?: BoolFilter<"Content"> | boolean
    created_at?: DateTimeFilter<"Content"> | Date | string
    updated_at?: DateTimeFilter<"Content"> | Date | string
  }

  export type ContentOrderByWithRelationInput = {
    id?: SortOrder
    page?: SortOrder
    section?: SortOrder
    type?: SortOrder
    key?: SortOrder
    value?: SortOrder
    visible?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ContentWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: ContentWhereInput | ContentWhereInput[]
    OR?: ContentWhereInput[]
    NOT?: ContentWhereInput | ContentWhereInput[]
    page?: StringFilter<"Content"> | string
    section?: StringFilter<"Content"> | string
    type?: EnumContentTypeFilter<"Content"> | $Enums.ContentType
    key?: StringFilter<"Content"> | string
    value?: JsonFilter<"Content">
    visible?: BoolFilter<"Content"> | boolean
    created_at?: DateTimeFilter<"Content"> | Date | string
    updated_at?: DateTimeFilter<"Content"> | Date | string
  }, "id">

  export type ContentOrderByWithAggregationInput = {
    id?: SortOrder
    page?: SortOrder
    section?: SortOrder
    type?: SortOrder
    key?: SortOrder
    value?: SortOrder
    visible?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: ContentCountOrderByAggregateInput
    _max?: ContentMaxOrderByAggregateInput
    _min?: ContentMinOrderByAggregateInput
  }

  export type ContentScalarWhereWithAggregatesInput = {
    AND?: ContentScalarWhereWithAggregatesInput | ContentScalarWhereWithAggregatesInput[]
    OR?: ContentScalarWhereWithAggregatesInput[]
    NOT?: ContentScalarWhereWithAggregatesInput | ContentScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Content"> | string
    page?: StringWithAggregatesFilter<"Content"> | string
    section?: StringWithAggregatesFilter<"Content"> | string
    type?: EnumContentTypeWithAggregatesFilter<"Content"> | $Enums.ContentType
    key?: StringWithAggregatesFilter<"Content"> | string
    value?: JsonWithAggregatesFilter<"Content">
    visible?: BoolWithAggregatesFilter<"Content"> | boolean
    created_at?: DateTimeWithAggregatesFilter<"Content"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"Content"> | Date | string
  }

  export type MenuItemWhereInput = {
    AND?: MenuItemWhereInput | MenuItemWhereInput[]
    OR?: MenuItemWhereInput[]
    NOT?: MenuItemWhereInput | MenuItemWhereInput[]
    id?: StringFilter<"MenuItem"> | string
    name?: StringFilter<"MenuItem"> | string
    url?: StringFilter<"MenuItem"> | string
    visible?: BoolFilter<"MenuItem"> | boolean
    created_at?: DateTimeFilter<"MenuItem"> | Date | string
    updated_at?: DateTimeFilter<"MenuItem"> | Date | string
  }

  export type MenuItemOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    url?: SortOrder
    visible?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type MenuItemWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: MenuItemWhereInput | MenuItemWhereInput[]
    OR?: MenuItemWhereInput[]
    NOT?: MenuItemWhereInput | MenuItemWhereInput[]
    name?: StringFilter<"MenuItem"> | string
    url?: StringFilter<"MenuItem"> | string
    visible?: BoolFilter<"MenuItem"> | boolean
    created_at?: DateTimeFilter<"MenuItem"> | Date | string
    updated_at?: DateTimeFilter<"MenuItem"> | Date | string
  }, "id">

  export type MenuItemOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    url?: SortOrder
    visible?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: MenuItemCountOrderByAggregateInput
    _max?: MenuItemMaxOrderByAggregateInput
    _min?: MenuItemMinOrderByAggregateInput
  }

  export type MenuItemScalarWhereWithAggregatesInput = {
    AND?: MenuItemScalarWhereWithAggregatesInput | MenuItemScalarWhereWithAggregatesInput[]
    OR?: MenuItemScalarWhereWithAggregatesInput[]
    NOT?: MenuItemScalarWhereWithAggregatesInput | MenuItemScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"MenuItem"> | string
    name?: StringWithAggregatesFilter<"MenuItem"> | string
    url?: StringWithAggregatesFilter<"MenuItem"> | string
    visible?: BoolWithAggregatesFilter<"MenuItem"> | boolean
    created_at?: DateTimeWithAggregatesFilter<"MenuItem"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"MenuItem"> | Date | string
  }

  export type FooterWhereInput = {
    AND?: FooterWhereInput | FooterWhereInput[]
    OR?: FooterWhereInput[]
    NOT?: FooterWhereInput | FooterWhereInput[]
    id?: StringFilter<"Footer"> | string
    name?: StringFilter<"Footer"> | string
    type?: EnumFooterTypeFilter<"Footer"> | $Enums.FooterType
    visible?: BoolFilter<"Footer"> | boolean
    order?: IntFilter<"Footer"> | number
    created_at?: DateTimeFilter<"Footer"> | Date | string
    updated_at?: DateTimeFilter<"Footer"> | Date | string
    FooterItem?: FooterItemListRelationFilter
  }

  export type FooterOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    type?: SortOrder
    visible?: SortOrder
    order?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    FooterItem?: FooterItemOrderByRelationAggregateInput
  }

  export type FooterWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: FooterWhereInput | FooterWhereInput[]
    OR?: FooterWhereInput[]
    NOT?: FooterWhereInput | FooterWhereInput[]
    name?: StringFilter<"Footer"> | string
    type?: EnumFooterTypeFilter<"Footer"> | $Enums.FooterType
    visible?: BoolFilter<"Footer"> | boolean
    order?: IntFilter<"Footer"> | number
    created_at?: DateTimeFilter<"Footer"> | Date | string
    updated_at?: DateTimeFilter<"Footer"> | Date | string
    FooterItem?: FooterItemListRelationFilter
  }, "id">

  export type FooterOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    type?: SortOrder
    visible?: SortOrder
    order?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: FooterCountOrderByAggregateInput
    _avg?: FooterAvgOrderByAggregateInput
    _max?: FooterMaxOrderByAggregateInput
    _min?: FooterMinOrderByAggregateInput
    _sum?: FooterSumOrderByAggregateInput
  }

  export type FooterScalarWhereWithAggregatesInput = {
    AND?: FooterScalarWhereWithAggregatesInput | FooterScalarWhereWithAggregatesInput[]
    OR?: FooterScalarWhereWithAggregatesInput[]
    NOT?: FooterScalarWhereWithAggregatesInput | FooterScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Footer"> | string
    name?: StringWithAggregatesFilter<"Footer"> | string
    type?: EnumFooterTypeWithAggregatesFilter<"Footer"> | $Enums.FooterType
    visible?: BoolWithAggregatesFilter<"Footer"> | boolean
    order?: IntWithAggregatesFilter<"Footer"> | number
    created_at?: DateTimeWithAggregatesFilter<"Footer"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"Footer"> | Date | string
  }

  export type FooterItemWhereInput = {
    AND?: FooterItemWhereInput | FooterItemWhereInput[]
    OR?: FooterItemWhereInput[]
    NOT?: FooterItemWhereInput | FooterItemWhereInput[]
    id?: StringFilter<"FooterItem"> | string
    footer_id?: StringFilter<"FooterItem"> | string
    name?: StringFilter<"FooterItem"> | string
    url?: StringFilter<"FooterItem"> | string
    visible?: BoolFilter<"FooterItem"> | boolean
    created_at?: DateTimeFilter<"FooterItem"> | Date | string
    updated_at?: DateTimeFilter<"FooterItem"> | Date | string
    Footer?: XOR<FooterRelationFilter, FooterWhereInput>
  }

  export type FooterItemOrderByWithRelationInput = {
    id?: SortOrder
    footer_id?: SortOrder
    name?: SortOrder
    url?: SortOrder
    visible?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    Footer?: FooterOrderByWithRelationInput
  }

  export type FooterItemWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: FooterItemWhereInput | FooterItemWhereInput[]
    OR?: FooterItemWhereInput[]
    NOT?: FooterItemWhereInput | FooterItemWhereInput[]
    footer_id?: StringFilter<"FooterItem"> | string
    name?: StringFilter<"FooterItem"> | string
    url?: StringFilter<"FooterItem"> | string
    visible?: BoolFilter<"FooterItem"> | boolean
    created_at?: DateTimeFilter<"FooterItem"> | Date | string
    updated_at?: DateTimeFilter<"FooterItem"> | Date | string
    Footer?: XOR<FooterRelationFilter, FooterWhereInput>
  }, "id">

  export type FooterItemOrderByWithAggregationInput = {
    id?: SortOrder
    footer_id?: SortOrder
    name?: SortOrder
    url?: SortOrder
    visible?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: FooterItemCountOrderByAggregateInput
    _max?: FooterItemMaxOrderByAggregateInput
    _min?: FooterItemMinOrderByAggregateInput
  }

  export type FooterItemScalarWhereWithAggregatesInput = {
    AND?: FooterItemScalarWhereWithAggregatesInput | FooterItemScalarWhereWithAggregatesInput[]
    OR?: FooterItemScalarWhereWithAggregatesInput[]
    NOT?: FooterItemScalarWhereWithAggregatesInput | FooterItemScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"FooterItem"> | string
    footer_id?: StringWithAggregatesFilter<"FooterItem"> | string
    name?: StringWithAggregatesFilter<"FooterItem"> | string
    url?: StringWithAggregatesFilter<"FooterItem"> | string
    visible?: BoolWithAggregatesFilter<"FooterItem"> | boolean
    created_at?: DateTimeWithAggregatesFilter<"FooterItem"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"FooterItem"> | Date | string
  }

  export type ColorWhereInput = {
    AND?: ColorWhereInput | ColorWhereInput[]
    OR?: ColorWhereInput[]
    NOT?: ColorWhereInput | ColorWhereInput[]
    id?: StringFilter<"Color"> | string
    name?: StringFilter<"Color"> | string
    hex?: StringFilter<"Color"> | string
    created_at?: DateTimeFilter<"Color"> | Date | string
    updated_at?: DateTimeFilter<"Color"> | Date | string
  }

  export type ColorOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    hex?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ColorWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: ColorWhereInput | ColorWhereInput[]
    OR?: ColorWhereInput[]
    NOT?: ColorWhereInput | ColorWhereInput[]
    name?: StringFilter<"Color"> | string
    hex?: StringFilter<"Color"> | string
    created_at?: DateTimeFilter<"Color"> | Date | string
    updated_at?: DateTimeFilter<"Color"> | Date | string
  }, "id">

  export type ColorOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    hex?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
    _count?: ColorCountOrderByAggregateInput
    _max?: ColorMaxOrderByAggregateInput
    _min?: ColorMinOrderByAggregateInput
  }

  export type ColorScalarWhereWithAggregatesInput = {
    AND?: ColorScalarWhereWithAggregatesInput | ColorScalarWhereWithAggregatesInput[]
    OR?: ColorScalarWhereWithAggregatesInput[]
    NOT?: ColorScalarWhereWithAggregatesInput | ColorScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Color"> | string
    name?: StringWithAggregatesFilter<"Color"> | string
    hex?: StringWithAggregatesFilter<"Color"> | string
    created_at?: DateTimeWithAggregatesFilter<"Color"> | Date | string
    updated_at?: DateTimeWithAggregatesFilter<"Color"> | Date | string
  }

  export type UserCreateInput = {
    id?: string
    email: string
    full_name: string
    password: string
    whatsapp_number: string
    role?: $Enums.Role
    created_at?: Date | string
    updated_at?: Date | string
    ProductOrders?: ProductOrderCreateNestedManyWithoutUserInput
    MitraPackageOrder?: MitraPackageOrderCreateNestedManyWithoutUserInput
    MitraRequest?: MitraRequestCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateInput = {
    id?: string
    email: string
    full_name: string
    password: string
    whatsapp_number: string
    role?: $Enums.Role
    created_at?: Date | string
    updated_at?: Date | string
    ProductOrders?: ProductOrderUncheckedCreateNestedManyWithoutUserInput
    MitraPackageOrder?: MitraPackageOrderUncheckedCreateNestedManyWithoutUserInput
    MitraRequest?: MitraRequestUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    full_name?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    whatsapp_number?: StringFieldUpdateOperationsInput | string
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ProductOrders?: ProductOrderUpdateManyWithoutUserNestedInput
    MitraPackageOrder?: MitraPackageOrderUpdateManyWithoutUserNestedInput
    MitraRequest?: MitraRequestUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    full_name?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    whatsapp_number?: StringFieldUpdateOperationsInput | string
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ProductOrders?: ProductOrderUncheckedUpdateManyWithoutUserNestedInput
    MitraPackageOrder?: MitraPackageOrderUncheckedUpdateManyWithoutUserNestedInput
    MitraRequest?: MitraRequestUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserCreateManyInput = {
    id?: string
    email: string
    full_name: string
    password: string
    whatsapp_number: string
    role?: $Enums.Role
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type UserUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    full_name?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    whatsapp_number?: StringFieldUpdateOperationsInput | string
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    full_name?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    whatsapp_number?: StringFieldUpdateOperationsInput | string
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraRequestCreateInput = {
    id?: string
    ktp: string
    upgrade_amount: Decimal | DecimalJsLike | number | string
    payment_proof: string
    status?: $Enums.RequestStatus
    created_at?: Date | string
    updated_at?: Date | string
    User: UserCreateNestedOneWithoutMitraRequestInput
  }

  export type MitraRequestUncheckedCreateInput = {
    id?: string
    user_id: string
    ktp: string
    upgrade_amount: Decimal | DecimalJsLike | number | string
    payment_proof: string
    status?: $Enums.RequestStatus
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MitraRequestUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    ktp?: StringFieldUpdateOperationsInput | string
    upgrade_amount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    payment_proof?: StringFieldUpdateOperationsInput | string
    status?: EnumRequestStatusFieldUpdateOperationsInput | $Enums.RequestStatus
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    User?: UserUpdateOneRequiredWithoutMitraRequestNestedInput
  }

  export type MitraRequestUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    ktp?: StringFieldUpdateOperationsInput | string
    upgrade_amount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    payment_proof?: StringFieldUpdateOperationsInput | string
    status?: EnumRequestStatusFieldUpdateOperationsInput | $Enums.RequestStatus
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraRequestCreateManyInput = {
    id?: string
    user_id: string
    ktp: string
    upgrade_amount: Decimal | DecimalJsLike | number | string
    payment_proof: string
    status?: $Enums.RequestStatus
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MitraRequestUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    ktp?: StringFieldUpdateOperationsInput | string
    upgrade_amount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    payment_proof?: StringFieldUpdateOperationsInput | string
    status?: EnumRequestStatusFieldUpdateOperationsInput | $Enums.RequestStatus
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraRequestUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    ktp?: StringFieldUpdateOperationsInput | string
    upgrade_amount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    payment_proof?: StringFieldUpdateOperationsInput | string
    status?: EnumRequestStatusFieldUpdateOperationsInput | $Enums.RequestStatus
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserPackageCreateInput = {
    id?: string
    number_of_pax: number
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    UserPackageOrders?: UserPackageOrderCreateNestedManyWithoutUserPackageInput
    transportation?: UserPackageOptionCreateNestedOneWithoutTransportationsInput
    flight?: UserPackageOptionCreateNestedOneWithoutFlightsInput
    hotelMekkah?: UserPackageOptionCreateNestedOneWithoutHotelMekkahsInput
    hotelMadinah?: UserPackageOptionCreateNestedOneWithoutHotelMadinahsInput
    muthawif?: UserPackageOptionCreateNestedOneWithoutMuthawifsInput
    handling?: UserPackageOptionCreateNestedOneWithoutHandlingsInput
  }

  export type UserPackageUncheckedCreateInput = {
    id?: string
    transportation_id?: string | null
    flight_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    muthawif_id?: string | null
    handling_id?: string | null
    number_of_pax: number
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    UserPackageOrders?: UserPackageOrderUncheckedCreateNestedManyWithoutUserPackageInput
  }

  export type UserPackageUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    UserPackageOrders?: UserPackageOrderUpdateManyWithoutUserPackageNestedInput
    transportation?: UserPackageOptionUpdateOneWithoutTransportationsNestedInput
    flight?: UserPackageOptionUpdateOneWithoutFlightsNestedInput
    hotelMekkah?: UserPackageOptionUpdateOneWithoutHotelMekkahsNestedInput
    hotelMadinah?: UserPackageOptionUpdateOneWithoutHotelMadinahsNestedInput
    muthawif?: UserPackageOptionUpdateOneWithoutMuthawifsNestedInput
    handling?: UserPackageOptionUpdateOneWithoutHandlingsNestedInput
  }

  export type UserPackageUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    flight_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    UserPackageOrders?: UserPackageOrderUncheckedUpdateManyWithoutUserPackageNestedInput
  }

  export type UserPackageCreateManyInput = {
    id?: string
    transportation_id?: string | null
    flight_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    muthawif_id?: string | null
    handling_id?: string | null
    number_of_pax: number
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type UserPackageUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserPackageUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    flight_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PackageTypeCreateInput = {
    id?: string
    name: string
    is_public?: boolean
    created_at?: Date | string
    updated_at?: Date | string
    UserPackageOptions?: UserPackageOptionCreateNestedManyWithoutPackageTypeInput
  }

  export type PackageTypeUncheckedCreateInput = {
    id?: string
    name: string
    is_public?: boolean
    created_at?: Date | string
    updated_at?: Date | string
    UserPackageOptions?: UserPackageOptionUncheckedCreateNestedManyWithoutPackageTypeInput
  }

  export type PackageTypeUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    is_public?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    UserPackageOptions?: UserPackageOptionUpdateManyWithoutPackageTypeNestedInput
  }

  export type PackageTypeUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    is_public?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    UserPackageOptions?: UserPackageOptionUncheckedUpdateManyWithoutPackageTypeNestedInput
  }

  export type PackageTypeCreateManyInput = {
    id?: string
    name: string
    is_public?: boolean
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type PackageTypeUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    is_public?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PackageTypeUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    is_public?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserPackageOptionCreateInput = {
    id?: string
    name: string
    price: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    transportations?: UserPackageCreateNestedManyWithoutTransportationInput
    flights?: UserPackageCreateNestedManyWithoutFlightInput
    hotelMekkahs?: UserPackageCreateNestedManyWithoutHotelMekkahInput
    hotelMadinahs?: UserPackageCreateNestedManyWithoutHotelMadinahInput
    muthawifs?: UserPackageCreateNestedManyWithoutMuthawifInput
    handlings?: UserPackageCreateNestedManyWithoutHandlingInput
    PackageType: PackageTypeCreateNestedOneWithoutUserPackageOptionsInput
  }

  export type UserPackageOptionUncheckedCreateInput = {
    id?: string
    package_type_id: string
    name: string
    price: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    transportations?: UserPackageUncheckedCreateNestedManyWithoutTransportationInput
    flights?: UserPackageUncheckedCreateNestedManyWithoutFlightInput
    hotelMekkahs?: UserPackageUncheckedCreateNestedManyWithoutHotelMekkahInput
    hotelMadinahs?: UserPackageUncheckedCreateNestedManyWithoutHotelMadinahInput
    muthawifs?: UserPackageUncheckedCreateNestedManyWithoutMuthawifInput
    handlings?: UserPackageUncheckedCreateNestedManyWithoutHandlingInput
  }

  export type UserPackageOptionUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    transportations?: UserPackageUpdateManyWithoutTransportationNestedInput
    flights?: UserPackageUpdateManyWithoutFlightNestedInput
    hotelMekkahs?: UserPackageUpdateManyWithoutHotelMekkahNestedInput
    hotelMadinahs?: UserPackageUpdateManyWithoutHotelMadinahNestedInput
    muthawifs?: UserPackageUpdateManyWithoutMuthawifNestedInput
    handlings?: UserPackageUpdateManyWithoutHandlingNestedInput
    PackageType?: PackageTypeUpdateOneRequiredWithoutUserPackageOptionsNestedInput
  }

  export type UserPackageOptionUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    package_type_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    transportations?: UserPackageUncheckedUpdateManyWithoutTransportationNestedInput
    flights?: UserPackageUncheckedUpdateManyWithoutFlightNestedInput
    hotelMekkahs?: UserPackageUncheckedUpdateManyWithoutHotelMekkahNestedInput
    hotelMadinahs?: UserPackageUncheckedUpdateManyWithoutHotelMadinahNestedInput
    muthawifs?: UserPackageUncheckedUpdateManyWithoutMuthawifNestedInput
    handlings?: UserPackageUncheckedUpdateManyWithoutHandlingNestedInput
  }

  export type UserPackageOptionCreateManyInput = {
    id?: string
    package_type_id: string
    name: string
    price: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type UserPackageOptionUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserPackageOptionUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    package_type_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserPackageOrderCreateInput = {
    id?: string
    full_name: string
    email: string
    whatsapp_number: string
    created_at?: Date | string
    updated_at?: Date | string
    UserPackage: UserPackageCreateNestedOneWithoutUserPackageOrdersInput
  }

  export type UserPackageOrderUncheckedCreateInput = {
    id?: string
    full_name: string
    email: string
    whatsapp_number: string
    user_package_id: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type UserPackageOrderUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    full_name?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    whatsapp_number?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    UserPackage?: UserPackageUpdateOneRequiredWithoutUserPackageOrdersNestedInput
  }

  export type UserPackageOrderUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    full_name?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    whatsapp_number?: StringFieldUpdateOperationsInput | string
    user_package_id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserPackageOrderCreateManyInput = {
    id?: string
    full_name: string
    email: string
    whatsapp_number: string
    user_package_id: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type UserPackageOrderUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    full_name?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    whatsapp_number?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserPackageOrderUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    full_name?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    whatsapp_number?: StringFieldUpdateOperationsInput | string
    user_package_id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CategoryCreateInput = {
    id?: string
    name: string
    created_at?: Date | string
    updated_at?: Date | string
    ProductCategories?: ProductCategoryCreateNestedManyWithoutCategoryInput
  }

  export type CategoryUncheckedCreateInput = {
    id?: string
    name: string
    created_at?: Date | string
    updated_at?: Date | string
    ProductCategories?: ProductCategoryUncheckedCreateNestedManyWithoutCategoryInput
  }

  export type CategoryUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ProductCategories?: ProductCategoryUpdateManyWithoutCategoryNestedInput
  }

  export type CategoryUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ProductCategories?: ProductCategoryUncheckedUpdateManyWithoutCategoryNestedInput
  }

  export type CategoryCreateManyInput = {
    id?: string
    name: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type CategoryUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CategoryUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProductCreateInput = {
    id?: string
    name: string
    description?: string | null
    price?: Decimal | DecimalJsLike | number | string
    has_variation?: boolean
    created_at?: Date | string
    updated_at?: Date | string
    ProductThumbnails?: ProductThumbnailCreateNestedManyWithoutProductInput
    ProductCategories?: ProductCategoryCreateNestedManyWithoutProductInput
    ProductVariations?: ProductVariationCreateNestedManyWithoutProductInput
    ProductIncludes?: ProductIncludeCreateNestedManyWithoutProductInput
    ProductExcludes?: ProductExcludeCreateNestedManyWithoutProductInput
    ProductOrders?: ProductOrderCreateNestedManyWithoutProductInput
  }

  export type ProductUncheckedCreateInput = {
    id?: string
    name: string
    description?: string | null
    price?: Decimal | DecimalJsLike | number | string
    has_variation?: boolean
    created_at?: Date | string
    updated_at?: Date | string
    ProductThumbnails?: ProductThumbnailUncheckedCreateNestedManyWithoutProductInput
    ProductCategories?: ProductCategoryUncheckedCreateNestedManyWithoutProductInput
    ProductVariations?: ProductVariationUncheckedCreateNestedManyWithoutProductInput
    ProductIncludes?: ProductIncludeUncheckedCreateNestedManyWithoutProductInput
    ProductExcludes?: ProductExcludeUncheckedCreateNestedManyWithoutProductInput
    ProductOrders?: ProductOrderUncheckedCreateNestedManyWithoutProductInput
  }

  export type ProductUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    has_variation?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ProductThumbnails?: ProductThumbnailUpdateManyWithoutProductNestedInput
    ProductCategories?: ProductCategoryUpdateManyWithoutProductNestedInput
    ProductVariations?: ProductVariationUpdateManyWithoutProductNestedInput
    ProductIncludes?: ProductIncludeUpdateManyWithoutProductNestedInput
    ProductExcludes?: ProductExcludeUpdateManyWithoutProductNestedInput
    ProductOrders?: ProductOrderUpdateManyWithoutProductNestedInput
  }

  export type ProductUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    has_variation?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ProductThumbnails?: ProductThumbnailUncheckedUpdateManyWithoutProductNestedInput
    ProductCategories?: ProductCategoryUncheckedUpdateManyWithoutProductNestedInput
    ProductVariations?: ProductVariationUncheckedUpdateManyWithoutProductNestedInput
    ProductIncludes?: ProductIncludeUncheckedUpdateManyWithoutProductNestedInput
    ProductExcludes?: ProductExcludeUncheckedUpdateManyWithoutProductNestedInput
    ProductOrders?: ProductOrderUncheckedUpdateManyWithoutProductNestedInput
  }

  export type ProductCreateManyInput = {
    id?: string
    name: string
    description?: string | null
    price?: Decimal | DecimalJsLike | number | string
    has_variation?: boolean
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type ProductUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    has_variation?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProductUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    has_variation?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProductThumbnailCreateInput = {
    id?: string
    increment?: number
    image_url: string
    Product: ProductCreateNestedOneWithoutProductThumbnailsInput
  }

  export type ProductThumbnailUncheckedCreateInput = {
    id?: string
    increment?: number
    product_id: string
    image_url: string
  }

  export type ProductThumbnailUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    image_url?: StringFieldUpdateOperationsInput | string
    Product?: ProductUpdateOneRequiredWithoutProductThumbnailsNestedInput
  }

  export type ProductThumbnailUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    increment?: IntFieldUpdateOperationsInput | number
    product_id?: StringFieldUpdateOperationsInput | string
    image_url?: StringFieldUpdateOperationsInput | string
  }

  export type ProductThumbnailCreateManyInput = {
    id?: string
    increment?: number
    product_id: string
    image_url: string
  }

  export type ProductThumbnailUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    image_url?: StringFieldUpdateOperationsInput | string
  }

  export type ProductThumbnailUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    increment?: IntFieldUpdateOperationsInput | number
    product_id?: StringFieldUpdateOperationsInput | string
    image_url?: StringFieldUpdateOperationsInput | string
  }

  export type ProductCategoryCreateInput = {
    id?: string
    Product: ProductCreateNestedOneWithoutProductCategoriesInput
    Category: CategoryCreateNestedOneWithoutProductCategoriesInput
  }

  export type ProductCategoryUncheckedCreateInput = {
    id?: string
    product_id: string
    category_id: string
  }

  export type ProductCategoryUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    Product?: ProductUpdateOneRequiredWithoutProductCategoriesNestedInput
    Category?: CategoryUpdateOneRequiredWithoutProductCategoriesNestedInput
  }

  export type ProductCategoryUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    product_id?: StringFieldUpdateOperationsInput | string
    category_id?: StringFieldUpdateOperationsInput | string
  }

  export type ProductCategoryCreateManyInput = {
    id?: string
    product_id: string
    category_id: string
  }

  export type ProductCategoryUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
  }

  export type ProductCategoryUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    product_id?: StringFieldUpdateOperationsInput | string
    category_id?: StringFieldUpdateOperationsInput | string
  }

  export type ProductVariationCreateInput = {
    id?: string
    increment?: number
    name: string
    price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    ProductOrders?: ProductOrderCreateNestedManyWithoutProductVariationInput
    Product: ProductCreateNestedOneWithoutProductVariationsInput
  }

  export type ProductVariationUncheckedCreateInput = {
    id?: string
    increment?: number
    product_id: string
    name: string
    price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    ProductOrders?: ProductOrderUncheckedCreateNestedManyWithoutProductVariationInput
  }

  export type ProductVariationUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ProductOrders?: ProductOrderUpdateManyWithoutProductVariationNestedInput
    Product?: ProductUpdateOneRequiredWithoutProductVariationsNestedInput
  }

  export type ProductVariationUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    increment?: IntFieldUpdateOperationsInput | number
    product_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ProductOrders?: ProductOrderUncheckedUpdateManyWithoutProductVariationNestedInput
  }

  export type ProductVariationCreateManyInput = {
    id?: string
    increment?: number
    product_id: string
    name: string
    price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type ProductVariationUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProductVariationUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    increment?: IntFieldUpdateOperationsInput | number
    product_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProductIncludeCreateInput = {
    id?: string
    increment?: number
    description: string
    Product: ProductCreateNestedOneWithoutProductIncludesInput
  }

  export type ProductIncludeUncheckedCreateInput = {
    id?: string
    increment?: number
    product_id: string
    description: string
  }

  export type ProductIncludeUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    Product?: ProductUpdateOneRequiredWithoutProductIncludesNestedInput
  }

  export type ProductIncludeUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    increment?: IntFieldUpdateOperationsInput | number
    product_id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
  }

  export type ProductIncludeCreateManyInput = {
    id?: string
    increment?: number
    product_id: string
    description: string
  }

  export type ProductIncludeUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
  }

  export type ProductIncludeUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    increment?: IntFieldUpdateOperationsInput | number
    product_id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
  }

  export type ProductExcludeCreateInput = {
    id?: string
    increment?: number
    description: string
    Product: ProductCreateNestedOneWithoutProductExcludesInput
  }

  export type ProductExcludeUncheckedCreateInput = {
    id?: string
    increment?: number
    product_id: string
    description: string
  }

  export type ProductExcludeUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
    Product?: ProductUpdateOneRequiredWithoutProductExcludesNestedInput
  }

  export type ProductExcludeUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    increment?: IntFieldUpdateOperationsInput | number
    product_id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
  }

  export type ProductExcludeCreateManyInput = {
    id?: string
    increment?: number
    product_id: string
    description: string
  }

  export type ProductExcludeUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
  }

  export type ProductExcludeUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    increment?: IntFieldUpdateOperationsInput | number
    product_id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
  }

  export type ProductOrderCreateInput = {
    id?: string
    departure: Date | string
    number_of_pax: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    User: UserCreateNestedOneWithoutProductOrdersInput
    Product: ProductCreateNestedOneWithoutProductOrdersInput
    ProductVariation?: ProductVariationCreateNestedOneWithoutProductOrdersInput
  }

  export type ProductOrderUncheckedCreateInput = {
    id?: string
    user_id: string
    product_id: string
    variation_id?: string | null
    departure: Date | string
    number_of_pax: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type ProductOrderUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    departure?: DateTimeFieldUpdateOperationsInput | Date | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    User?: UserUpdateOneRequiredWithoutProductOrdersNestedInput
    Product?: ProductUpdateOneRequiredWithoutProductOrdersNestedInput
    ProductVariation?: ProductVariationUpdateOneWithoutProductOrdersNestedInput
  }

  export type ProductOrderUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    product_id?: StringFieldUpdateOperationsInput | string
    variation_id?: NullableStringFieldUpdateOperationsInput | string | null
    departure?: DateTimeFieldUpdateOperationsInput | Date | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProductOrderCreateManyInput = {
    id?: string
    user_id: string
    product_id: string
    variation_id?: string | null
    departure: Date | string
    number_of_pax: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type ProductOrderUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    departure?: DateTimeFieldUpdateOperationsInput | Date | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProductOrderUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    product_id?: StringFieldUpdateOperationsInput | string
    variation_id?: NullableStringFieldUpdateOperationsInput | string | null
    departure?: DateTimeFieldUpdateOperationsInput | Date | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type VendorCreateInput = {
    id?: string
    name: string
    created_at?: Date | string
    updated_at?: Date | string
    Hotels?: HotelCreateNestedManyWithoutVendorInput
    MitraPackages?: MitraPackageCreateNestedManyWithoutVendorInput
  }

  export type VendorUncheckedCreateInput = {
    id?: string
    name: string
    created_at?: Date | string
    updated_at?: Date | string
    Hotels?: HotelUncheckedCreateNestedManyWithoutVendorInput
    MitraPackages?: MitraPackageUncheckedCreateNestedManyWithoutVendorInput
  }

  export type VendorUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    Hotels?: HotelUpdateManyWithoutVendorNestedInput
    MitraPackages?: MitraPackageUpdateManyWithoutVendorNestedInput
  }

  export type VendorUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    Hotels?: HotelUncheckedUpdateManyWithoutVendorNestedInput
    MitraPackages?: MitraPackageUncheckedUpdateManyWithoutVendorNestedInput
  }

  export type VendorCreateManyInput = {
    id?: string
    name: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type VendorUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type VendorUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type HotelCreateInput = {
    id?: string
    name: string
    city: $Enums.City
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    Vendor: VendorCreateNestedOneWithoutHotelsInput
    HotelPeriodPrices?: HotelPeriodPriceCreateNestedManyWithoutHotelInput
    MitraPackagesMekkah?: MitraPackageCreateNestedManyWithoutHotelMekkahInput
    MitraPackagesMadinah?: MitraPackageCreateNestedManyWithoutHotelMadinahInput
  }

  export type HotelUncheckedCreateInput = {
    id?: string
    vendor_id: string
    name: string
    city: $Enums.City
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    HotelPeriodPrices?: HotelPeriodPriceUncheckedCreateNestedManyWithoutHotelInput
    MitraPackagesMekkah?: MitraPackageUncheckedCreateNestedManyWithoutHotelMekkahInput
    MitraPackagesMadinah?: MitraPackageUncheckedCreateNestedManyWithoutHotelMadinahInput
  }

  export type HotelUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    city?: EnumCityFieldUpdateOperationsInput | $Enums.City
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    Vendor?: VendorUpdateOneRequiredWithoutHotelsNestedInput
    HotelPeriodPrices?: HotelPeriodPriceUpdateManyWithoutHotelNestedInput
    MitraPackagesMekkah?: MitraPackageUpdateManyWithoutHotelMekkahNestedInput
    MitraPackagesMadinah?: MitraPackageUpdateManyWithoutHotelMadinahNestedInput
  }

  export type HotelUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    vendor_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    city?: EnumCityFieldUpdateOperationsInput | $Enums.City
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    HotelPeriodPrices?: HotelPeriodPriceUncheckedUpdateManyWithoutHotelNestedInput
    MitraPackagesMekkah?: MitraPackageUncheckedUpdateManyWithoutHotelMekkahNestedInput
    MitraPackagesMadinah?: MitraPackageUncheckedUpdateManyWithoutHotelMadinahNestedInput
  }

  export type HotelCreateManyInput = {
    id?: string
    vendor_id: string
    name: string
    city: $Enums.City
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type HotelUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    city?: EnumCityFieldUpdateOperationsInput | $Enums.City
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type HotelUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    vendor_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    city?: EnumCityFieldUpdateOperationsInput | $Enums.City
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PeriodCreateInput = {
    id?: string
    category?: $Enums.PeriodCategory
    start_date: Date | string
    end_date: Date | string
    created_at?: Date | string
    updated_at?: Date | string
    HotelPeriodPrices?: HotelPeriodPriceCreateNestedManyWithoutPeriodInput
    MitraPackages?: MitraPackageCreateNestedManyWithoutPeriodInput
  }

  export type PeriodUncheckedCreateInput = {
    id?: string
    category?: $Enums.PeriodCategory
    start_date: Date | string
    end_date: Date | string
    created_at?: Date | string
    updated_at?: Date | string
    HotelPeriodPrices?: HotelPeriodPriceUncheckedCreateNestedManyWithoutPeriodInput
    MitraPackages?: MitraPackageUncheckedCreateNestedManyWithoutPeriodInput
  }

  export type PeriodUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    category?: EnumPeriodCategoryFieldUpdateOperationsInput | $Enums.PeriodCategory
    start_date?: DateTimeFieldUpdateOperationsInput | Date | string
    end_date?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    HotelPeriodPrices?: HotelPeriodPriceUpdateManyWithoutPeriodNestedInput
    MitraPackages?: MitraPackageUpdateManyWithoutPeriodNestedInput
  }

  export type PeriodUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    category?: EnumPeriodCategoryFieldUpdateOperationsInput | $Enums.PeriodCategory
    start_date?: DateTimeFieldUpdateOperationsInput | Date | string
    end_date?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    HotelPeriodPrices?: HotelPeriodPriceUncheckedUpdateManyWithoutPeriodNestedInput
    MitraPackages?: MitraPackageUncheckedUpdateManyWithoutPeriodNestedInput
  }

  export type PeriodCreateManyInput = {
    id?: string
    category?: $Enums.PeriodCategory
    start_date: Date | string
    end_date: Date | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type PeriodUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    category?: EnumPeriodCategoryFieldUpdateOperationsInput | $Enums.PeriodCategory
    start_date?: DateTimeFieldUpdateOperationsInput | Date | string
    end_date?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PeriodUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    category?: EnumPeriodCategoryFieldUpdateOperationsInput | $Enums.PeriodCategory
    start_date?: DateTimeFieldUpdateOperationsInput | Date | string
    end_date?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type HotelPeriodPriceCreateInput = {
    id?: string
    price_double: Decimal | DecimalJsLike | number | string
    price_triple: Decimal | DecimalJsLike | number | string
    price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    Hotel: HotelCreateNestedOneWithoutHotelPeriodPricesInput
    Period: PeriodCreateNestedOneWithoutHotelPeriodPricesInput
  }

  export type HotelPeriodPriceUncheckedCreateInput = {
    id?: string
    hotel_id: string
    period_id: string
    price_double: Decimal | DecimalJsLike | number | string
    price_triple: Decimal | DecimalJsLike | number | string
    price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type HotelPeriodPriceUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    Hotel?: HotelUpdateOneRequiredWithoutHotelPeriodPricesNestedInput
    Period?: PeriodUpdateOneRequiredWithoutHotelPeriodPricesNestedInput
  }

  export type HotelPeriodPriceUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    hotel_id?: StringFieldUpdateOperationsInput | string
    period_id?: StringFieldUpdateOperationsInput | string
    price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type HotelPeriodPriceCreateManyInput = {
    id?: string
    hotel_id: string
    period_id: string
    price_double: Decimal | DecimalJsLike | number | string
    price_triple: Decimal | DecimalJsLike | number | string
    price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type HotelPeriodPriceUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type HotelPeriodPriceUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    hotel_id?: StringFieldUpdateOperationsInput | string
    period_id?: StringFieldUpdateOperationsInput | string
    price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AirlineCreateInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackages?: MitraPackageCreateNestedManyWithoutAirlineInput
  }

  export type AirlineUncheckedCreateInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackages?: MitraPackageUncheckedCreateNestedManyWithoutAirlineInput
  }

  export type AirlineUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackages?: MitraPackageUpdateManyWithoutAirlineNestedInput
  }

  export type AirlineUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackages?: MitraPackageUncheckedUpdateManyWithoutAirlineNestedInput
  }

  export type AirlineCreateManyInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type AirlineUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AirlineUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type VisaCreateInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackages?: MitraPackageCreateNestedManyWithoutVisaInput
  }

  export type VisaUncheckedCreateInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackages?: MitraPackageUncheckedCreateNestedManyWithoutVisaInput
  }

  export type VisaUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackages?: MitraPackageUpdateManyWithoutVisaNestedInput
  }

  export type VisaUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackages?: MitraPackageUncheckedUpdateManyWithoutVisaNestedInput
  }

  export type VisaCreateManyInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type VisaUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type VisaUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type TransportationCreateInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackage?: MitraPackageCreateNestedManyWithoutTransportationInput
  }

  export type TransportationUncheckedCreateInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackage?: MitraPackageUncheckedCreateNestedManyWithoutTransportationInput
  }

  export type TransportationUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackage?: MitraPackageUpdateManyWithoutTransportationNestedInput
  }

  export type TransportationUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackage?: MitraPackageUncheckedUpdateManyWithoutTransportationNestedInput
  }

  export type TransportationCreateManyInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type TransportationUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type TransportationUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MuthawifCreateInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackages?: MitraPackageCreateNestedManyWithoutMuthawifInput
  }

  export type MuthawifUncheckedCreateInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackages?: MitraPackageUncheckedCreateNestedManyWithoutMuthawifInput
  }

  export type MuthawifUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackages?: MitraPackageUpdateManyWithoutMuthawifNestedInput
  }

  export type MuthawifUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackages?: MitraPackageUncheckedUpdateManyWithoutMuthawifNestedInput
  }

  export type MuthawifCreateManyInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MuthawifUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MuthawifUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type HandlingSaudiCreateInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackages?: MitraPackageCreateNestedManyWithoutHandlingSaudiInput
  }

  export type HandlingSaudiUncheckedCreateInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackages?: MitraPackageUncheckedCreateNestedManyWithoutHandlingSaudiInput
  }

  export type HandlingSaudiUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackages?: MitraPackageUpdateManyWithoutHandlingSaudiNestedInput
  }

  export type HandlingSaudiUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackages?: MitraPackageUncheckedUpdateManyWithoutHandlingSaudiNestedInput
  }

  export type HandlingSaudiCreateManyInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type HandlingSaudiUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type HandlingSaudiUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type HandlingDomesticCreateInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackages?: MitraPackageCreateNestedManyWithoutHandlingDomesticInput
  }

  export type HandlingDomesticUncheckedCreateInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackages?: MitraPackageUncheckedCreateNestedManyWithoutHandlingDomesticInput
  }

  export type HandlingDomesticUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackages?: MitraPackageUpdateManyWithoutHandlingDomesticNestedInput
  }

  export type HandlingDomesticUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackages?: MitraPackageUncheckedUpdateManyWithoutHandlingDomesticNestedInput
  }

  export type HandlingDomesticCreateManyInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type HandlingDomesticUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type HandlingDomesticUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SiskopatuhCreateInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackages?: MitraPackageCreateNestedManyWithoutSiskopatuhInput
  }

  export type SiskopatuhUncheckedCreateInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackages?: MitraPackageUncheckedCreateNestedManyWithoutSiskopatuhInput
  }

  export type SiskopatuhUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackages?: MitraPackageUpdateManyWithoutSiskopatuhNestedInput
  }

  export type SiskopatuhUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackages?: MitraPackageUncheckedUpdateManyWithoutSiskopatuhNestedInput
  }

  export type SiskopatuhCreateManyInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type SiskopatuhUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SiskopatuhUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EquipmentCreateInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackages?: MitraPackageCreateNestedManyWithoutEquipmentInput
  }

  export type EquipmentUncheckedCreateInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackages?: MitraPackageUncheckedCreateNestedManyWithoutEquipmentInput
  }

  export type EquipmentUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackages?: MitraPackageUpdateManyWithoutEquipmentNestedInput
  }

  export type EquipmentUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackages?: MitraPackageUncheckedUpdateManyWithoutEquipmentNestedInput
  }

  export type EquipmentCreateManyInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type EquipmentUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EquipmentUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type TourPlusCreateInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackages?: MitraPackageCreateNestedManyWithoutTourPlusInput
  }

  export type TourPlusUncheckedCreateInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackages?: MitraPackageUncheckedCreateNestedManyWithoutTourPlusInput
  }

  export type TourPlusUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackages?: MitraPackageUpdateManyWithoutTourPlusNestedInput
  }

  export type TourPlusUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackages?: MitraPackageUncheckedUpdateManyWithoutTourPlusNestedInput
  }

  export type TourPlusCreateManyInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type TourPlusUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type TourPlusUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ManasikCreateInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackages?: MitraPackageCreateNestedManyWithoutManasikInput
  }

  export type ManasikUncheckedCreateInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackages?: MitraPackageUncheckedCreateNestedManyWithoutManasikInput
  }

  export type ManasikUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackages?: MitraPackageUpdateManyWithoutManasikNestedInput
  }

  export type ManasikUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackages?: MitraPackageUncheckedUpdateManyWithoutManasikNestedInput
  }

  export type ManasikCreateManyInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type ManasikUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ManasikUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraPackageCreateInput = {
    id?: string
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderCreateNestedManyWithoutMitraPackageInput
    period?: PeriodCreateNestedOneWithoutMitraPackagesInput
    airline?: AirlineCreateNestedOneWithoutMitraPackagesInput
    vendor?: VendorCreateNestedOneWithoutMitraPackagesInput
    hotelMekkah?: HotelCreateNestedOneWithoutMitraPackagesMekkahInput
    hotelMadinah?: HotelCreateNestedOneWithoutMitraPackagesMadinahInput
    visa?: VisaCreateNestedOneWithoutMitraPackagesInput
    transportation?: TransportationCreateNestedOneWithoutMitraPackageInput
    muthawif?: MuthawifCreateNestedOneWithoutMitraPackagesInput
    handlingSaudi?: HandlingSaudiCreateNestedOneWithoutMitraPackagesInput
    handlingDomestic?: HandlingDomesticCreateNestedOneWithoutMitraPackagesInput
    siskopatuh?: SiskopatuhCreateNestedOneWithoutMitraPackagesInput
    equipment?: EquipmentCreateNestedOneWithoutMitraPackagesInput
    tourPlus?: TourPlusCreateNestedOneWithoutMitraPackagesInput
    manasik?: ManasikCreateNestedOneWithoutMitraPackagesInput
  }

  export type MitraPackageUncheckedCreateInput = {
    id?: string
    period_id?: string | null
    airline_id?: string | null
    vendor_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    visa_id?: string | null
    transportation_id?: string | null
    muthawif_id?: string | null
    handling_saudi_id?: string | null
    handling_domestic_id?: string | null
    siskopatuh_id?: string | null
    equipment_id?: string | null
    tour_plus_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedCreateNestedManyWithoutMitraPackageInput
  }

  export type MitraPackageUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUpdateManyWithoutMitraPackageNestedInput
    period?: PeriodUpdateOneWithoutMitraPackagesNestedInput
    airline?: AirlineUpdateOneWithoutMitraPackagesNestedInput
    vendor?: VendorUpdateOneWithoutMitraPackagesNestedInput
    hotelMekkah?: HotelUpdateOneWithoutMitraPackagesMekkahNestedInput
    hotelMadinah?: HotelUpdateOneWithoutMitraPackagesMadinahNestedInput
    visa?: VisaUpdateOneWithoutMitraPackagesNestedInput
    transportation?: TransportationUpdateOneWithoutMitraPackageNestedInput
    muthawif?: MuthawifUpdateOneWithoutMitraPackagesNestedInput
    handlingSaudi?: HandlingSaudiUpdateOneWithoutMitraPackagesNestedInput
    handlingDomestic?: HandlingDomesticUpdateOneWithoutMitraPackagesNestedInput
    siskopatuh?: SiskopatuhUpdateOneWithoutMitraPackagesNestedInput
    equipment?: EquipmentUpdateOneWithoutMitraPackagesNestedInput
    tourPlus?: TourPlusUpdateOneWithoutMitraPackagesNestedInput
    manasik?: ManasikUpdateOneWithoutMitraPackagesNestedInput
  }

  export type MitraPackageUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedUpdateManyWithoutMitraPackageNestedInput
  }

  export type MitraPackageCreateManyInput = {
    id?: string
    period_id?: string | null
    airline_id?: string | null
    vendor_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    visa_id?: string | null
    transportation_id?: string | null
    muthawif_id?: string | null
    handling_saudi_id?: string | null
    handling_domestic_id?: string | null
    siskopatuh_id?: string | null
    equipment_id?: string | null
    tour_plus_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MitraPackageUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraPackageUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraPackageOrderCreateInput = {
    id?: string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackage: MitraPackageCreateNestedOneWithoutMitraPackageOrdersInput
    User: UserCreateNestedOneWithoutMitraPackageOrderInput
  }

  export type MitraPackageOrderUncheckedCreateInput = {
    id?: string
    user_id: string
    mitra_package_id: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MitraPackageOrderUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackage?: MitraPackageUpdateOneRequiredWithoutMitraPackageOrdersNestedInput
    User?: UserUpdateOneRequiredWithoutMitraPackageOrderNestedInput
  }

  export type MitraPackageOrderUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    mitra_package_id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraPackageOrderCreateManyInput = {
    id?: string
    user_id: string
    mitra_package_id: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MitraPackageOrderUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraPackageOrderUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    mitra_package_id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ExchangeRateCreateInput = {
    id?: string
    currency: string
    rate_idr: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type ExchangeRateUncheckedCreateInput = {
    id?: string
    currency: string
    rate_idr: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type ExchangeRateUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    currency?: StringFieldUpdateOperationsInput | string
    rate_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ExchangeRateUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    currency?: StringFieldUpdateOperationsInput | string
    rate_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ExchangeRateCreateManyInput = {
    id?: string
    currency: string
    rate_idr: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type ExchangeRateUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    currency?: StringFieldUpdateOperationsInput | string
    rate_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ExchangeRateUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    currency?: StringFieldUpdateOperationsInput | string
    rate_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ContactCreateInput = {
    id?: string
    name: string
    value?: string | null
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type ContactUncheckedCreateInput = {
    id?: string
    name: string
    value?: string | null
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type ContactUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    value?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ContactUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    value?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ContactCreateManyInput = {
    id?: string
    name: string
    value?: string | null
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type ContactUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    value?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ContactUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    value?: NullableStringFieldUpdateOperationsInput | string | null
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FaqCreateInput = {
    id?: string
    question: string
    answer: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type FaqUncheckedCreateInput = {
    id?: string
    question: string
    answer: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type FaqUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    question?: StringFieldUpdateOperationsInput | string
    answer?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FaqUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    question?: StringFieldUpdateOperationsInput | string
    answer?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FaqCreateManyInput = {
    id?: string
    question: string
    answer: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type FaqUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    question?: StringFieldUpdateOperationsInput | string
    answer?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FaqUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    question?: StringFieldUpdateOperationsInput | string
    answer?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ContentCreateInput = {
    id?: string
    page: string
    section: string
    type: $Enums.ContentType
    key: string
    value: JsonNullValueInput | InputJsonValue
    visible?: boolean
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type ContentUncheckedCreateInput = {
    id?: string
    page: string
    section: string
    type: $Enums.ContentType
    key: string
    value: JsonNullValueInput | InputJsonValue
    visible?: boolean
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type ContentUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    page?: StringFieldUpdateOperationsInput | string
    section?: StringFieldUpdateOperationsInput | string
    type?: EnumContentTypeFieldUpdateOperationsInput | $Enums.ContentType
    key?: StringFieldUpdateOperationsInput | string
    value?: JsonNullValueInput | InputJsonValue
    visible?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ContentUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    page?: StringFieldUpdateOperationsInput | string
    section?: StringFieldUpdateOperationsInput | string
    type?: EnumContentTypeFieldUpdateOperationsInput | $Enums.ContentType
    key?: StringFieldUpdateOperationsInput | string
    value?: JsonNullValueInput | InputJsonValue
    visible?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ContentCreateManyInput = {
    id?: string
    page: string
    section: string
    type: $Enums.ContentType
    key: string
    value: JsonNullValueInput | InputJsonValue
    visible?: boolean
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type ContentUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    page?: StringFieldUpdateOperationsInput | string
    section?: StringFieldUpdateOperationsInput | string
    type?: EnumContentTypeFieldUpdateOperationsInput | $Enums.ContentType
    key?: StringFieldUpdateOperationsInput | string
    value?: JsonNullValueInput | InputJsonValue
    visible?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ContentUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    page?: StringFieldUpdateOperationsInput | string
    section?: StringFieldUpdateOperationsInput | string
    type?: EnumContentTypeFieldUpdateOperationsInput | $Enums.ContentType
    key?: StringFieldUpdateOperationsInput | string
    value?: JsonNullValueInput | InputJsonValue
    visible?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MenuItemCreateInput = {
    id?: string
    name: string
    url: string
    visible?: boolean
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MenuItemUncheckedCreateInput = {
    id?: string
    name: string
    url: string
    visible?: boolean
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MenuItemUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    visible?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MenuItemUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    visible?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MenuItemCreateManyInput = {
    id?: string
    name: string
    url: string
    visible?: boolean
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MenuItemUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    visible?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MenuItemUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    visible?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FooterCreateInput = {
    id?: string
    name: string
    type: $Enums.FooterType
    visible?: boolean
    order?: number
    created_at?: Date | string
    updated_at?: Date | string
    FooterItem?: FooterItemCreateNestedManyWithoutFooterInput
  }

  export type FooterUncheckedCreateInput = {
    id?: string
    name: string
    type: $Enums.FooterType
    visible?: boolean
    order?: number
    created_at?: Date | string
    updated_at?: Date | string
    FooterItem?: FooterItemUncheckedCreateNestedManyWithoutFooterInput
  }

  export type FooterUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    type?: EnumFooterTypeFieldUpdateOperationsInput | $Enums.FooterType
    visible?: BoolFieldUpdateOperationsInput | boolean
    order?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    FooterItem?: FooterItemUpdateManyWithoutFooterNestedInput
  }

  export type FooterUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    type?: EnumFooterTypeFieldUpdateOperationsInput | $Enums.FooterType
    visible?: BoolFieldUpdateOperationsInput | boolean
    order?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    FooterItem?: FooterItemUncheckedUpdateManyWithoutFooterNestedInput
  }

  export type FooterCreateManyInput = {
    id?: string
    name: string
    type: $Enums.FooterType
    visible?: boolean
    order?: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type FooterUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    type?: EnumFooterTypeFieldUpdateOperationsInput | $Enums.FooterType
    visible?: BoolFieldUpdateOperationsInput | boolean
    order?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FooterUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    type?: EnumFooterTypeFieldUpdateOperationsInput | $Enums.FooterType
    visible?: BoolFieldUpdateOperationsInput | boolean
    order?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FooterItemCreateInput = {
    id?: string
    name: string
    url: string
    visible?: boolean
    created_at?: Date | string
    updated_at?: Date | string
    Footer: FooterCreateNestedOneWithoutFooterItemInput
  }

  export type FooterItemUncheckedCreateInput = {
    id?: string
    footer_id: string
    name: string
    url: string
    visible?: boolean
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type FooterItemUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    visible?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    Footer?: FooterUpdateOneRequiredWithoutFooterItemNestedInput
  }

  export type FooterItemUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    footer_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    visible?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FooterItemCreateManyInput = {
    id?: string
    footer_id: string
    name: string
    url: string
    visible?: boolean
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type FooterItemUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    visible?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FooterItemUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    footer_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    visible?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ColorCreateInput = {
    id?: string
    name: string
    hex: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type ColorUncheckedCreateInput = {
    id?: string
    name: string
    hex: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type ColorUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    hex?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ColorUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    hex?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ColorCreateManyInput = {
    id?: string
    name: string
    hex: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type ColorUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    hex?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ColorUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    hex?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  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 EnumRoleFilter<$PrismaModel = never> = {
    equals?: $Enums.Role | EnumRoleFieldRefInput<$PrismaModel>
    in?: $Enums.Role[]
    notIn?: $Enums.Role[]
    not?: NestedEnumRoleFilter<$PrismaModel> | $Enums.Role
  }

  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 ProductOrderListRelationFilter = {
    every?: ProductOrderWhereInput
    some?: ProductOrderWhereInput
    none?: ProductOrderWhereInput
  }

  export type MitraPackageOrderListRelationFilter = {
    every?: MitraPackageOrderWhereInput
    some?: MitraPackageOrderWhereInput
    none?: MitraPackageOrderWhereInput
  }

  export type MitraRequestListRelationFilter = {
    every?: MitraRequestWhereInput
    some?: MitraRequestWhereInput
    none?: MitraRequestWhereInput
  }

  export type ProductOrderOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type MitraPackageOrderOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type MitraRequestOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type UserCountOrderByAggregateInput = {
    id?: SortOrder
    email?: SortOrder
    full_name?: SortOrder
    password?: SortOrder
    whatsapp_number?: SortOrder
    role?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type UserMaxOrderByAggregateInput = {
    id?: SortOrder
    email?: SortOrder
    full_name?: SortOrder
    password?: SortOrder
    whatsapp_number?: SortOrder
    role?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type UserMinOrderByAggregateInput = {
    id?: SortOrder
    email?: SortOrder
    full_name?: SortOrder
    password?: SortOrder
    whatsapp_number?: SortOrder
    role?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  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 EnumRoleWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.Role | EnumRoleFieldRefInput<$PrismaModel>
    in?: $Enums.Role[]
    notIn?: $Enums.Role[]
    not?: NestedEnumRoleWithAggregatesFilter<$PrismaModel> | $Enums.Role
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumRoleFilter<$PrismaModel>
    _max?: NestedEnumRoleFilter<$PrismaModel>
  }

  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 DecimalFilter<$PrismaModel = never> = {
    equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    in?: Decimal[] | DecimalJsLike[] | number[] | string[]
    notIn?: Decimal[] | DecimalJsLike[] | number[] | string[]
    lt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    lte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    not?: NestedDecimalFilter<$PrismaModel> | Decimal | DecimalJsLike | number | string
  }

  export type EnumRequestStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.RequestStatus | EnumRequestStatusFieldRefInput<$PrismaModel>
    in?: $Enums.RequestStatus[]
    notIn?: $Enums.RequestStatus[]
    not?: NestedEnumRequestStatusFilter<$PrismaModel> | $Enums.RequestStatus
  }

  export type UserRelationFilter = {
    is?: UserWhereInput
    isNot?: UserWhereInput
  }

  export type MitraRequestCountOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    ktp?: SortOrder
    upgrade_amount?: SortOrder
    payment_proof?: SortOrder
    status?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type MitraRequestAvgOrderByAggregateInput = {
    upgrade_amount?: SortOrder
  }

  export type MitraRequestMaxOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    ktp?: SortOrder
    upgrade_amount?: SortOrder
    payment_proof?: SortOrder
    status?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type MitraRequestMinOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    ktp?: SortOrder
    upgrade_amount?: SortOrder
    payment_proof?: SortOrder
    status?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type MitraRequestSumOrderByAggregateInput = {
    upgrade_amount?: SortOrder
  }

  export type DecimalWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    in?: Decimal[] | DecimalJsLike[] | number[] | string[]
    notIn?: Decimal[] | DecimalJsLike[] | number[] | string[]
    lt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    lte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    not?: NestedDecimalWithAggregatesFilter<$PrismaModel> | Decimal | DecimalJsLike | number | string
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedDecimalFilter<$PrismaModel>
    _sum?: NestedDecimalFilter<$PrismaModel>
    _min?: NestedDecimalFilter<$PrismaModel>
    _max?: NestedDecimalFilter<$PrismaModel>
  }

  export type EnumRequestStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.RequestStatus | EnumRequestStatusFieldRefInput<$PrismaModel>
    in?: $Enums.RequestStatus[]
    notIn?: $Enums.RequestStatus[]
    not?: NestedEnumRequestStatusWithAggregatesFilter<$PrismaModel> | $Enums.RequestStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumRequestStatusFilter<$PrismaModel>
    _max?: NestedEnumRequestStatusFilter<$PrismaModel>
  }

  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 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 UserPackageOrderListRelationFilter = {
    every?: UserPackageOrderWhereInput
    some?: UserPackageOrderWhereInput
    none?: UserPackageOrderWhereInput
  }

  export type UserPackageOptionNullableRelationFilter = {
    is?: UserPackageOptionWhereInput | null
    isNot?: UserPackageOptionWhereInput | null
  }

  export type SortOrderInput = {
    sort: SortOrder
    nulls?: NullsOrder
  }

  export type UserPackageOrderOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type UserPackageCountOrderByAggregateInput = {
    id?: SortOrder
    transportation_id?: SortOrder
    flight_id?: SortOrder
    hotel_mekkah_id?: SortOrder
    hotel_madinah_id?: SortOrder
    muthawif_id?: SortOrder
    handling_id?: SortOrder
    number_of_pax?: SortOrder
    travel_duration?: SortOrder
    mekkah_duration?: SortOrder
    madinah_duration?: SortOrder
    per_pax_price?: SortOrder
    total_price?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type UserPackageAvgOrderByAggregateInput = {
    number_of_pax?: SortOrder
    travel_duration?: SortOrder
    mekkah_duration?: SortOrder
    madinah_duration?: SortOrder
    per_pax_price?: SortOrder
    total_price?: SortOrder
  }

  export type UserPackageMaxOrderByAggregateInput = {
    id?: SortOrder
    transportation_id?: SortOrder
    flight_id?: SortOrder
    hotel_mekkah_id?: SortOrder
    hotel_madinah_id?: SortOrder
    muthawif_id?: SortOrder
    handling_id?: SortOrder
    number_of_pax?: SortOrder
    travel_duration?: SortOrder
    mekkah_duration?: SortOrder
    madinah_duration?: SortOrder
    per_pax_price?: SortOrder
    total_price?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type UserPackageMinOrderByAggregateInput = {
    id?: SortOrder
    transportation_id?: SortOrder
    flight_id?: SortOrder
    hotel_mekkah_id?: SortOrder
    hotel_madinah_id?: SortOrder
    muthawif_id?: SortOrder
    handling_id?: SortOrder
    number_of_pax?: SortOrder
    travel_duration?: SortOrder
    mekkah_duration?: SortOrder
    madinah_duration?: SortOrder
    per_pax_price?: SortOrder
    total_price?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type UserPackageSumOrderByAggregateInput = {
    number_of_pax?: SortOrder
    travel_duration?: SortOrder
    mekkah_duration?: SortOrder
    madinah_duration?: SortOrder
    per_pax_price?: SortOrder
    total_price?: SortOrder
  }

  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 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 BoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  export type UserPackageOptionListRelationFilter = {
    every?: UserPackageOptionWhereInput
    some?: UserPackageOptionWhereInput
    none?: UserPackageOptionWhereInput
  }

  export type UserPackageOptionOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type PackageTypeCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    is_public?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type PackageTypeMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    is_public?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type PackageTypeMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    is_public?: SortOrder
    created_at?: SortOrder
    updated_at?: 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 UserPackageListRelationFilter = {
    every?: UserPackageWhereInput
    some?: UserPackageWhereInput
    none?: UserPackageWhereInput
  }

  export type PackageTypeRelationFilter = {
    is?: PackageTypeWhereInput
    isNot?: PackageTypeWhereInput
  }

  export type UserPackageOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type UserPackageOptionCountOrderByAggregateInput = {
    id?: SortOrder
    package_type_id?: SortOrder
    name?: SortOrder
    price?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type UserPackageOptionAvgOrderByAggregateInput = {
    price?: SortOrder
    order_number?: SortOrder
  }

  export type UserPackageOptionMaxOrderByAggregateInput = {
    id?: SortOrder
    package_type_id?: SortOrder
    name?: SortOrder
    price?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type UserPackageOptionMinOrderByAggregateInput = {
    id?: SortOrder
    package_type_id?: SortOrder
    name?: SortOrder
    price?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type UserPackageOptionSumOrderByAggregateInput = {
    price?: SortOrder
    order_number?: SortOrder
  }

  export type UserPackageRelationFilter = {
    is?: UserPackageWhereInput
    isNot?: UserPackageWhereInput
  }

  export type UserPackageOrderCountOrderByAggregateInput = {
    id?: SortOrder
    full_name?: SortOrder
    email?: SortOrder
    whatsapp_number?: SortOrder
    user_package_id?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type UserPackageOrderMaxOrderByAggregateInput = {
    id?: SortOrder
    full_name?: SortOrder
    email?: SortOrder
    whatsapp_number?: SortOrder
    user_package_id?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type UserPackageOrderMinOrderByAggregateInput = {
    id?: SortOrder
    full_name?: SortOrder
    email?: SortOrder
    whatsapp_number?: SortOrder
    user_package_id?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ProductCategoryListRelationFilter = {
    every?: ProductCategoryWhereInput
    some?: ProductCategoryWhereInput
    none?: ProductCategoryWhereInput
  }

  export type ProductCategoryOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type CategoryCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type CategoryMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type CategoryMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ProductThumbnailListRelationFilter = {
    every?: ProductThumbnailWhereInput
    some?: ProductThumbnailWhereInput
    none?: ProductThumbnailWhereInput
  }

  export type ProductVariationListRelationFilter = {
    every?: ProductVariationWhereInput
    some?: ProductVariationWhereInput
    none?: ProductVariationWhereInput
  }

  export type ProductIncludeListRelationFilter = {
    every?: ProductIncludeWhereInput
    some?: ProductIncludeWhereInput
    none?: ProductIncludeWhereInput
  }

  export type ProductExcludeListRelationFilter = {
    every?: ProductExcludeWhereInput
    some?: ProductExcludeWhereInput
    none?: ProductExcludeWhereInput
  }

  export type ProductThumbnailOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ProductVariationOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ProductIncludeOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ProductExcludeOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ProductCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrder
    price?: SortOrder
    has_variation?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ProductAvgOrderByAggregateInput = {
    price?: SortOrder
  }

  export type ProductMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrder
    price?: SortOrder
    has_variation?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ProductMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    description?: SortOrder
    price?: SortOrder
    has_variation?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ProductSumOrderByAggregateInput = {
    price?: SortOrder
  }

  export type ProductRelationFilter = {
    is?: ProductWhereInput
    isNot?: ProductWhereInput
  }

  export type ProductThumbnailCountOrderByAggregateInput = {
    id?: SortOrder
    increment?: SortOrder
    product_id?: SortOrder
    image_url?: SortOrder
  }

  export type ProductThumbnailAvgOrderByAggregateInput = {
    increment?: SortOrder
  }

  export type ProductThumbnailMaxOrderByAggregateInput = {
    id?: SortOrder
    increment?: SortOrder
    product_id?: SortOrder
    image_url?: SortOrder
  }

  export type ProductThumbnailMinOrderByAggregateInput = {
    id?: SortOrder
    increment?: SortOrder
    product_id?: SortOrder
    image_url?: SortOrder
  }

  export type ProductThumbnailSumOrderByAggregateInput = {
    increment?: SortOrder
  }

  export type CategoryRelationFilter = {
    is?: CategoryWhereInput
    isNot?: CategoryWhereInput
  }

  export type ProductCategoryCountOrderByAggregateInput = {
    id?: SortOrder
    product_id?: SortOrder
    category_id?: SortOrder
  }

  export type ProductCategoryMaxOrderByAggregateInput = {
    id?: SortOrder
    product_id?: SortOrder
    category_id?: SortOrder
  }

  export type ProductCategoryMinOrderByAggregateInput = {
    id?: SortOrder
    product_id?: SortOrder
    category_id?: SortOrder
  }

  export type ProductVariationCountOrderByAggregateInput = {
    id?: SortOrder
    increment?: SortOrder
    product_id?: SortOrder
    name?: SortOrder
    price?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ProductVariationAvgOrderByAggregateInput = {
    increment?: SortOrder
    price?: SortOrder
  }

  export type ProductVariationMaxOrderByAggregateInput = {
    id?: SortOrder
    increment?: SortOrder
    product_id?: SortOrder
    name?: SortOrder
    price?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ProductVariationMinOrderByAggregateInput = {
    id?: SortOrder
    increment?: SortOrder
    product_id?: SortOrder
    name?: SortOrder
    price?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ProductVariationSumOrderByAggregateInput = {
    increment?: SortOrder
    price?: SortOrder
  }

  export type ProductIncludeCountOrderByAggregateInput = {
    id?: SortOrder
    increment?: SortOrder
    product_id?: SortOrder
    description?: SortOrder
  }

  export type ProductIncludeAvgOrderByAggregateInput = {
    increment?: SortOrder
  }

  export type ProductIncludeMaxOrderByAggregateInput = {
    id?: SortOrder
    increment?: SortOrder
    product_id?: SortOrder
    description?: SortOrder
  }

  export type ProductIncludeMinOrderByAggregateInput = {
    id?: SortOrder
    increment?: SortOrder
    product_id?: SortOrder
    description?: SortOrder
  }

  export type ProductIncludeSumOrderByAggregateInput = {
    increment?: SortOrder
  }

  export type ProductExcludeCountOrderByAggregateInput = {
    id?: SortOrder
    increment?: SortOrder
    product_id?: SortOrder
    description?: SortOrder
  }

  export type ProductExcludeAvgOrderByAggregateInput = {
    increment?: SortOrder
  }

  export type ProductExcludeMaxOrderByAggregateInput = {
    id?: SortOrder
    increment?: SortOrder
    product_id?: SortOrder
    description?: SortOrder
  }

  export type ProductExcludeMinOrderByAggregateInput = {
    id?: SortOrder
    increment?: SortOrder
    product_id?: SortOrder
    description?: SortOrder
  }

  export type ProductExcludeSumOrderByAggregateInput = {
    increment?: SortOrder
  }

  export type ProductVariationNullableRelationFilter = {
    is?: ProductVariationWhereInput | null
    isNot?: ProductVariationWhereInput | null
  }

  export type ProductOrderCountOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    product_id?: SortOrder
    variation_id?: SortOrder
    departure?: SortOrder
    number_of_pax?: SortOrder
    per_pax_price?: SortOrder
    total_price?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ProductOrderAvgOrderByAggregateInput = {
    number_of_pax?: SortOrder
    per_pax_price?: SortOrder
    total_price?: SortOrder
  }

  export type ProductOrderMaxOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    product_id?: SortOrder
    variation_id?: SortOrder
    departure?: SortOrder
    number_of_pax?: SortOrder
    per_pax_price?: SortOrder
    total_price?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ProductOrderMinOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    product_id?: SortOrder
    variation_id?: SortOrder
    departure?: SortOrder
    number_of_pax?: SortOrder
    per_pax_price?: SortOrder
    total_price?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ProductOrderSumOrderByAggregateInput = {
    number_of_pax?: SortOrder
    per_pax_price?: SortOrder
    total_price?: SortOrder
  }

  export type HotelListRelationFilter = {
    every?: HotelWhereInput
    some?: HotelWhereInput
    none?: HotelWhereInput
  }

  export type MitraPackageListRelationFilter = {
    every?: MitraPackageWhereInput
    some?: MitraPackageWhereInput
    none?: MitraPackageWhereInput
  }

  export type HotelOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type MitraPackageOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type VendorCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type VendorMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type VendorMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type EnumCityFilter<$PrismaModel = never> = {
    equals?: $Enums.City | EnumCityFieldRefInput<$PrismaModel>
    in?: $Enums.City[]
    notIn?: $Enums.City[]
    not?: NestedEnumCityFilter<$PrismaModel> | $Enums.City
  }

  export type VendorRelationFilter = {
    is?: VendorWhereInput
    isNot?: VendorWhereInput
  }

  export type HotelPeriodPriceListRelationFilter = {
    every?: HotelPeriodPriceWhereInput
    some?: HotelPeriodPriceWhereInput
    none?: HotelPeriodPriceWhereInput
  }

  export type HotelPeriodPriceOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type HotelCountOrderByAggregateInput = {
    id?: SortOrder
    vendor_id?: SortOrder
    name?: SortOrder
    city?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type HotelAvgOrderByAggregateInput = {
    order_number?: SortOrder
  }

  export type HotelMaxOrderByAggregateInput = {
    id?: SortOrder
    vendor_id?: SortOrder
    name?: SortOrder
    city?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type HotelMinOrderByAggregateInput = {
    id?: SortOrder
    vendor_id?: SortOrder
    name?: SortOrder
    city?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type HotelSumOrderByAggregateInput = {
    order_number?: SortOrder
  }

  export type EnumCityWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.City | EnumCityFieldRefInput<$PrismaModel>
    in?: $Enums.City[]
    notIn?: $Enums.City[]
    not?: NestedEnumCityWithAggregatesFilter<$PrismaModel> | $Enums.City
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumCityFilter<$PrismaModel>
    _max?: NestedEnumCityFilter<$PrismaModel>
  }

  export type EnumPeriodCategoryFilter<$PrismaModel = never> = {
    equals?: $Enums.PeriodCategory | EnumPeriodCategoryFieldRefInput<$PrismaModel>
    in?: $Enums.PeriodCategory[]
    notIn?: $Enums.PeriodCategory[]
    not?: NestedEnumPeriodCategoryFilter<$PrismaModel> | $Enums.PeriodCategory
  }

  export type PeriodCountOrderByAggregateInput = {
    id?: SortOrder
    category?: SortOrder
    start_date?: SortOrder
    end_date?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type PeriodMaxOrderByAggregateInput = {
    id?: SortOrder
    category?: SortOrder
    start_date?: SortOrder
    end_date?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type PeriodMinOrderByAggregateInput = {
    id?: SortOrder
    category?: SortOrder
    start_date?: SortOrder
    end_date?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type EnumPeriodCategoryWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.PeriodCategory | EnumPeriodCategoryFieldRefInput<$PrismaModel>
    in?: $Enums.PeriodCategory[]
    notIn?: $Enums.PeriodCategory[]
    not?: NestedEnumPeriodCategoryWithAggregatesFilter<$PrismaModel> | $Enums.PeriodCategory
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumPeriodCategoryFilter<$PrismaModel>
    _max?: NestedEnumPeriodCategoryFilter<$PrismaModel>
  }

  export type HotelRelationFilter = {
    is?: HotelWhereInput
    isNot?: HotelWhereInput
  }

  export type PeriodRelationFilter = {
    is?: PeriodWhereInput
    isNot?: PeriodWhereInput
  }

  export type HotelPeriodPriceHotel_idPeriod_idCompoundUniqueInput = {
    hotel_id: string
    period_id: string
  }

  export type HotelPeriodPriceCountOrderByAggregateInput = {
    id?: SortOrder
    hotel_id?: SortOrder
    period_id?: SortOrder
    price_double?: SortOrder
    price_triple?: SortOrder
    price_quad?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type HotelPeriodPriceAvgOrderByAggregateInput = {
    price_double?: SortOrder
    price_triple?: SortOrder
    price_quad?: SortOrder
  }

  export type HotelPeriodPriceMaxOrderByAggregateInput = {
    id?: SortOrder
    hotel_id?: SortOrder
    period_id?: SortOrder
    price_double?: SortOrder
    price_triple?: SortOrder
    price_quad?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type HotelPeriodPriceMinOrderByAggregateInput = {
    id?: SortOrder
    hotel_id?: SortOrder
    period_id?: SortOrder
    price_double?: SortOrder
    price_triple?: SortOrder
    price_quad?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type HotelPeriodPriceSumOrderByAggregateInput = {
    price_double?: SortOrder
    price_triple?: SortOrder
    price_quad?: SortOrder
  }

  export type AirlineCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type AirlineAvgOrderByAggregateInput = {
    price_idr?: SortOrder
    order_number?: SortOrder
  }

  export type AirlineMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type AirlineMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type AirlineSumOrderByAggregateInput = {
    price_idr?: SortOrder
    order_number?: SortOrder
  }

  export type VisaCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type VisaAvgOrderByAggregateInput = {
    price_idr?: SortOrder
    order_number?: SortOrder
  }

  export type VisaMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type VisaMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type VisaSumOrderByAggregateInput = {
    price_idr?: SortOrder
    order_number?: SortOrder
  }

  export type TransportationCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type TransportationAvgOrderByAggregateInput = {
    price_idr?: SortOrder
    order_number?: SortOrder
  }

  export type TransportationMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type TransportationMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type TransportationSumOrderByAggregateInput = {
    price_idr?: SortOrder
    order_number?: SortOrder
  }

  export type MuthawifCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type MuthawifAvgOrderByAggregateInput = {
    price_idr?: SortOrder
    order_number?: SortOrder
  }

  export type MuthawifMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type MuthawifMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type MuthawifSumOrderByAggregateInput = {
    price_idr?: SortOrder
    order_number?: SortOrder
  }

  export type HandlingSaudiCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type HandlingSaudiAvgOrderByAggregateInput = {
    price_idr?: SortOrder
    order_number?: SortOrder
  }

  export type HandlingSaudiMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type HandlingSaudiMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type HandlingSaudiSumOrderByAggregateInput = {
    price_idr?: SortOrder
    order_number?: SortOrder
  }

  export type HandlingDomesticCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type HandlingDomesticAvgOrderByAggregateInput = {
    price_idr?: SortOrder
    order_number?: SortOrder
  }

  export type HandlingDomesticMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type HandlingDomesticMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type HandlingDomesticSumOrderByAggregateInput = {
    price_idr?: SortOrder
    order_number?: SortOrder
  }

  export type SiskopatuhCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type SiskopatuhAvgOrderByAggregateInput = {
    price_idr?: SortOrder
    order_number?: SortOrder
  }

  export type SiskopatuhMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type SiskopatuhMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type SiskopatuhSumOrderByAggregateInput = {
    price_idr?: SortOrder
    order_number?: SortOrder
  }

  export type EquipmentCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type EquipmentAvgOrderByAggregateInput = {
    price_idr?: SortOrder
    order_number?: SortOrder
  }

  export type EquipmentMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type EquipmentMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type EquipmentSumOrderByAggregateInput = {
    price_idr?: SortOrder
    order_number?: SortOrder
  }

  export type TourPlusCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type TourPlusAvgOrderByAggregateInput = {
    price_idr?: SortOrder
    order_number?: SortOrder
  }

  export type TourPlusMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type TourPlusMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type TourPlusSumOrderByAggregateInput = {
    price_idr?: SortOrder
    order_number?: SortOrder
  }

  export type ManasikCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ManasikAvgOrderByAggregateInput = {
    price_idr?: SortOrder
    order_number?: SortOrder
  }

  export type ManasikMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ManasikMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    price_idr?: SortOrder
    order_number?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ManasikSumOrderByAggregateInput = {
    price_idr?: SortOrder
    order_number?: SortOrder
  }

  export type PeriodNullableRelationFilter = {
    is?: PeriodWhereInput | null
    isNot?: PeriodWhereInput | null
  }

  export type AirlineNullableRelationFilter = {
    is?: AirlineWhereInput | null
    isNot?: AirlineWhereInput | null
  }

  export type VendorNullableRelationFilter = {
    is?: VendorWhereInput | null
    isNot?: VendorWhereInput | null
  }

  export type HotelNullableRelationFilter = {
    is?: HotelWhereInput | null
    isNot?: HotelWhereInput | null
  }

  export type VisaNullableRelationFilter = {
    is?: VisaWhereInput | null
    isNot?: VisaWhereInput | null
  }

  export type TransportationNullableRelationFilter = {
    is?: TransportationWhereInput | null
    isNot?: TransportationWhereInput | null
  }

  export type MuthawifNullableRelationFilter = {
    is?: MuthawifWhereInput | null
    isNot?: MuthawifWhereInput | null
  }

  export type HandlingSaudiNullableRelationFilter = {
    is?: HandlingSaudiWhereInput | null
    isNot?: HandlingSaudiWhereInput | null
  }

  export type HandlingDomesticNullableRelationFilter = {
    is?: HandlingDomesticWhereInput | null
    isNot?: HandlingDomesticWhereInput | null
  }

  export type SiskopatuhNullableRelationFilter = {
    is?: SiskopatuhWhereInput | null
    isNot?: SiskopatuhWhereInput | null
  }

  export type EquipmentNullableRelationFilter = {
    is?: EquipmentWhereInput | null
    isNot?: EquipmentWhereInput | null
  }

  export type TourPlusNullableRelationFilter = {
    is?: TourPlusWhereInput | null
    isNot?: TourPlusWhereInput | null
  }

  export type ManasikNullableRelationFilter = {
    is?: ManasikWhereInput | null
    isNot?: ManasikWhereInput | null
  }

  export type MitraPackageCountOrderByAggregateInput = {
    id?: SortOrder
    period_id?: SortOrder
    airline_id?: SortOrder
    vendor_id?: SortOrder
    hotel_mekkah_id?: SortOrder
    hotel_madinah_id?: SortOrder
    visa_id?: SortOrder
    transportation_id?: SortOrder
    muthawif_id?: SortOrder
    handling_saudi_id?: SortOrder
    handling_domestic_id?: SortOrder
    siskopatuh_id?: SortOrder
    equipment_id?: SortOrder
    tour_plus_id?: SortOrder
    manasik_id?: SortOrder
    number_of_pax?: SortOrder
    departure_date?: SortOrder
    travel_duration?: SortOrder
    mekkah_duration?: SortOrder
    madinah_duration?: SortOrder
    tour_leader?: SortOrder
    margin?: SortOrder
    per_pax_price_double?: SortOrder
    per_pax_price_triple?: SortOrder
    per_pax_price_quad?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type MitraPackageAvgOrderByAggregateInput = {
    number_of_pax?: SortOrder
    travel_duration?: SortOrder
    mekkah_duration?: SortOrder
    madinah_duration?: SortOrder
    tour_leader?: SortOrder
    margin?: SortOrder
    per_pax_price_double?: SortOrder
    per_pax_price_triple?: SortOrder
    per_pax_price_quad?: SortOrder
  }

  export type MitraPackageMaxOrderByAggregateInput = {
    id?: SortOrder
    period_id?: SortOrder
    airline_id?: SortOrder
    vendor_id?: SortOrder
    hotel_mekkah_id?: SortOrder
    hotel_madinah_id?: SortOrder
    visa_id?: SortOrder
    transportation_id?: SortOrder
    muthawif_id?: SortOrder
    handling_saudi_id?: SortOrder
    handling_domestic_id?: SortOrder
    siskopatuh_id?: SortOrder
    equipment_id?: SortOrder
    tour_plus_id?: SortOrder
    manasik_id?: SortOrder
    number_of_pax?: SortOrder
    departure_date?: SortOrder
    travel_duration?: SortOrder
    mekkah_duration?: SortOrder
    madinah_duration?: SortOrder
    tour_leader?: SortOrder
    margin?: SortOrder
    per_pax_price_double?: SortOrder
    per_pax_price_triple?: SortOrder
    per_pax_price_quad?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type MitraPackageMinOrderByAggregateInput = {
    id?: SortOrder
    period_id?: SortOrder
    airline_id?: SortOrder
    vendor_id?: SortOrder
    hotel_mekkah_id?: SortOrder
    hotel_madinah_id?: SortOrder
    visa_id?: SortOrder
    transportation_id?: SortOrder
    muthawif_id?: SortOrder
    handling_saudi_id?: SortOrder
    handling_domestic_id?: SortOrder
    siskopatuh_id?: SortOrder
    equipment_id?: SortOrder
    tour_plus_id?: SortOrder
    manasik_id?: SortOrder
    number_of_pax?: SortOrder
    departure_date?: SortOrder
    travel_duration?: SortOrder
    mekkah_duration?: SortOrder
    madinah_duration?: SortOrder
    tour_leader?: SortOrder
    margin?: SortOrder
    per_pax_price_double?: SortOrder
    per_pax_price_triple?: SortOrder
    per_pax_price_quad?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type MitraPackageSumOrderByAggregateInput = {
    number_of_pax?: SortOrder
    travel_duration?: SortOrder
    mekkah_duration?: SortOrder
    madinah_duration?: SortOrder
    tour_leader?: SortOrder
    margin?: SortOrder
    per_pax_price_double?: SortOrder
    per_pax_price_triple?: SortOrder
    per_pax_price_quad?: SortOrder
  }

  export type MitraPackageRelationFilter = {
    is?: MitraPackageWhereInput
    isNot?: MitraPackageWhereInput
  }

  export type MitraPackageOrderCountOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    mitra_package_id?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type MitraPackageOrderMaxOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    mitra_package_id?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type MitraPackageOrderMinOrderByAggregateInput = {
    id?: SortOrder
    user_id?: SortOrder
    mitra_package_id?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ExchangeRateCountOrderByAggregateInput = {
    id?: SortOrder
    currency?: SortOrder
    rate_idr?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ExchangeRateAvgOrderByAggregateInput = {
    rate_idr?: SortOrder
  }

  export type ExchangeRateMaxOrderByAggregateInput = {
    id?: SortOrder
    currency?: SortOrder
    rate_idr?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ExchangeRateMinOrderByAggregateInput = {
    id?: SortOrder
    currency?: SortOrder
    rate_idr?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ExchangeRateSumOrderByAggregateInput = {
    rate_idr?: SortOrder
  }

  export type ContactCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    value?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ContactMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    value?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ContactMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    value?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type FaqCountOrderByAggregateInput = {
    id?: SortOrder
    question?: SortOrder
    answer?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type FaqMaxOrderByAggregateInput = {
    id?: SortOrder
    question?: SortOrder
    answer?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type FaqMinOrderByAggregateInput = {
    id?: SortOrder
    question?: SortOrder
    answer?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type EnumContentTypeFilter<$PrismaModel = never> = {
    equals?: $Enums.ContentType | EnumContentTypeFieldRefInput<$PrismaModel>
    in?: $Enums.ContentType[]
    notIn?: $Enums.ContentType[]
    not?: NestedEnumContentTypeFilter<$PrismaModel> | $Enums.ContentType
  }
  export type JsonFilter<$PrismaModel = never> = 
    | PatchUndefined<
        Either<Required<JsonFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonFilterBase<$PrismaModel>>, 'path'>>,
        Required<JsonFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<JsonFilterBase<$PrismaModel>>, 'path'>>

  export type JsonFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string
    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 ContentCountOrderByAggregateInput = {
    id?: SortOrder
    page?: SortOrder
    section?: SortOrder
    type?: SortOrder
    key?: SortOrder
    value?: SortOrder
    visible?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ContentMaxOrderByAggregateInput = {
    id?: SortOrder
    page?: SortOrder
    section?: SortOrder
    type?: SortOrder
    key?: SortOrder
    visible?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ContentMinOrderByAggregateInput = {
    id?: SortOrder
    page?: SortOrder
    section?: SortOrder
    type?: SortOrder
    key?: SortOrder
    visible?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type EnumContentTypeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.ContentType | EnumContentTypeFieldRefInput<$PrismaModel>
    in?: $Enums.ContentType[]
    notIn?: $Enums.ContentType[]
    not?: NestedEnumContentTypeWithAggregatesFilter<$PrismaModel> | $Enums.ContentType
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumContentTypeFilter<$PrismaModel>
    _max?: NestedEnumContentTypeFilter<$PrismaModel>
  }
  export type JsonWithAggregatesFilter<$PrismaModel = never> = 
    | PatchUndefined<
        Either<Required<JsonWithAggregatesFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonWithAggregatesFilterBase<$PrismaModel>>, 'path'>>,
        Required<JsonWithAggregatesFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<JsonWithAggregatesFilterBase<$PrismaModel>>, 'path'>>

  export type JsonWithAggregatesFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string
    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?: NestedIntFilter<$PrismaModel>
    _min?: NestedJsonFilter<$PrismaModel>
    _max?: NestedJsonFilter<$PrismaModel>
  }

  export type MenuItemCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    url?: SortOrder
    visible?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type MenuItemMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    url?: SortOrder
    visible?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type MenuItemMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    url?: SortOrder
    visible?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type EnumFooterTypeFilter<$PrismaModel = never> = {
    equals?: $Enums.FooterType | EnumFooterTypeFieldRefInput<$PrismaModel>
    in?: $Enums.FooterType[]
    notIn?: $Enums.FooterType[]
    not?: NestedEnumFooterTypeFilter<$PrismaModel> | $Enums.FooterType
  }

  export type FooterItemListRelationFilter = {
    every?: FooterItemWhereInput
    some?: FooterItemWhereInput
    none?: FooterItemWhereInput
  }

  export type FooterItemOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type FooterCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    type?: SortOrder
    visible?: SortOrder
    order?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type FooterAvgOrderByAggregateInput = {
    order?: SortOrder
  }

  export type FooterMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    type?: SortOrder
    visible?: SortOrder
    order?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type FooterMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    type?: SortOrder
    visible?: SortOrder
    order?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type FooterSumOrderByAggregateInput = {
    order?: SortOrder
  }

  export type EnumFooterTypeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.FooterType | EnumFooterTypeFieldRefInput<$PrismaModel>
    in?: $Enums.FooterType[]
    notIn?: $Enums.FooterType[]
    not?: NestedEnumFooterTypeWithAggregatesFilter<$PrismaModel> | $Enums.FooterType
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumFooterTypeFilter<$PrismaModel>
    _max?: NestedEnumFooterTypeFilter<$PrismaModel>
  }

  export type FooterRelationFilter = {
    is?: FooterWhereInput
    isNot?: FooterWhereInput
  }

  export type FooterItemCountOrderByAggregateInput = {
    id?: SortOrder
    footer_id?: SortOrder
    name?: SortOrder
    url?: SortOrder
    visible?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type FooterItemMaxOrderByAggregateInput = {
    id?: SortOrder
    footer_id?: SortOrder
    name?: SortOrder
    url?: SortOrder
    visible?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type FooterItemMinOrderByAggregateInput = {
    id?: SortOrder
    footer_id?: SortOrder
    name?: SortOrder
    url?: SortOrder
    visible?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ColorCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    hex?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ColorMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    hex?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ColorMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    hex?: SortOrder
    created_at?: SortOrder
    updated_at?: SortOrder
  }

  export type ProductOrderCreateNestedManyWithoutUserInput = {
    create?: XOR<ProductOrderCreateWithoutUserInput, ProductOrderUncheckedCreateWithoutUserInput> | ProductOrderCreateWithoutUserInput[] | ProductOrderUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ProductOrderCreateOrConnectWithoutUserInput | ProductOrderCreateOrConnectWithoutUserInput[]
    createMany?: ProductOrderCreateManyUserInputEnvelope
    connect?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
  }

  export type MitraPackageOrderCreateNestedManyWithoutUserInput = {
    create?: XOR<MitraPackageOrderCreateWithoutUserInput, MitraPackageOrderUncheckedCreateWithoutUserInput> | MitraPackageOrderCreateWithoutUserInput[] | MitraPackageOrderUncheckedCreateWithoutUserInput[]
    connectOrCreate?: MitraPackageOrderCreateOrConnectWithoutUserInput | MitraPackageOrderCreateOrConnectWithoutUserInput[]
    createMany?: MitraPackageOrderCreateManyUserInputEnvelope
    connect?: MitraPackageOrderWhereUniqueInput | MitraPackageOrderWhereUniqueInput[]
  }

  export type MitraRequestCreateNestedManyWithoutUserInput = {
    create?: XOR<MitraRequestCreateWithoutUserInput, MitraRequestUncheckedCreateWithoutUserInput> | MitraRequestCreateWithoutUserInput[] | MitraRequestUncheckedCreateWithoutUserInput[]
    connectOrCreate?: MitraRequestCreateOrConnectWithoutUserInput | MitraRequestCreateOrConnectWithoutUserInput[]
    createMany?: MitraRequestCreateManyUserInputEnvelope
    connect?: MitraRequestWhereUniqueInput | MitraRequestWhereUniqueInput[]
  }

  export type ProductOrderUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<ProductOrderCreateWithoutUserInput, ProductOrderUncheckedCreateWithoutUserInput> | ProductOrderCreateWithoutUserInput[] | ProductOrderUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ProductOrderCreateOrConnectWithoutUserInput | ProductOrderCreateOrConnectWithoutUserInput[]
    createMany?: ProductOrderCreateManyUserInputEnvelope
    connect?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
  }

  export type MitraPackageOrderUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<MitraPackageOrderCreateWithoutUserInput, MitraPackageOrderUncheckedCreateWithoutUserInput> | MitraPackageOrderCreateWithoutUserInput[] | MitraPackageOrderUncheckedCreateWithoutUserInput[]
    connectOrCreate?: MitraPackageOrderCreateOrConnectWithoutUserInput | MitraPackageOrderCreateOrConnectWithoutUserInput[]
    createMany?: MitraPackageOrderCreateManyUserInputEnvelope
    connect?: MitraPackageOrderWhereUniqueInput | MitraPackageOrderWhereUniqueInput[]
  }

  export type MitraRequestUncheckedCreateNestedManyWithoutUserInput = {
    create?: XOR<MitraRequestCreateWithoutUserInput, MitraRequestUncheckedCreateWithoutUserInput> | MitraRequestCreateWithoutUserInput[] | MitraRequestUncheckedCreateWithoutUserInput[]
    connectOrCreate?: MitraRequestCreateOrConnectWithoutUserInput | MitraRequestCreateOrConnectWithoutUserInput[]
    createMany?: MitraRequestCreateManyUserInputEnvelope
    connect?: MitraRequestWhereUniqueInput | MitraRequestWhereUniqueInput[]
  }

  export type StringFieldUpdateOperationsInput = {
    set?: string
  }

  export type EnumRoleFieldUpdateOperationsInput = {
    set?: $Enums.Role
  }

  export type DateTimeFieldUpdateOperationsInput = {
    set?: Date | string
  }

  export type ProductOrderUpdateManyWithoutUserNestedInput = {
    create?: XOR<ProductOrderCreateWithoutUserInput, ProductOrderUncheckedCreateWithoutUserInput> | ProductOrderCreateWithoutUserInput[] | ProductOrderUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ProductOrderCreateOrConnectWithoutUserInput | ProductOrderCreateOrConnectWithoutUserInput[]
    upsert?: ProductOrderUpsertWithWhereUniqueWithoutUserInput | ProductOrderUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: ProductOrderCreateManyUserInputEnvelope
    set?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
    disconnect?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
    delete?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
    connect?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
    update?: ProductOrderUpdateWithWhereUniqueWithoutUserInput | ProductOrderUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: ProductOrderUpdateManyWithWhereWithoutUserInput | ProductOrderUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: ProductOrderScalarWhereInput | ProductOrderScalarWhereInput[]
  }

  export type MitraPackageOrderUpdateManyWithoutUserNestedInput = {
    create?: XOR<MitraPackageOrderCreateWithoutUserInput, MitraPackageOrderUncheckedCreateWithoutUserInput> | MitraPackageOrderCreateWithoutUserInput[] | MitraPackageOrderUncheckedCreateWithoutUserInput[]
    connectOrCreate?: MitraPackageOrderCreateOrConnectWithoutUserInput | MitraPackageOrderCreateOrConnectWithoutUserInput[]
    upsert?: MitraPackageOrderUpsertWithWhereUniqueWithoutUserInput | MitraPackageOrderUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: MitraPackageOrderCreateManyUserInputEnvelope
    set?: MitraPackageOrderWhereUniqueInput | MitraPackageOrderWhereUniqueInput[]
    disconnect?: MitraPackageOrderWhereUniqueInput | MitraPackageOrderWhereUniqueInput[]
    delete?: MitraPackageOrderWhereUniqueInput | MitraPackageOrderWhereUniqueInput[]
    connect?: MitraPackageOrderWhereUniqueInput | MitraPackageOrderWhereUniqueInput[]
    update?: MitraPackageOrderUpdateWithWhereUniqueWithoutUserInput | MitraPackageOrderUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: MitraPackageOrderUpdateManyWithWhereWithoutUserInput | MitraPackageOrderUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: MitraPackageOrderScalarWhereInput | MitraPackageOrderScalarWhereInput[]
  }

  export type MitraRequestUpdateManyWithoutUserNestedInput = {
    create?: XOR<MitraRequestCreateWithoutUserInput, MitraRequestUncheckedCreateWithoutUserInput> | MitraRequestCreateWithoutUserInput[] | MitraRequestUncheckedCreateWithoutUserInput[]
    connectOrCreate?: MitraRequestCreateOrConnectWithoutUserInput | MitraRequestCreateOrConnectWithoutUserInput[]
    upsert?: MitraRequestUpsertWithWhereUniqueWithoutUserInput | MitraRequestUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: MitraRequestCreateManyUserInputEnvelope
    set?: MitraRequestWhereUniqueInput | MitraRequestWhereUniqueInput[]
    disconnect?: MitraRequestWhereUniqueInput | MitraRequestWhereUniqueInput[]
    delete?: MitraRequestWhereUniqueInput | MitraRequestWhereUniqueInput[]
    connect?: MitraRequestWhereUniqueInput | MitraRequestWhereUniqueInput[]
    update?: MitraRequestUpdateWithWhereUniqueWithoutUserInput | MitraRequestUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: MitraRequestUpdateManyWithWhereWithoutUserInput | MitraRequestUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: MitraRequestScalarWhereInput | MitraRequestScalarWhereInput[]
  }

  export type ProductOrderUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<ProductOrderCreateWithoutUserInput, ProductOrderUncheckedCreateWithoutUserInput> | ProductOrderCreateWithoutUserInput[] | ProductOrderUncheckedCreateWithoutUserInput[]
    connectOrCreate?: ProductOrderCreateOrConnectWithoutUserInput | ProductOrderCreateOrConnectWithoutUserInput[]
    upsert?: ProductOrderUpsertWithWhereUniqueWithoutUserInput | ProductOrderUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: ProductOrderCreateManyUserInputEnvelope
    set?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
    disconnect?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
    delete?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
    connect?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
    update?: ProductOrderUpdateWithWhereUniqueWithoutUserInput | ProductOrderUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: ProductOrderUpdateManyWithWhereWithoutUserInput | ProductOrderUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: ProductOrderScalarWhereInput | ProductOrderScalarWhereInput[]
  }

  export type MitraPackageOrderUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<MitraPackageOrderCreateWithoutUserInput, MitraPackageOrderUncheckedCreateWithoutUserInput> | MitraPackageOrderCreateWithoutUserInput[] | MitraPackageOrderUncheckedCreateWithoutUserInput[]
    connectOrCreate?: MitraPackageOrderCreateOrConnectWithoutUserInput | MitraPackageOrderCreateOrConnectWithoutUserInput[]
    upsert?: MitraPackageOrderUpsertWithWhereUniqueWithoutUserInput | MitraPackageOrderUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: MitraPackageOrderCreateManyUserInputEnvelope
    set?: MitraPackageOrderWhereUniqueInput | MitraPackageOrderWhereUniqueInput[]
    disconnect?: MitraPackageOrderWhereUniqueInput | MitraPackageOrderWhereUniqueInput[]
    delete?: MitraPackageOrderWhereUniqueInput | MitraPackageOrderWhereUniqueInput[]
    connect?: MitraPackageOrderWhereUniqueInput | MitraPackageOrderWhereUniqueInput[]
    update?: MitraPackageOrderUpdateWithWhereUniqueWithoutUserInput | MitraPackageOrderUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: MitraPackageOrderUpdateManyWithWhereWithoutUserInput | MitraPackageOrderUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: MitraPackageOrderScalarWhereInput | MitraPackageOrderScalarWhereInput[]
  }

  export type MitraRequestUncheckedUpdateManyWithoutUserNestedInput = {
    create?: XOR<MitraRequestCreateWithoutUserInput, MitraRequestUncheckedCreateWithoutUserInput> | MitraRequestCreateWithoutUserInput[] | MitraRequestUncheckedCreateWithoutUserInput[]
    connectOrCreate?: MitraRequestCreateOrConnectWithoutUserInput | MitraRequestCreateOrConnectWithoutUserInput[]
    upsert?: MitraRequestUpsertWithWhereUniqueWithoutUserInput | MitraRequestUpsertWithWhereUniqueWithoutUserInput[]
    createMany?: MitraRequestCreateManyUserInputEnvelope
    set?: MitraRequestWhereUniqueInput | MitraRequestWhereUniqueInput[]
    disconnect?: MitraRequestWhereUniqueInput | MitraRequestWhereUniqueInput[]
    delete?: MitraRequestWhereUniqueInput | MitraRequestWhereUniqueInput[]
    connect?: MitraRequestWhereUniqueInput | MitraRequestWhereUniqueInput[]
    update?: MitraRequestUpdateWithWhereUniqueWithoutUserInput | MitraRequestUpdateWithWhereUniqueWithoutUserInput[]
    updateMany?: MitraRequestUpdateManyWithWhereWithoutUserInput | MitraRequestUpdateManyWithWhereWithoutUserInput[]
    deleteMany?: MitraRequestScalarWhereInput | MitraRequestScalarWhereInput[]
  }

  export type UserCreateNestedOneWithoutMitraRequestInput = {
    create?: XOR<UserCreateWithoutMitraRequestInput, UserUncheckedCreateWithoutMitraRequestInput>
    connectOrCreate?: UserCreateOrConnectWithoutMitraRequestInput
    connect?: UserWhereUniqueInput
  }

  export type DecimalFieldUpdateOperationsInput = {
    set?: Decimal | DecimalJsLike | number | string
    increment?: Decimal | DecimalJsLike | number | string
    decrement?: Decimal | DecimalJsLike | number | string
    multiply?: Decimal | DecimalJsLike | number | string
    divide?: Decimal | DecimalJsLike | number | string
  }

  export type EnumRequestStatusFieldUpdateOperationsInput = {
    set?: $Enums.RequestStatus
  }

  export type UserUpdateOneRequiredWithoutMitraRequestNestedInput = {
    create?: XOR<UserCreateWithoutMitraRequestInput, UserUncheckedCreateWithoutMitraRequestInput>
    connectOrCreate?: UserCreateOrConnectWithoutMitraRequestInput
    upsert?: UserUpsertWithoutMitraRequestInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutMitraRequestInput, UserUpdateWithoutMitraRequestInput>, UserUncheckedUpdateWithoutMitraRequestInput>
  }

  export type UserPackageOrderCreateNestedManyWithoutUserPackageInput = {
    create?: XOR<UserPackageOrderCreateWithoutUserPackageInput, UserPackageOrderUncheckedCreateWithoutUserPackageInput> | UserPackageOrderCreateWithoutUserPackageInput[] | UserPackageOrderUncheckedCreateWithoutUserPackageInput[]
    connectOrCreate?: UserPackageOrderCreateOrConnectWithoutUserPackageInput | UserPackageOrderCreateOrConnectWithoutUserPackageInput[]
    createMany?: UserPackageOrderCreateManyUserPackageInputEnvelope
    connect?: UserPackageOrderWhereUniqueInput | UserPackageOrderWhereUniqueInput[]
  }

  export type UserPackageOptionCreateNestedOneWithoutTransportationsInput = {
    create?: XOR<UserPackageOptionCreateWithoutTransportationsInput, UserPackageOptionUncheckedCreateWithoutTransportationsInput>
    connectOrCreate?: UserPackageOptionCreateOrConnectWithoutTransportationsInput
    connect?: UserPackageOptionWhereUniqueInput
  }

  export type UserPackageOptionCreateNestedOneWithoutFlightsInput = {
    create?: XOR<UserPackageOptionCreateWithoutFlightsInput, UserPackageOptionUncheckedCreateWithoutFlightsInput>
    connectOrCreate?: UserPackageOptionCreateOrConnectWithoutFlightsInput
    connect?: UserPackageOptionWhereUniqueInput
  }

  export type UserPackageOptionCreateNestedOneWithoutHotelMekkahsInput = {
    create?: XOR<UserPackageOptionCreateWithoutHotelMekkahsInput, UserPackageOptionUncheckedCreateWithoutHotelMekkahsInput>
    connectOrCreate?: UserPackageOptionCreateOrConnectWithoutHotelMekkahsInput
    connect?: UserPackageOptionWhereUniqueInput
  }

  export type UserPackageOptionCreateNestedOneWithoutHotelMadinahsInput = {
    create?: XOR<UserPackageOptionCreateWithoutHotelMadinahsInput, UserPackageOptionUncheckedCreateWithoutHotelMadinahsInput>
    connectOrCreate?: UserPackageOptionCreateOrConnectWithoutHotelMadinahsInput
    connect?: UserPackageOptionWhereUniqueInput
  }

  export type UserPackageOptionCreateNestedOneWithoutMuthawifsInput = {
    create?: XOR<UserPackageOptionCreateWithoutMuthawifsInput, UserPackageOptionUncheckedCreateWithoutMuthawifsInput>
    connectOrCreate?: UserPackageOptionCreateOrConnectWithoutMuthawifsInput
    connect?: UserPackageOptionWhereUniqueInput
  }

  export type UserPackageOptionCreateNestedOneWithoutHandlingsInput = {
    create?: XOR<UserPackageOptionCreateWithoutHandlingsInput, UserPackageOptionUncheckedCreateWithoutHandlingsInput>
    connectOrCreate?: UserPackageOptionCreateOrConnectWithoutHandlingsInput
    connect?: UserPackageOptionWhereUniqueInput
  }

  export type UserPackageOrderUncheckedCreateNestedManyWithoutUserPackageInput = {
    create?: XOR<UserPackageOrderCreateWithoutUserPackageInput, UserPackageOrderUncheckedCreateWithoutUserPackageInput> | UserPackageOrderCreateWithoutUserPackageInput[] | UserPackageOrderUncheckedCreateWithoutUserPackageInput[]
    connectOrCreate?: UserPackageOrderCreateOrConnectWithoutUserPackageInput | UserPackageOrderCreateOrConnectWithoutUserPackageInput[]
    createMany?: UserPackageOrderCreateManyUserPackageInputEnvelope
    connect?: UserPackageOrderWhereUniqueInput | UserPackageOrderWhereUniqueInput[]
  }

  export type IntFieldUpdateOperationsInput = {
    set?: number
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type UserPackageOrderUpdateManyWithoutUserPackageNestedInput = {
    create?: XOR<UserPackageOrderCreateWithoutUserPackageInput, UserPackageOrderUncheckedCreateWithoutUserPackageInput> | UserPackageOrderCreateWithoutUserPackageInput[] | UserPackageOrderUncheckedCreateWithoutUserPackageInput[]
    connectOrCreate?: UserPackageOrderCreateOrConnectWithoutUserPackageInput | UserPackageOrderCreateOrConnectWithoutUserPackageInput[]
    upsert?: UserPackageOrderUpsertWithWhereUniqueWithoutUserPackageInput | UserPackageOrderUpsertWithWhereUniqueWithoutUserPackageInput[]
    createMany?: UserPackageOrderCreateManyUserPackageInputEnvelope
    set?: UserPackageOrderWhereUniqueInput | UserPackageOrderWhereUniqueInput[]
    disconnect?: UserPackageOrderWhereUniqueInput | UserPackageOrderWhereUniqueInput[]
    delete?: UserPackageOrderWhereUniqueInput | UserPackageOrderWhereUniqueInput[]
    connect?: UserPackageOrderWhereUniqueInput | UserPackageOrderWhereUniqueInput[]
    update?: UserPackageOrderUpdateWithWhereUniqueWithoutUserPackageInput | UserPackageOrderUpdateWithWhereUniqueWithoutUserPackageInput[]
    updateMany?: UserPackageOrderUpdateManyWithWhereWithoutUserPackageInput | UserPackageOrderUpdateManyWithWhereWithoutUserPackageInput[]
    deleteMany?: UserPackageOrderScalarWhereInput | UserPackageOrderScalarWhereInput[]
  }

  export type UserPackageOptionUpdateOneWithoutTransportationsNestedInput = {
    create?: XOR<UserPackageOptionCreateWithoutTransportationsInput, UserPackageOptionUncheckedCreateWithoutTransportationsInput>
    connectOrCreate?: UserPackageOptionCreateOrConnectWithoutTransportationsInput
    upsert?: UserPackageOptionUpsertWithoutTransportationsInput
    disconnect?: UserPackageOptionWhereInput | boolean
    delete?: UserPackageOptionWhereInput | boolean
    connect?: UserPackageOptionWhereUniqueInput
    update?: XOR<XOR<UserPackageOptionUpdateToOneWithWhereWithoutTransportationsInput, UserPackageOptionUpdateWithoutTransportationsInput>, UserPackageOptionUncheckedUpdateWithoutTransportationsInput>
  }

  export type UserPackageOptionUpdateOneWithoutFlightsNestedInput = {
    create?: XOR<UserPackageOptionCreateWithoutFlightsInput, UserPackageOptionUncheckedCreateWithoutFlightsInput>
    connectOrCreate?: UserPackageOptionCreateOrConnectWithoutFlightsInput
    upsert?: UserPackageOptionUpsertWithoutFlightsInput
    disconnect?: UserPackageOptionWhereInput | boolean
    delete?: UserPackageOptionWhereInput | boolean
    connect?: UserPackageOptionWhereUniqueInput
    update?: XOR<XOR<UserPackageOptionUpdateToOneWithWhereWithoutFlightsInput, UserPackageOptionUpdateWithoutFlightsInput>, UserPackageOptionUncheckedUpdateWithoutFlightsInput>
  }

  export type UserPackageOptionUpdateOneWithoutHotelMekkahsNestedInput = {
    create?: XOR<UserPackageOptionCreateWithoutHotelMekkahsInput, UserPackageOptionUncheckedCreateWithoutHotelMekkahsInput>
    connectOrCreate?: UserPackageOptionCreateOrConnectWithoutHotelMekkahsInput
    upsert?: UserPackageOptionUpsertWithoutHotelMekkahsInput
    disconnect?: UserPackageOptionWhereInput | boolean
    delete?: UserPackageOptionWhereInput | boolean
    connect?: UserPackageOptionWhereUniqueInput
    update?: XOR<XOR<UserPackageOptionUpdateToOneWithWhereWithoutHotelMekkahsInput, UserPackageOptionUpdateWithoutHotelMekkahsInput>, UserPackageOptionUncheckedUpdateWithoutHotelMekkahsInput>
  }

  export type UserPackageOptionUpdateOneWithoutHotelMadinahsNestedInput = {
    create?: XOR<UserPackageOptionCreateWithoutHotelMadinahsInput, UserPackageOptionUncheckedCreateWithoutHotelMadinahsInput>
    connectOrCreate?: UserPackageOptionCreateOrConnectWithoutHotelMadinahsInput
    upsert?: UserPackageOptionUpsertWithoutHotelMadinahsInput
    disconnect?: UserPackageOptionWhereInput | boolean
    delete?: UserPackageOptionWhereInput | boolean
    connect?: UserPackageOptionWhereUniqueInput
    update?: XOR<XOR<UserPackageOptionUpdateToOneWithWhereWithoutHotelMadinahsInput, UserPackageOptionUpdateWithoutHotelMadinahsInput>, UserPackageOptionUncheckedUpdateWithoutHotelMadinahsInput>
  }

  export type UserPackageOptionUpdateOneWithoutMuthawifsNestedInput = {
    create?: XOR<UserPackageOptionCreateWithoutMuthawifsInput, UserPackageOptionUncheckedCreateWithoutMuthawifsInput>
    connectOrCreate?: UserPackageOptionCreateOrConnectWithoutMuthawifsInput
    upsert?: UserPackageOptionUpsertWithoutMuthawifsInput
    disconnect?: UserPackageOptionWhereInput | boolean
    delete?: UserPackageOptionWhereInput | boolean
    connect?: UserPackageOptionWhereUniqueInput
    update?: XOR<XOR<UserPackageOptionUpdateToOneWithWhereWithoutMuthawifsInput, UserPackageOptionUpdateWithoutMuthawifsInput>, UserPackageOptionUncheckedUpdateWithoutMuthawifsInput>
  }

  export type UserPackageOptionUpdateOneWithoutHandlingsNestedInput = {
    create?: XOR<UserPackageOptionCreateWithoutHandlingsInput, UserPackageOptionUncheckedCreateWithoutHandlingsInput>
    connectOrCreate?: UserPackageOptionCreateOrConnectWithoutHandlingsInput
    upsert?: UserPackageOptionUpsertWithoutHandlingsInput
    disconnect?: UserPackageOptionWhereInput | boolean
    delete?: UserPackageOptionWhereInput | boolean
    connect?: UserPackageOptionWhereUniqueInput
    update?: XOR<XOR<UserPackageOptionUpdateToOneWithWhereWithoutHandlingsInput, UserPackageOptionUpdateWithoutHandlingsInput>, UserPackageOptionUncheckedUpdateWithoutHandlingsInput>
  }

  export type NullableStringFieldUpdateOperationsInput = {
    set?: string | null
  }

  export type UserPackageOrderUncheckedUpdateManyWithoutUserPackageNestedInput = {
    create?: XOR<UserPackageOrderCreateWithoutUserPackageInput, UserPackageOrderUncheckedCreateWithoutUserPackageInput> | UserPackageOrderCreateWithoutUserPackageInput[] | UserPackageOrderUncheckedCreateWithoutUserPackageInput[]
    connectOrCreate?: UserPackageOrderCreateOrConnectWithoutUserPackageInput | UserPackageOrderCreateOrConnectWithoutUserPackageInput[]
    upsert?: UserPackageOrderUpsertWithWhereUniqueWithoutUserPackageInput | UserPackageOrderUpsertWithWhereUniqueWithoutUserPackageInput[]
    createMany?: UserPackageOrderCreateManyUserPackageInputEnvelope
    set?: UserPackageOrderWhereUniqueInput | UserPackageOrderWhereUniqueInput[]
    disconnect?: UserPackageOrderWhereUniqueInput | UserPackageOrderWhereUniqueInput[]
    delete?: UserPackageOrderWhereUniqueInput | UserPackageOrderWhereUniqueInput[]
    connect?: UserPackageOrderWhereUniqueInput | UserPackageOrderWhereUniqueInput[]
    update?: UserPackageOrderUpdateWithWhereUniqueWithoutUserPackageInput | UserPackageOrderUpdateWithWhereUniqueWithoutUserPackageInput[]
    updateMany?: UserPackageOrderUpdateManyWithWhereWithoutUserPackageInput | UserPackageOrderUpdateManyWithWhereWithoutUserPackageInput[]
    deleteMany?: UserPackageOrderScalarWhereInput | UserPackageOrderScalarWhereInput[]
  }

  export type UserPackageOptionCreateNestedManyWithoutPackageTypeInput = {
    create?: XOR<UserPackageOptionCreateWithoutPackageTypeInput, UserPackageOptionUncheckedCreateWithoutPackageTypeInput> | UserPackageOptionCreateWithoutPackageTypeInput[] | UserPackageOptionUncheckedCreateWithoutPackageTypeInput[]
    connectOrCreate?: UserPackageOptionCreateOrConnectWithoutPackageTypeInput | UserPackageOptionCreateOrConnectWithoutPackageTypeInput[]
    createMany?: UserPackageOptionCreateManyPackageTypeInputEnvelope
    connect?: UserPackageOptionWhereUniqueInput | UserPackageOptionWhereUniqueInput[]
  }

  export type UserPackageOptionUncheckedCreateNestedManyWithoutPackageTypeInput = {
    create?: XOR<UserPackageOptionCreateWithoutPackageTypeInput, UserPackageOptionUncheckedCreateWithoutPackageTypeInput> | UserPackageOptionCreateWithoutPackageTypeInput[] | UserPackageOptionUncheckedCreateWithoutPackageTypeInput[]
    connectOrCreate?: UserPackageOptionCreateOrConnectWithoutPackageTypeInput | UserPackageOptionCreateOrConnectWithoutPackageTypeInput[]
    createMany?: UserPackageOptionCreateManyPackageTypeInputEnvelope
    connect?: UserPackageOptionWhereUniqueInput | UserPackageOptionWhereUniqueInput[]
  }

  export type BoolFieldUpdateOperationsInput = {
    set?: boolean
  }

  export type UserPackageOptionUpdateManyWithoutPackageTypeNestedInput = {
    create?: XOR<UserPackageOptionCreateWithoutPackageTypeInput, UserPackageOptionUncheckedCreateWithoutPackageTypeInput> | UserPackageOptionCreateWithoutPackageTypeInput[] | UserPackageOptionUncheckedCreateWithoutPackageTypeInput[]
    connectOrCreate?: UserPackageOptionCreateOrConnectWithoutPackageTypeInput | UserPackageOptionCreateOrConnectWithoutPackageTypeInput[]
    upsert?: UserPackageOptionUpsertWithWhereUniqueWithoutPackageTypeInput | UserPackageOptionUpsertWithWhereUniqueWithoutPackageTypeInput[]
    createMany?: UserPackageOptionCreateManyPackageTypeInputEnvelope
    set?: UserPackageOptionWhereUniqueInput | UserPackageOptionWhereUniqueInput[]
    disconnect?: UserPackageOptionWhereUniqueInput | UserPackageOptionWhereUniqueInput[]
    delete?: UserPackageOptionWhereUniqueInput | UserPackageOptionWhereUniqueInput[]
    connect?: UserPackageOptionWhereUniqueInput | UserPackageOptionWhereUniqueInput[]
    update?: UserPackageOptionUpdateWithWhereUniqueWithoutPackageTypeInput | UserPackageOptionUpdateWithWhereUniqueWithoutPackageTypeInput[]
    updateMany?: UserPackageOptionUpdateManyWithWhereWithoutPackageTypeInput | UserPackageOptionUpdateManyWithWhereWithoutPackageTypeInput[]
    deleteMany?: UserPackageOptionScalarWhereInput | UserPackageOptionScalarWhereInput[]
  }

  export type UserPackageOptionUncheckedUpdateManyWithoutPackageTypeNestedInput = {
    create?: XOR<UserPackageOptionCreateWithoutPackageTypeInput, UserPackageOptionUncheckedCreateWithoutPackageTypeInput> | UserPackageOptionCreateWithoutPackageTypeInput[] | UserPackageOptionUncheckedCreateWithoutPackageTypeInput[]
    connectOrCreate?: UserPackageOptionCreateOrConnectWithoutPackageTypeInput | UserPackageOptionCreateOrConnectWithoutPackageTypeInput[]
    upsert?: UserPackageOptionUpsertWithWhereUniqueWithoutPackageTypeInput | UserPackageOptionUpsertWithWhereUniqueWithoutPackageTypeInput[]
    createMany?: UserPackageOptionCreateManyPackageTypeInputEnvelope
    set?: UserPackageOptionWhereUniqueInput | UserPackageOptionWhereUniqueInput[]
    disconnect?: UserPackageOptionWhereUniqueInput | UserPackageOptionWhereUniqueInput[]
    delete?: UserPackageOptionWhereUniqueInput | UserPackageOptionWhereUniqueInput[]
    connect?: UserPackageOptionWhereUniqueInput | UserPackageOptionWhereUniqueInput[]
    update?: UserPackageOptionUpdateWithWhereUniqueWithoutPackageTypeInput | UserPackageOptionUpdateWithWhereUniqueWithoutPackageTypeInput[]
    updateMany?: UserPackageOptionUpdateManyWithWhereWithoutPackageTypeInput | UserPackageOptionUpdateManyWithWhereWithoutPackageTypeInput[]
    deleteMany?: UserPackageOptionScalarWhereInput | UserPackageOptionScalarWhereInput[]
  }

  export type UserPackageCreateNestedManyWithoutTransportationInput = {
    create?: XOR<UserPackageCreateWithoutTransportationInput, UserPackageUncheckedCreateWithoutTransportationInput> | UserPackageCreateWithoutTransportationInput[] | UserPackageUncheckedCreateWithoutTransportationInput[]
    connectOrCreate?: UserPackageCreateOrConnectWithoutTransportationInput | UserPackageCreateOrConnectWithoutTransportationInput[]
    createMany?: UserPackageCreateManyTransportationInputEnvelope
    connect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
  }

  export type UserPackageCreateNestedManyWithoutFlightInput = {
    create?: XOR<UserPackageCreateWithoutFlightInput, UserPackageUncheckedCreateWithoutFlightInput> | UserPackageCreateWithoutFlightInput[] | UserPackageUncheckedCreateWithoutFlightInput[]
    connectOrCreate?: UserPackageCreateOrConnectWithoutFlightInput | UserPackageCreateOrConnectWithoutFlightInput[]
    createMany?: UserPackageCreateManyFlightInputEnvelope
    connect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
  }

  export type UserPackageCreateNestedManyWithoutHotelMekkahInput = {
    create?: XOR<UserPackageCreateWithoutHotelMekkahInput, UserPackageUncheckedCreateWithoutHotelMekkahInput> | UserPackageCreateWithoutHotelMekkahInput[] | UserPackageUncheckedCreateWithoutHotelMekkahInput[]
    connectOrCreate?: UserPackageCreateOrConnectWithoutHotelMekkahInput | UserPackageCreateOrConnectWithoutHotelMekkahInput[]
    createMany?: UserPackageCreateManyHotelMekkahInputEnvelope
    connect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
  }

  export type UserPackageCreateNestedManyWithoutHotelMadinahInput = {
    create?: XOR<UserPackageCreateWithoutHotelMadinahInput, UserPackageUncheckedCreateWithoutHotelMadinahInput> | UserPackageCreateWithoutHotelMadinahInput[] | UserPackageUncheckedCreateWithoutHotelMadinahInput[]
    connectOrCreate?: UserPackageCreateOrConnectWithoutHotelMadinahInput | UserPackageCreateOrConnectWithoutHotelMadinahInput[]
    createMany?: UserPackageCreateManyHotelMadinahInputEnvelope
    connect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
  }

  export type UserPackageCreateNestedManyWithoutMuthawifInput = {
    create?: XOR<UserPackageCreateWithoutMuthawifInput, UserPackageUncheckedCreateWithoutMuthawifInput> | UserPackageCreateWithoutMuthawifInput[] | UserPackageUncheckedCreateWithoutMuthawifInput[]
    connectOrCreate?: UserPackageCreateOrConnectWithoutMuthawifInput | UserPackageCreateOrConnectWithoutMuthawifInput[]
    createMany?: UserPackageCreateManyMuthawifInputEnvelope
    connect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
  }

  export type UserPackageCreateNestedManyWithoutHandlingInput = {
    create?: XOR<UserPackageCreateWithoutHandlingInput, UserPackageUncheckedCreateWithoutHandlingInput> | UserPackageCreateWithoutHandlingInput[] | UserPackageUncheckedCreateWithoutHandlingInput[]
    connectOrCreate?: UserPackageCreateOrConnectWithoutHandlingInput | UserPackageCreateOrConnectWithoutHandlingInput[]
    createMany?: UserPackageCreateManyHandlingInputEnvelope
    connect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
  }

  export type PackageTypeCreateNestedOneWithoutUserPackageOptionsInput = {
    create?: XOR<PackageTypeCreateWithoutUserPackageOptionsInput, PackageTypeUncheckedCreateWithoutUserPackageOptionsInput>
    connectOrCreate?: PackageTypeCreateOrConnectWithoutUserPackageOptionsInput
    connect?: PackageTypeWhereUniqueInput
  }

  export type UserPackageUncheckedCreateNestedManyWithoutTransportationInput = {
    create?: XOR<UserPackageCreateWithoutTransportationInput, UserPackageUncheckedCreateWithoutTransportationInput> | UserPackageCreateWithoutTransportationInput[] | UserPackageUncheckedCreateWithoutTransportationInput[]
    connectOrCreate?: UserPackageCreateOrConnectWithoutTransportationInput | UserPackageCreateOrConnectWithoutTransportationInput[]
    createMany?: UserPackageCreateManyTransportationInputEnvelope
    connect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
  }

  export type UserPackageUncheckedCreateNestedManyWithoutFlightInput = {
    create?: XOR<UserPackageCreateWithoutFlightInput, UserPackageUncheckedCreateWithoutFlightInput> | UserPackageCreateWithoutFlightInput[] | UserPackageUncheckedCreateWithoutFlightInput[]
    connectOrCreate?: UserPackageCreateOrConnectWithoutFlightInput | UserPackageCreateOrConnectWithoutFlightInput[]
    createMany?: UserPackageCreateManyFlightInputEnvelope
    connect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
  }

  export type UserPackageUncheckedCreateNestedManyWithoutHotelMekkahInput = {
    create?: XOR<UserPackageCreateWithoutHotelMekkahInput, UserPackageUncheckedCreateWithoutHotelMekkahInput> | UserPackageCreateWithoutHotelMekkahInput[] | UserPackageUncheckedCreateWithoutHotelMekkahInput[]
    connectOrCreate?: UserPackageCreateOrConnectWithoutHotelMekkahInput | UserPackageCreateOrConnectWithoutHotelMekkahInput[]
    createMany?: UserPackageCreateManyHotelMekkahInputEnvelope
    connect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
  }

  export type UserPackageUncheckedCreateNestedManyWithoutHotelMadinahInput = {
    create?: XOR<UserPackageCreateWithoutHotelMadinahInput, UserPackageUncheckedCreateWithoutHotelMadinahInput> | UserPackageCreateWithoutHotelMadinahInput[] | UserPackageUncheckedCreateWithoutHotelMadinahInput[]
    connectOrCreate?: UserPackageCreateOrConnectWithoutHotelMadinahInput | UserPackageCreateOrConnectWithoutHotelMadinahInput[]
    createMany?: UserPackageCreateManyHotelMadinahInputEnvelope
    connect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
  }

  export type UserPackageUncheckedCreateNestedManyWithoutMuthawifInput = {
    create?: XOR<UserPackageCreateWithoutMuthawifInput, UserPackageUncheckedCreateWithoutMuthawifInput> | UserPackageCreateWithoutMuthawifInput[] | UserPackageUncheckedCreateWithoutMuthawifInput[]
    connectOrCreate?: UserPackageCreateOrConnectWithoutMuthawifInput | UserPackageCreateOrConnectWithoutMuthawifInput[]
    createMany?: UserPackageCreateManyMuthawifInputEnvelope
    connect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
  }

  export type UserPackageUncheckedCreateNestedManyWithoutHandlingInput = {
    create?: XOR<UserPackageCreateWithoutHandlingInput, UserPackageUncheckedCreateWithoutHandlingInput> | UserPackageCreateWithoutHandlingInput[] | UserPackageUncheckedCreateWithoutHandlingInput[]
    connectOrCreate?: UserPackageCreateOrConnectWithoutHandlingInput | UserPackageCreateOrConnectWithoutHandlingInput[]
    createMany?: UserPackageCreateManyHandlingInputEnvelope
    connect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
  }

  export type UserPackageUpdateManyWithoutTransportationNestedInput = {
    create?: XOR<UserPackageCreateWithoutTransportationInput, UserPackageUncheckedCreateWithoutTransportationInput> | UserPackageCreateWithoutTransportationInput[] | UserPackageUncheckedCreateWithoutTransportationInput[]
    connectOrCreate?: UserPackageCreateOrConnectWithoutTransportationInput | UserPackageCreateOrConnectWithoutTransportationInput[]
    upsert?: UserPackageUpsertWithWhereUniqueWithoutTransportationInput | UserPackageUpsertWithWhereUniqueWithoutTransportationInput[]
    createMany?: UserPackageCreateManyTransportationInputEnvelope
    set?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    disconnect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    delete?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    connect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    update?: UserPackageUpdateWithWhereUniqueWithoutTransportationInput | UserPackageUpdateWithWhereUniqueWithoutTransportationInput[]
    updateMany?: UserPackageUpdateManyWithWhereWithoutTransportationInput | UserPackageUpdateManyWithWhereWithoutTransportationInput[]
    deleteMany?: UserPackageScalarWhereInput | UserPackageScalarWhereInput[]
  }

  export type UserPackageUpdateManyWithoutFlightNestedInput = {
    create?: XOR<UserPackageCreateWithoutFlightInput, UserPackageUncheckedCreateWithoutFlightInput> | UserPackageCreateWithoutFlightInput[] | UserPackageUncheckedCreateWithoutFlightInput[]
    connectOrCreate?: UserPackageCreateOrConnectWithoutFlightInput | UserPackageCreateOrConnectWithoutFlightInput[]
    upsert?: UserPackageUpsertWithWhereUniqueWithoutFlightInput | UserPackageUpsertWithWhereUniqueWithoutFlightInput[]
    createMany?: UserPackageCreateManyFlightInputEnvelope
    set?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    disconnect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    delete?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    connect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    update?: UserPackageUpdateWithWhereUniqueWithoutFlightInput | UserPackageUpdateWithWhereUniqueWithoutFlightInput[]
    updateMany?: UserPackageUpdateManyWithWhereWithoutFlightInput | UserPackageUpdateManyWithWhereWithoutFlightInput[]
    deleteMany?: UserPackageScalarWhereInput | UserPackageScalarWhereInput[]
  }

  export type UserPackageUpdateManyWithoutHotelMekkahNestedInput = {
    create?: XOR<UserPackageCreateWithoutHotelMekkahInput, UserPackageUncheckedCreateWithoutHotelMekkahInput> | UserPackageCreateWithoutHotelMekkahInput[] | UserPackageUncheckedCreateWithoutHotelMekkahInput[]
    connectOrCreate?: UserPackageCreateOrConnectWithoutHotelMekkahInput | UserPackageCreateOrConnectWithoutHotelMekkahInput[]
    upsert?: UserPackageUpsertWithWhereUniqueWithoutHotelMekkahInput | UserPackageUpsertWithWhereUniqueWithoutHotelMekkahInput[]
    createMany?: UserPackageCreateManyHotelMekkahInputEnvelope
    set?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    disconnect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    delete?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    connect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    update?: UserPackageUpdateWithWhereUniqueWithoutHotelMekkahInput | UserPackageUpdateWithWhereUniqueWithoutHotelMekkahInput[]
    updateMany?: UserPackageUpdateManyWithWhereWithoutHotelMekkahInput | UserPackageUpdateManyWithWhereWithoutHotelMekkahInput[]
    deleteMany?: UserPackageScalarWhereInput | UserPackageScalarWhereInput[]
  }

  export type UserPackageUpdateManyWithoutHotelMadinahNestedInput = {
    create?: XOR<UserPackageCreateWithoutHotelMadinahInput, UserPackageUncheckedCreateWithoutHotelMadinahInput> | UserPackageCreateWithoutHotelMadinahInput[] | UserPackageUncheckedCreateWithoutHotelMadinahInput[]
    connectOrCreate?: UserPackageCreateOrConnectWithoutHotelMadinahInput | UserPackageCreateOrConnectWithoutHotelMadinahInput[]
    upsert?: UserPackageUpsertWithWhereUniqueWithoutHotelMadinahInput | UserPackageUpsertWithWhereUniqueWithoutHotelMadinahInput[]
    createMany?: UserPackageCreateManyHotelMadinahInputEnvelope
    set?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    disconnect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    delete?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    connect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    update?: UserPackageUpdateWithWhereUniqueWithoutHotelMadinahInput | UserPackageUpdateWithWhereUniqueWithoutHotelMadinahInput[]
    updateMany?: UserPackageUpdateManyWithWhereWithoutHotelMadinahInput | UserPackageUpdateManyWithWhereWithoutHotelMadinahInput[]
    deleteMany?: UserPackageScalarWhereInput | UserPackageScalarWhereInput[]
  }

  export type UserPackageUpdateManyWithoutMuthawifNestedInput = {
    create?: XOR<UserPackageCreateWithoutMuthawifInput, UserPackageUncheckedCreateWithoutMuthawifInput> | UserPackageCreateWithoutMuthawifInput[] | UserPackageUncheckedCreateWithoutMuthawifInput[]
    connectOrCreate?: UserPackageCreateOrConnectWithoutMuthawifInput | UserPackageCreateOrConnectWithoutMuthawifInput[]
    upsert?: UserPackageUpsertWithWhereUniqueWithoutMuthawifInput | UserPackageUpsertWithWhereUniqueWithoutMuthawifInput[]
    createMany?: UserPackageCreateManyMuthawifInputEnvelope
    set?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    disconnect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    delete?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    connect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    update?: UserPackageUpdateWithWhereUniqueWithoutMuthawifInput | UserPackageUpdateWithWhereUniqueWithoutMuthawifInput[]
    updateMany?: UserPackageUpdateManyWithWhereWithoutMuthawifInput | UserPackageUpdateManyWithWhereWithoutMuthawifInput[]
    deleteMany?: UserPackageScalarWhereInput | UserPackageScalarWhereInput[]
  }

  export type UserPackageUpdateManyWithoutHandlingNestedInput = {
    create?: XOR<UserPackageCreateWithoutHandlingInput, UserPackageUncheckedCreateWithoutHandlingInput> | UserPackageCreateWithoutHandlingInput[] | UserPackageUncheckedCreateWithoutHandlingInput[]
    connectOrCreate?: UserPackageCreateOrConnectWithoutHandlingInput | UserPackageCreateOrConnectWithoutHandlingInput[]
    upsert?: UserPackageUpsertWithWhereUniqueWithoutHandlingInput | UserPackageUpsertWithWhereUniqueWithoutHandlingInput[]
    createMany?: UserPackageCreateManyHandlingInputEnvelope
    set?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    disconnect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    delete?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    connect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    update?: UserPackageUpdateWithWhereUniqueWithoutHandlingInput | UserPackageUpdateWithWhereUniqueWithoutHandlingInput[]
    updateMany?: UserPackageUpdateManyWithWhereWithoutHandlingInput | UserPackageUpdateManyWithWhereWithoutHandlingInput[]
    deleteMany?: UserPackageScalarWhereInput | UserPackageScalarWhereInput[]
  }

  export type PackageTypeUpdateOneRequiredWithoutUserPackageOptionsNestedInput = {
    create?: XOR<PackageTypeCreateWithoutUserPackageOptionsInput, PackageTypeUncheckedCreateWithoutUserPackageOptionsInput>
    connectOrCreate?: PackageTypeCreateOrConnectWithoutUserPackageOptionsInput
    upsert?: PackageTypeUpsertWithoutUserPackageOptionsInput
    connect?: PackageTypeWhereUniqueInput
    update?: XOR<XOR<PackageTypeUpdateToOneWithWhereWithoutUserPackageOptionsInput, PackageTypeUpdateWithoutUserPackageOptionsInput>, PackageTypeUncheckedUpdateWithoutUserPackageOptionsInput>
  }

  export type UserPackageUncheckedUpdateManyWithoutTransportationNestedInput = {
    create?: XOR<UserPackageCreateWithoutTransportationInput, UserPackageUncheckedCreateWithoutTransportationInput> | UserPackageCreateWithoutTransportationInput[] | UserPackageUncheckedCreateWithoutTransportationInput[]
    connectOrCreate?: UserPackageCreateOrConnectWithoutTransportationInput | UserPackageCreateOrConnectWithoutTransportationInput[]
    upsert?: UserPackageUpsertWithWhereUniqueWithoutTransportationInput | UserPackageUpsertWithWhereUniqueWithoutTransportationInput[]
    createMany?: UserPackageCreateManyTransportationInputEnvelope
    set?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    disconnect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    delete?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    connect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    update?: UserPackageUpdateWithWhereUniqueWithoutTransportationInput | UserPackageUpdateWithWhereUniqueWithoutTransportationInput[]
    updateMany?: UserPackageUpdateManyWithWhereWithoutTransportationInput | UserPackageUpdateManyWithWhereWithoutTransportationInput[]
    deleteMany?: UserPackageScalarWhereInput | UserPackageScalarWhereInput[]
  }

  export type UserPackageUncheckedUpdateManyWithoutFlightNestedInput = {
    create?: XOR<UserPackageCreateWithoutFlightInput, UserPackageUncheckedCreateWithoutFlightInput> | UserPackageCreateWithoutFlightInput[] | UserPackageUncheckedCreateWithoutFlightInput[]
    connectOrCreate?: UserPackageCreateOrConnectWithoutFlightInput | UserPackageCreateOrConnectWithoutFlightInput[]
    upsert?: UserPackageUpsertWithWhereUniqueWithoutFlightInput | UserPackageUpsertWithWhereUniqueWithoutFlightInput[]
    createMany?: UserPackageCreateManyFlightInputEnvelope
    set?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    disconnect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    delete?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    connect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    update?: UserPackageUpdateWithWhereUniqueWithoutFlightInput | UserPackageUpdateWithWhereUniqueWithoutFlightInput[]
    updateMany?: UserPackageUpdateManyWithWhereWithoutFlightInput | UserPackageUpdateManyWithWhereWithoutFlightInput[]
    deleteMany?: UserPackageScalarWhereInput | UserPackageScalarWhereInput[]
  }

  export type UserPackageUncheckedUpdateManyWithoutHotelMekkahNestedInput = {
    create?: XOR<UserPackageCreateWithoutHotelMekkahInput, UserPackageUncheckedCreateWithoutHotelMekkahInput> | UserPackageCreateWithoutHotelMekkahInput[] | UserPackageUncheckedCreateWithoutHotelMekkahInput[]
    connectOrCreate?: UserPackageCreateOrConnectWithoutHotelMekkahInput | UserPackageCreateOrConnectWithoutHotelMekkahInput[]
    upsert?: UserPackageUpsertWithWhereUniqueWithoutHotelMekkahInput | UserPackageUpsertWithWhereUniqueWithoutHotelMekkahInput[]
    createMany?: UserPackageCreateManyHotelMekkahInputEnvelope
    set?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    disconnect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    delete?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    connect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    update?: UserPackageUpdateWithWhereUniqueWithoutHotelMekkahInput | UserPackageUpdateWithWhereUniqueWithoutHotelMekkahInput[]
    updateMany?: UserPackageUpdateManyWithWhereWithoutHotelMekkahInput | UserPackageUpdateManyWithWhereWithoutHotelMekkahInput[]
    deleteMany?: UserPackageScalarWhereInput | UserPackageScalarWhereInput[]
  }

  export type UserPackageUncheckedUpdateManyWithoutHotelMadinahNestedInput = {
    create?: XOR<UserPackageCreateWithoutHotelMadinahInput, UserPackageUncheckedCreateWithoutHotelMadinahInput> | UserPackageCreateWithoutHotelMadinahInput[] | UserPackageUncheckedCreateWithoutHotelMadinahInput[]
    connectOrCreate?: UserPackageCreateOrConnectWithoutHotelMadinahInput | UserPackageCreateOrConnectWithoutHotelMadinahInput[]
    upsert?: UserPackageUpsertWithWhereUniqueWithoutHotelMadinahInput | UserPackageUpsertWithWhereUniqueWithoutHotelMadinahInput[]
    createMany?: UserPackageCreateManyHotelMadinahInputEnvelope
    set?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    disconnect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    delete?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    connect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    update?: UserPackageUpdateWithWhereUniqueWithoutHotelMadinahInput | UserPackageUpdateWithWhereUniqueWithoutHotelMadinahInput[]
    updateMany?: UserPackageUpdateManyWithWhereWithoutHotelMadinahInput | UserPackageUpdateManyWithWhereWithoutHotelMadinahInput[]
    deleteMany?: UserPackageScalarWhereInput | UserPackageScalarWhereInput[]
  }

  export type UserPackageUncheckedUpdateManyWithoutMuthawifNestedInput = {
    create?: XOR<UserPackageCreateWithoutMuthawifInput, UserPackageUncheckedCreateWithoutMuthawifInput> | UserPackageCreateWithoutMuthawifInput[] | UserPackageUncheckedCreateWithoutMuthawifInput[]
    connectOrCreate?: UserPackageCreateOrConnectWithoutMuthawifInput | UserPackageCreateOrConnectWithoutMuthawifInput[]
    upsert?: UserPackageUpsertWithWhereUniqueWithoutMuthawifInput | UserPackageUpsertWithWhereUniqueWithoutMuthawifInput[]
    createMany?: UserPackageCreateManyMuthawifInputEnvelope
    set?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    disconnect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    delete?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    connect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    update?: UserPackageUpdateWithWhereUniqueWithoutMuthawifInput | UserPackageUpdateWithWhereUniqueWithoutMuthawifInput[]
    updateMany?: UserPackageUpdateManyWithWhereWithoutMuthawifInput | UserPackageUpdateManyWithWhereWithoutMuthawifInput[]
    deleteMany?: UserPackageScalarWhereInput | UserPackageScalarWhereInput[]
  }

  export type UserPackageUncheckedUpdateManyWithoutHandlingNestedInput = {
    create?: XOR<UserPackageCreateWithoutHandlingInput, UserPackageUncheckedCreateWithoutHandlingInput> | UserPackageCreateWithoutHandlingInput[] | UserPackageUncheckedCreateWithoutHandlingInput[]
    connectOrCreate?: UserPackageCreateOrConnectWithoutHandlingInput | UserPackageCreateOrConnectWithoutHandlingInput[]
    upsert?: UserPackageUpsertWithWhereUniqueWithoutHandlingInput | UserPackageUpsertWithWhereUniqueWithoutHandlingInput[]
    createMany?: UserPackageCreateManyHandlingInputEnvelope
    set?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    disconnect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    delete?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    connect?: UserPackageWhereUniqueInput | UserPackageWhereUniqueInput[]
    update?: UserPackageUpdateWithWhereUniqueWithoutHandlingInput | UserPackageUpdateWithWhereUniqueWithoutHandlingInput[]
    updateMany?: UserPackageUpdateManyWithWhereWithoutHandlingInput | UserPackageUpdateManyWithWhereWithoutHandlingInput[]
    deleteMany?: UserPackageScalarWhereInput | UserPackageScalarWhereInput[]
  }

  export type UserPackageCreateNestedOneWithoutUserPackageOrdersInput = {
    create?: XOR<UserPackageCreateWithoutUserPackageOrdersInput, UserPackageUncheckedCreateWithoutUserPackageOrdersInput>
    connectOrCreate?: UserPackageCreateOrConnectWithoutUserPackageOrdersInput
    connect?: UserPackageWhereUniqueInput
  }

  export type UserPackageUpdateOneRequiredWithoutUserPackageOrdersNestedInput = {
    create?: XOR<UserPackageCreateWithoutUserPackageOrdersInput, UserPackageUncheckedCreateWithoutUserPackageOrdersInput>
    connectOrCreate?: UserPackageCreateOrConnectWithoutUserPackageOrdersInput
    upsert?: UserPackageUpsertWithoutUserPackageOrdersInput
    connect?: UserPackageWhereUniqueInput
    update?: XOR<XOR<UserPackageUpdateToOneWithWhereWithoutUserPackageOrdersInput, UserPackageUpdateWithoutUserPackageOrdersInput>, UserPackageUncheckedUpdateWithoutUserPackageOrdersInput>
  }

  export type ProductCategoryCreateNestedManyWithoutCategoryInput = {
    create?: XOR<ProductCategoryCreateWithoutCategoryInput, ProductCategoryUncheckedCreateWithoutCategoryInput> | ProductCategoryCreateWithoutCategoryInput[] | ProductCategoryUncheckedCreateWithoutCategoryInput[]
    connectOrCreate?: ProductCategoryCreateOrConnectWithoutCategoryInput | ProductCategoryCreateOrConnectWithoutCategoryInput[]
    createMany?: ProductCategoryCreateManyCategoryInputEnvelope
    connect?: ProductCategoryWhereUniqueInput | ProductCategoryWhereUniqueInput[]
  }

  export type ProductCategoryUncheckedCreateNestedManyWithoutCategoryInput = {
    create?: XOR<ProductCategoryCreateWithoutCategoryInput, ProductCategoryUncheckedCreateWithoutCategoryInput> | ProductCategoryCreateWithoutCategoryInput[] | ProductCategoryUncheckedCreateWithoutCategoryInput[]
    connectOrCreate?: ProductCategoryCreateOrConnectWithoutCategoryInput | ProductCategoryCreateOrConnectWithoutCategoryInput[]
    createMany?: ProductCategoryCreateManyCategoryInputEnvelope
    connect?: ProductCategoryWhereUniqueInput | ProductCategoryWhereUniqueInput[]
  }

  export type ProductCategoryUpdateManyWithoutCategoryNestedInput = {
    create?: XOR<ProductCategoryCreateWithoutCategoryInput, ProductCategoryUncheckedCreateWithoutCategoryInput> | ProductCategoryCreateWithoutCategoryInput[] | ProductCategoryUncheckedCreateWithoutCategoryInput[]
    connectOrCreate?: ProductCategoryCreateOrConnectWithoutCategoryInput | ProductCategoryCreateOrConnectWithoutCategoryInput[]
    upsert?: ProductCategoryUpsertWithWhereUniqueWithoutCategoryInput | ProductCategoryUpsertWithWhereUniqueWithoutCategoryInput[]
    createMany?: ProductCategoryCreateManyCategoryInputEnvelope
    set?: ProductCategoryWhereUniqueInput | ProductCategoryWhereUniqueInput[]
    disconnect?: ProductCategoryWhereUniqueInput | ProductCategoryWhereUniqueInput[]
    delete?: ProductCategoryWhereUniqueInput | ProductCategoryWhereUniqueInput[]
    connect?: ProductCategoryWhereUniqueInput | ProductCategoryWhereUniqueInput[]
    update?: ProductCategoryUpdateWithWhereUniqueWithoutCategoryInput | ProductCategoryUpdateWithWhereUniqueWithoutCategoryInput[]
    updateMany?: ProductCategoryUpdateManyWithWhereWithoutCategoryInput | ProductCategoryUpdateManyWithWhereWithoutCategoryInput[]
    deleteMany?: ProductCategoryScalarWhereInput | ProductCategoryScalarWhereInput[]
  }

  export type ProductCategoryUncheckedUpdateManyWithoutCategoryNestedInput = {
    create?: XOR<ProductCategoryCreateWithoutCategoryInput, ProductCategoryUncheckedCreateWithoutCategoryInput> | ProductCategoryCreateWithoutCategoryInput[] | ProductCategoryUncheckedCreateWithoutCategoryInput[]
    connectOrCreate?: ProductCategoryCreateOrConnectWithoutCategoryInput | ProductCategoryCreateOrConnectWithoutCategoryInput[]
    upsert?: ProductCategoryUpsertWithWhereUniqueWithoutCategoryInput | ProductCategoryUpsertWithWhereUniqueWithoutCategoryInput[]
    createMany?: ProductCategoryCreateManyCategoryInputEnvelope
    set?: ProductCategoryWhereUniqueInput | ProductCategoryWhereUniqueInput[]
    disconnect?: ProductCategoryWhereUniqueInput | ProductCategoryWhereUniqueInput[]
    delete?: ProductCategoryWhereUniqueInput | ProductCategoryWhereUniqueInput[]
    connect?: ProductCategoryWhereUniqueInput | ProductCategoryWhereUniqueInput[]
    update?: ProductCategoryUpdateWithWhereUniqueWithoutCategoryInput | ProductCategoryUpdateWithWhereUniqueWithoutCategoryInput[]
    updateMany?: ProductCategoryUpdateManyWithWhereWithoutCategoryInput | ProductCategoryUpdateManyWithWhereWithoutCategoryInput[]
    deleteMany?: ProductCategoryScalarWhereInput | ProductCategoryScalarWhereInput[]
  }

  export type ProductThumbnailCreateNestedManyWithoutProductInput = {
    create?: XOR<ProductThumbnailCreateWithoutProductInput, ProductThumbnailUncheckedCreateWithoutProductInput> | ProductThumbnailCreateWithoutProductInput[] | ProductThumbnailUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductThumbnailCreateOrConnectWithoutProductInput | ProductThumbnailCreateOrConnectWithoutProductInput[]
    createMany?: ProductThumbnailCreateManyProductInputEnvelope
    connect?: ProductThumbnailWhereUniqueInput | ProductThumbnailWhereUniqueInput[]
  }

  export type ProductCategoryCreateNestedManyWithoutProductInput = {
    create?: XOR<ProductCategoryCreateWithoutProductInput, ProductCategoryUncheckedCreateWithoutProductInput> | ProductCategoryCreateWithoutProductInput[] | ProductCategoryUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductCategoryCreateOrConnectWithoutProductInput | ProductCategoryCreateOrConnectWithoutProductInput[]
    createMany?: ProductCategoryCreateManyProductInputEnvelope
    connect?: ProductCategoryWhereUniqueInput | ProductCategoryWhereUniqueInput[]
  }

  export type ProductVariationCreateNestedManyWithoutProductInput = {
    create?: XOR<ProductVariationCreateWithoutProductInput, ProductVariationUncheckedCreateWithoutProductInput> | ProductVariationCreateWithoutProductInput[] | ProductVariationUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductVariationCreateOrConnectWithoutProductInput | ProductVariationCreateOrConnectWithoutProductInput[]
    createMany?: ProductVariationCreateManyProductInputEnvelope
    connect?: ProductVariationWhereUniqueInput | ProductVariationWhereUniqueInput[]
  }

  export type ProductIncludeCreateNestedManyWithoutProductInput = {
    create?: XOR<ProductIncludeCreateWithoutProductInput, ProductIncludeUncheckedCreateWithoutProductInput> | ProductIncludeCreateWithoutProductInput[] | ProductIncludeUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductIncludeCreateOrConnectWithoutProductInput | ProductIncludeCreateOrConnectWithoutProductInput[]
    createMany?: ProductIncludeCreateManyProductInputEnvelope
    connect?: ProductIncludeWhereUniqueInput | ProductIncludeWhereUniqueInput[]
  }

  export type ProductExcludeCreateNestedManyWithoutProductInput = {
    create?: XOR<ProductExcludeCreateWithoutProductInput, ProductExcludeUncheckedCreateWithoutProductInput> | ProductExcludeCreateWithoutProductInput[] | ProductExcludeUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductExcludeCreateOrConnectWithoutProductInput | ProductExcludeCreateOrConnectWithoutProductInput[]
    createMany?: ProductExcludeCreateManyProductInputEnvelope
    connect?: ProductExcludeWhereUniqueInput | ProductExcludeWhereUniqueInput[]
  }

  export type ProductOrderCreateNestedManyWithoutProductInput = {
    create?: XOR<ProductOrderCreateWithoutProductInput, ProductOrderUncheckedCreateWithoutProductInput> | ProductOrderCreateWithoutProductInput[] | ProductOrderUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductOrderCreateOrConnectWithoutProductInput | ProductOrderCreateOrConnectWithoutProductInput[]
    createMany?: ProductOrderCreateManyProductInputEnvelope
    connect?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
  }

  export type ProductThumbnailUncheckedCreateNestedManyWithoutProductInput = {
    create?: XOR<ProductThumbnailCreateWithoutProductInput, ProductThumbnailUncheckedCreateWithoutProductInput> | ProductThumbnailCreateWithoutProductInput[] | ProductThumbnailUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductThumbnailCreateOrConnectWithoutProductInput | ProductThumbnailCreateOrConnectWithoutProductInput[]
    createMany?: ProductThumbnailCreateManyProductInputEnvelope
    connect?: ProductThumbnailWhereUniqueInput | ProductThumbnailWhereUniqueInput[]
  }

  export type ProductCategoryUncheckedCreateNestedManyWithoutProductInput = {
    create?: XOR<ProductCategoryCreateWithoutProductInput, ProductCategoryUncheckedCreateWithoutProductInput> | ProductCategoryCreateWithoutProductInput[] | ProductCategoryUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductCategoryCreateOrConnectWithoutProductInput | ProductCategoryCreateOrConnectWithoutProductInput[]
    createMany?: ProductCategoryCreateManyProductInputEnvelope
    connect?: ProductCategoryWhereUniqueInput | ProductCategoryWhereUniqueInput[]
  }

  export type ProductVariationUncheckedCreateNestedManyWithoutProductInput = {
    create?: XOR<ProductVariationCreateWithoutProductInput, ProductVariationUncheckedCreateWithoutProductInput> | ProductVariationCreateWithoutProductInput[] | ProductVariationUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductVariationCreateOrConnectWithoutProductInput | ProductVariationCreateOrConnectWithoutProductInput[]
    createMany?: ProductVariationCreateManyProductInputEnvelope
    connect?: ProductVariationWhereUniqueInput | ProductVariationWhereUniqueInput[]
  }

  export type ProductIncludeUncheckedCreateNestedManyWithoutProductInput = {
    create?: XOR<ProductIncludeCreateWithoutProductInput, ProductIncludeUncheckedCreateWithoutProductInput> | ProductIncludeCreateWithoutProductInput[] | ProductIncludeUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductIncludeCreateOrConnectWithoutProductInput | ProductIncludeCreateOrConnectWithoutProductInput[]
    createMany?: ProductIncludeCreateManyProductInputEnvelope
    connect?: ProductIncludeWhereUniqueInput | ProductIncludeWhereUniqueInput[]
  }

  export type ProductExcludeUncheckedCreateNestedManyWithoutProductInput = {
    create?: XOR<ProductExcludeCreateWithoutProductInput, ProductExcludeUncheckedCreateWithoutProductInput> | ProductExcludeCreateWithoutProductInput[] | ProductExcludeUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductExcludeCreateOrConnectWithoutProductInput | ProductExcludeCreateOrConnectWithoutProductInput[]
    createMany?: ProductExcludeCreateManyProductInputEnvelope
    connect?: ProductExcludeWhereUniqueInput | ProductExcludeWhereUniqueInput[]
  }

  export type ProductOrderUncheckedCreateNestedManyWithoutProductInput = {
    create?: XOR<ProductOrderCreateWithoutProductInput, ProductOrderUncheckedCreateWithoutProductInput> | ProductOrderCreateWithoutProductInput[] | ProductOrderUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductOrderCreateOrConnectWithoutProductInput | ProductOrderCreateOrConnectWithoutProductInput[]
    createMany?: ProductOrderCreateManyProductInputEnvelope
    connect?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
  }

  export type ProductThumbnailUpdateManyWithoutProductNestedInput = {
    create?: XOR<ProductThumbnailCreateWithoutProductInput, ProductThumbnailUncheckedCreateWithoutProductInput> | ProductThumbnailCreateWithoutProductInput[] | ProductThumbnailUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductThumbnailCreateOrConnectWithoutProductInput | ProductThumbnailCreateOrConnectWithoutProductInput[]
    upsert?: ProductThumbnailUpsertWithWhereUniqueWithoutProductInput | ProductThumbnailUpsertWithWhereUniqueWithoutProductInput[]
    createMany?: ProductThumbnailCreateManyProductInputEnvelope
    set?: ProductThumbnailWhereUniqueInput | ProductThumbnailWhereUniqueInput[]
    disconnect?: ProductThumbnailWhereUniqueInput | ProductThumbnailWhereUniqueInput[]
    delete?: ProductThumbnailWhereUniqueInput | ProductThumbnailWhereUniqueInput[]
    connect?: ProductThumbnailWhereUniqueInput | ProductThumbnailWhereUniqueInput[]
    update?: ProductThumbnailUpdateWithWhereUniqueWithoutProductInput | ProductThumbnailUpdateWithWhereUniqueWithoutProductInput[]
    updateMany?: ProductThumbnailUpdateManyWithWhereWithoutProductInput | ProductThumbnailUpdateManyWithWhereWithoutProductInput[]
    deleteMany?: ProductThumbnailScalarWhereInput | ProductThumbnailScalarWhereInput[]
  }

  export type ProductCategoryUpdateManyWithoutProductNestedInput = {
    create?: XOR<ProductCategoryCreateWithoutProductInput, ProductCategoryUncheckedCreateWithoutProductInput> | ProductCategoryCreateWithoutProductInput[] | ProductCategoryUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductCategoryCreateOrConnectWithoutProductInput | ProductCategoryCreateOrConnectWithoutProductInput[]
    upsert?: ProductCategoryUpsertWithWhereUniqueWithoutProductInput | ProductCategoryUpsertWithWhereUniqueWithoutProductInput[]
    createMany?: ProductCategoryCreateManyProductInputEnvelope
    set?: ProductCategoryWhereUniqueInput | ProductCategoryWhereUniqueInput[]
    disconnect?: ProductCategoryWhereUniqueInput | ProductCategoryWhereUniqueInput[]
    delete?: ProductCategoryWhereUniqueInput | ProductCategoryWhereUniqueInput[]
    connect?: ProductCategoryWhereUniqueInput | ProductCategoryWhereUniqueInput[]
    update?: ProductCategoryUpdateWithWhereUniqueWithoutProductInput | ProductCategoryUpdateWithWhereUniqueWithoutProductInput[]
    updateMany?: ProductCategoryUpdateManyWithWhereWithoutProductInput | ProductCategoryUpdateManyWithWhereWithoutProductInput[]
    deleteMany?: ProductCategoryScalarWhereInput | ProductCategoryScalarWhereInput[]
  }

  export type ProductVariationUpdateManyWithoutProductNestedInput = {
    create?: XOR<ProductVariationCreateWithoutProductInput, ProductVariationUncheckedCreateWithoutProductInput> | ProductVariationCreateWithoutProductInput[] | ProductVariationUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductVariationCreateOrConnectWithoutProductInput | ProductVariationCreateOrConnectWithoutProductInput[]
    upsert?: ProductVariationUpsertWithWhereUniqueWithoutProductInput | ProductVariationUpsertWithWhereUniqueWithoutProductInput[]
    createMany?: ProductVariationCreateManyProductInputEnvelope
    set?: ProductVariationWhereUniqueInput | ProductVariationWhereUniqueInput[]
    disconnect?: ProductVariationWhereUniqueInput | ProductVariationWhereUniqueInput[]
    delete?: ProductVariationWhereUniqueInput | ProductVariationWhereUniqueInput[]
    connect?: ProductVariationWhereUniqueInput | ProductVariationWhereUniqueInput[]
    update?: ProductVariationUpdateWithWhereUniqueWithoutProductInput | ProductVariationUpdateWithWhereUniqueWithoutProductInput[]
    updateMany?: ProductVariationUpdateManyWithWhereWithoutProductInput | ProductVariationUpdateManyWithWhereWithoutProductInput[]
    deleteMany?: ProductVariationScalarWhereInput | ProductVariationScalarWhereInput[]
  }

  export type ProductIncludeUpdateManyWithoutProductNestedInput = {
    create?: XOR<ProductIncludeCreateWithoutProductInput, ProductIncludeUncheckedCreateWithoutProductInput> | ProductIncludeCreateWithoutProductInput[] | ProductIncludeUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductIncludeCreateOrConnectWithoutProductInput | ProductIncludeCreateOrConnectWithoutProductInput[]
    upsert?: ProductIncludeUpsertWithWhereUniqueWithoutProductInput | ProductIncludeUpsertWithWhereUniqueWithoutProductInput[]
    createMany?: ProductIncludeCreateManyProductInputEnvelope
    set?: ProductIncludeWhereUniqueInput | ProductIncludeWhereUniqueInput[]
    disconnect?: ProductIncludeWhereUniqueInput | ProductIncludeWhereUniqueInput[]
    delete?: ProductIncludeWhereUniqueInput | ProductIncludeWhereUniqueInput[]
    connect?: ProductIncludeWhereUniqueInput | ProductIncludeWhereUniqueInput[]
    update?: ProductIncludeUpdateWithWhereUniqueWithoutProductInput | ProductIncludeUpdateWithWhereUniqueWithoutProductInput[]
    updateMany?: ProductIncludeUpdateManyWithWhereWithoutProductInput | ProductIncludeUpdateManyWithWhereWithoutProductInput[]
    deleteMany?: ProductIncludeScalarWhereInput | ProductIncludeScalarWhereInput[]
  }

  export type ProductExcludeUpdateManyWithoutProductNestedInput = {
    create?: XOR<ProductExcludeCreateWithoutProductInput, ProductExcludeUncheckedCreateWithoutProductInput> | ProductExcludeCreateWithoutProductInput[] | ProductExcludeUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductExcludeCreateOrConnectWithoutProductInput | ProductExcludeCreateOrConnectWithoutProductInput[]
    upsert?: ProductExcludeUpsertWithWhereUniqueWithoutProductInput | ProductExcludeUpsertWithWhereUniqueWithoutProductInput[]
    createMany?: ProductExcludeCreateManyProductInputEnvelope
    set?: ProductExcludeWhereUniqueInput | ProductExcludeWhereUniqueInput[]
    disconnect?: ProductExcludeWhereUniqueInput | ProductExcludeWhereUniqueInput[]
    delete?: ProductExcludeWhereUniqueInput | ProductExcludeWhereUniqueInput[]
    connect?: ProductExcludeWhereUniqueInput | ProductExcludeWhereUniqueInput[]
    update?: ProductExcludeUpdateWithWhereUniqueWithoutProductInput | ProductExcludeUpdateWithWhereUniqueWithoutProductInput[]
    updateMany?: ProductExcludeUpdateManyWithWhereWithoutProductInput | ProductExcludeUpdateManyWithWhereWithoutProductInput[]
    deleteMany?: ProductExcludeScalarWhereInput | ProductExcludeScalarWhereInput[]
  }

  export type ProductOrderUpdateManyWithoutProductNestedInput = {
    create?: XOR<ProductOrderCreateWithoutProductInput, ProductOrderUncheckedCreateWithoutProductInput> | ProductOrderCreateWithoutProductInput[] | ProductOrderUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductOrderCreateOrConnectWithoutProductInput | ProductOrderCreateOrConnectWithoutProductInput[]
    upsert?: ProductOrderUpsertWithWhereUniqueWithoutProductInput | ProductOrderUpsertWithWhereUniqueWithoutProductInput[]
    createMany?: ProductOrderCreateManyProductInputEnvelope
    set?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
    disconnect?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
    delete?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
    connect?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
    update?: ProductOrderUpdateWithWhereUniqueWithoutProductInput | ProductOrderUpdateWithWhereUniqueWithoutProductInput[]
    updateMany?: ProductOrderUpdateManyWithWhereWithoutProductInput | ProductOrderUpdateManyWithWhereWithoutProductInput[]
    deleteMany?: ProductOrderScalarWhereInput | ProductOrderScalarWhereInput[]
  }

  export type ProductThumbnailUncheckedUpdateManyWithoutProductNestedInput = {
    create?: XOR<ProductThumbnailCreateWithoutProductInput, ProductThumbnailUncheckedCreateWithoutProductInput> | ProductThumbnailCreateWithoutProductInput[] | ProductThumbnailUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductThumbnailCreateOrConnectWithoutProductInput | ProductThumbnailCreateOrConnectWithoutProductInput[]
    upsert?: ProductThumbnailUpsertWithWhereUniqueWithoutProductInput | ProductThumbnailUpsertWithWhereUniqueWithoutProductInput[]
    createMany?: ProductThumbnailCreateManyProductInputEnvelope
    set?: ProductThumbnailWhereUniqueInput | ProductThumbnailWhereUniqueInput[]
    disconnect?: ProductThumbnailWhereUniqueInput | ProductThumbnailWhereUniqueInput[]
    delete?: ProductThumbnailWhereUniqueInput | ProductThumbnailWhereUniqueInput[]
    connect?: ProductThumbnailWhereUniqueInput | ProductThumbnailWhereUniqueInput[]
    update?: ProductThumbnailUpdateWithWhereUniqueWithoutProductInput | ProductThumbnailUpdateWithWhereUniqueWithoutProductInput[]
    updateMany?: ProductThumbnailUpdateManyWithWhereWithoutProductInput | ProductThumbnailUpdateManyWithWhereWithoutProductInput[]
    deleteMany?: ProductThumbnailScalarWhereInput | ProductThumbnailScalarWhereInput[]
  }

  export type ProductCategoryUncheckedUpdateManyWithoutProductNestedInput = {
    create?: XOR<ProductCategoryCreateWithoutProductInput, ProductCategoryUncheckedCreateWithoutProductInput> | ProductCategoryCreateWithoutProductInput[] | ProductCategoryUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductCategoryCreateOrConnectWithoutProductInput | ProductCategoryCreateOrConnectWithoutProductInput[]
    upsert?: ProductCategoryUpsertWithWhereUniqueWithoutProductInput | ProductCategoryUpsertWithWhereUniqueWithoutProductInput[]
    createMany?: ProductCategoryCreateManyProductInputEnvelope
    set?: ProductCategoryWhereUniqueInput | ProductCategoryWhereUniqueInput[]
    disconnect?: ProductCategoryWhereUniqueInput | ProductCategoryWhereUniqueInput[]
    delete?: ProductCategoryWhereUniqueInput | ProductCategoryWhereUniqueInput[]
    connect?: ProductCategoryWhereUniqueInput | ProductCategoryWhereUniqueInput[]
    update?: ProductCategoryUpdateWithWhereUniqueWithoutProductInput | ProductCategoryUpdateWithWhereUniqueWithoutProductInput[]
    updateMany?: ProductCategoryUpdateManyWithWhereWithoutProductInput | ProductCategoryUpdateManyWithWhereWithoutProductInput[]
    deleteMany?: ProductCategoryScalarWhereInput | ProductCategoryScalarWhereInput[]
  }

  export type ProductVariationUncheckedUpdateManyWithoutProductNestedInput = {
    create?: XOR<ProductVariationCreateWithoutProductInput, ProductVariationUncheckedCreateWithoutProductInput> | ProductVariationCreateWithoutProductInput[] | ProductVariationUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductVariationCreateOrConnectWithoutProductInput | ProductVariationCreateOrConnectWithoutProductInput[]
    upsert?: ProductVariationUpsertWithWhereUniqueWithoutProductInput | ProductVariationUpsertWithWhereUniqueWithoutProductInput[]
    createMany?: ProductVariationCreateManyProductInputEnvelope
    set?: ProductVariationWhereUniqueInput | ProductVariationWhereUniqueInput[]
    disconnect?: ProductVariationWhereUniqueInput | ProductVariationWhereUniqueInput[]
    delete?: ProductVariationWhereUniqueInput | ProductVariationWhereUniqueInput[]
    connect?: ProductVariationWhereUniqueInput | ProductVariationWhereUniqueInput[]
    update?: ProductVariationUpdateWithWhereUniqueWithoutProductInput | ProductVariationUpdateWithWhereUniqueWithoutProductInput[]
    updateMany?: ProductVariationUpdateManyWithWhereWithoutProductInput | ProductVariationUpdateManyWithWhereWithoutProductInput[]
    deleteMany?: ProductVariationScalarWhereInput | ProductVariationScalarWhereInput[]
  }

  export type ProductIncludeUncheckedUpdateManyWithoutProductNestedInput = {
    create?: XOR<ProductIncludeCreateWithoutProductInput, ProductIncludeUncheckedCreateWithoutProductInput> | ProductIncludeCreateWithoutProductInput[] | ProductIncludeUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductIncludeCreateOrConnectWithoutProductInput | ProductIncludeCreateOrConnectWithoutProductInput[]
    upsert?: ProductIncludeUpsertWithWhereUniqueWithoutProductInput | ProductIncludeUpsertWithWhereUniqueWithoutProductInput[]
    createMany?: ProductIncludeCreateManyProductInputEnvelope
    set?: ProductIncludeWhereUniqueInput | ProductIncludeWhereUniqueInput[]
    disconnect?: ProductIncludeWhereUniqueInput | ProductIncludeWhereUniqueInput[]
    delete?: ProductIncludeWhereUniqueInput | ProductIncludeWhereUniqueInput[]
    connect?: ProductIncludeWhereUniqueInput | ProductIncludeWhereUniqueInput[]
    update?: ProductIncludeUpdateWithWhereUniqueWithoutProductInput | ProductIncludeUpdateWithWhereUniqueWithoutProductInput[]
    updateMany?: ProductIncludeUpdateManyWithWhereWithoutProductInput | ProductIncludeUpdateManyWithWhereWithoutProductInput[]
    deleteMany?: ProductIncludeScalarWhereInput | ProductIncludeScalarWhereInput[]
  }

  export type ProductExcludeUncheckedUpdateManyWithoutProductNestedInput = {
    create?: XOR<ProductExcludeCreateWithoutProductInput, ProductExcludeUncheckedCreateWithoutProductInput> | ProductExcludeCreateWithoutProductInput[] | ProductExcludeUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductExcludeCreateOrConnectWithoutProductInput | ProductExcludeCreateOrConnectWithoutProductInput[]
    upsert?: ProductExcludeUpsertWithWhereUniqueWithoutProductInput | ProductExcludeUpsertWithWhereUniqueWithoutProductInput[]
    createMany?: ProductExcludeCreateManyProductInputEnvelope
    set?: ProductExcludeWhereUniqueInput | ProductExcludeWhereUniqueInput[]
    disconnect?: ProductExcludeWhereUniqueInput | ProductExcludeWhereUniqueInput[]
    delete?: ProductExcludeWhereUniqueInput | ProductExcludeWhereUniqueInput[]
    connect?: ProductExcludeWhereUniqueInput | ProductExcludeWhereUniqueInput[]
    update?: ProductExcludeUpdateWithWhereUniqueWithoutProductInput | ProductExcludeUpdateWithWhereUniqueWithoutProductInput[]
    updateMany?: ProductExcludeUpdateManyWithWhereWithoutProductInput | ProductExcludeUpdateManyWithWhereWithoutProductInput[]
    deleteMany?: ProductExcludeScalarWhereInput | ProductExcludeScalarWhereInput[]
  }

  export type ProductOrderUncheckedUpdateManyWithoutProductNestedInput = {
    create?: XOR<ProductOrderCreateWithoutProductInput, ProductOrderUncheckedCreateWithoutProductInput> | ProductOrderCreateWithoutProductInput[] | ProductOrderUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductOrderCreateOrConnectWithoutProductInput | ProductOrderCreateOrConnectWithoutProductInput[]
    upsert?: ProductOrderUpsertWithWhereUniqueWithoutProductInput | ProductOrderUpsertWithWhereUniqueWithoutProductInput[]
    createMany?: ProductOrderCreateManyProductInputEnvelope
    set?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
    disconnect?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
    delete?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
    connect?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
    update?: ProductOrderUpdateWithWhereUniqueWithoutProductInput | ProductOrderUpdateWithWhereUniqueWithoutProductInput[]
    updateMany?: ProductOrderUpdateManyWithWhereWithoutProductInput | ProductOrderUpdateManyWithWhereWithoutProductInput[]
    deleteMany?: ProductOrderScalarWhereInput | ProductOrderScalarWhereInput[]
  }

  export type ProductCreateNestedOneWithoutProductThumbnailsInput = {
    create?: XOR<ProductCreateWithoutProductThumbnailsInput, ProductUncheckedCreateWithoutProductThumbnailsInput>
    connectOrCreate?: ProductCreateOrConnectWithoutProductThumbnailsInput
    connect?: ProductWhereUniqueInput
  }

  export type ProductUpdateOneRequiredWithoutProductThumbnailsNestedInput = {
    create?: XOR<ProductCreateWithoutProductThumbnailsInput, ProductUncheckedCreateWithoutProductThumbnailsInput>
    connectOrCreate?: ProductCreateOrConnectWithoutProductThumbnailsInput
    upsert?: ProductUpsertWithoutProductThumbnailsInput
    connect?: ProductWhereUniqueInput
    update?: XOR<XOR<ProductUpdateToOneWithWhereWithoutProductThumbnailsInput, ProductUpdateWithoutProductThumbnailsInput>, ProductUncheckedUpdateWithoutProductThumbnailsInput>
  }

  export type ProductCreateNestedOneWithoutProductCategoriesInput = {
    create?: XOR<ProductCreateWithoutProductCategoriesInput, ProductUncheckedCreateWithoutProductCategoriesInput>
    connectOrCreate?: ProductCreateOrConnectWithoutProductCategoriesInput
    connect?: ProductWhereUniqueInput
  }

  export type CategoryCreateNestedOneWithoutProductCategoriesInput = {
    create?: XOR<CategoryCreateWithoutProductCategoriesInput, CategoryUncheckedCreateWithoutProductCategoriesInput>
    connectOrCreate?: CategoryCreateOrConnectWithoutProductCategoriesInput
    connect?: CategoryWhereUniqueInput
  }

  export type ProductUpdateOneRequiredWithoutProductCategoriesNestedInput = {
    create?: XOR<ProductCreateWithoutProductCategoriesInput, ProductUncheckedCreateWithoutProductCategoriesInput>
    connectOrCreate?: ProductCreateOrConnectWithoutProductCategoriesInput
    upsert?: ProductUpsertWithoutProductCategoriesInput
    connect?: ProductWhereUniqueInput
    update?: XOR<XOR<ProductUpdateToOneWithWhereWithoutProductCategoriesInput, ProductUpdateWithoutProductCategoriesInput>, ProductUncheckedUpdateWithoutProductCategoriesInput>
  }

  export type CategoryUpdateOneRequiredWithoutProductCategoriesNestedInput = {
    create?: XOR<CategoryCreateWithoutProductCategoriesInput, CategoryUncheckedCreateWithoutProductCategoriesInput>
    connectOrCreate?: CategoryCreateOrConnectWithoutProductCategoriesInput
    upsert?: CategoryUpsertWithoutProductCategoriesInput
    connect?: CategoryWhereUniqueInput
    update?: XOR<XOR<CategoryUpdateToOneWithWhereWithoutProductCategoriesInput, CategoryUpdateWithoutProductCategoriesInput>, CategoryUncheckedUpdateWithoutProductCategoriesInput>
  }

  export type ProductOrderCreateNestedManyWithoutProductVariationInput = {
    create?: XOR<ProductOrderCreateWithoutProductVariationInput, ProductOrderUncheckedCreateWithoutProductVariationInput> | ProductOrderCreateWithoutProductVariationInput[] | ProductOrderUncheckedCreateWithoutProductVariationInput[]
    connectOrCreate?: ProductOrderCreateOrConnectWithoutProductVariationInput | ProductOrderCreateOrConnectWithoutProductVariationInput[]
    createMany?: ProductOrderCreateManyProductVariationInputEnvelope
    connect?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
  }

  export type ProductCreateNestedOneWithoutProductVariationsInput = {
    create?: XOR<ProductCreateWithoutProductVariationsInput, ProductUncheckedCreateWithoutProductVariationsInput>
    connectOrCreate?: ProductCreateOrConnectWithoutProductVariationsInput
    connect?: ProductWhereUniqueInput
  }

  export type ProductOrderUncheckedCreateNestedManyWithoutProductVariationInput = {
    create?: XOR<ProductOrderCreateWithoutProductVariationInput, ProductOrderUncheckedCreateWithoutProductVariationInput> | ProductOrderCreateWithoutProductVariationInput[] | ProductOrderUncheckedCreateWithoutProductVariationInput[]
    connectOrCreate?: ProductOrderCreateOrConnectWithoutProductVariationInput | ProductOrderCreateOrConnectWithoutProductVariationInput[]
    createMany?: ProductOrderCreateManyProductVariationInputEnvelope
    connect?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
  }

  export type ProductOrderUpdateManyWithoutProductVariationNestedInput = {
    create?: XOR<ProductOrderCreateWithoutProductVariationInput, ProductOrderUncheckedCreateWithoutProductVariationInput> | ProductOrderCreateWithoutProductVariationInput[] | ProductOrderUncheckedCreateWithoutProductVariationInput[]
    connectOrCreate?: ProductOrderCreateOrConnectWithoutProductVariationInput | ProductOrderCreateOrConnectWithoutProductVariationInput[]
    upsert?: ProductOrderUpsertWithWhereUniqueWithoutProductVariationInput | ProductOrderUpsertWithWhereUniqueWithoutProductVariationInput[]
    createMany?: ProductOrderCreateManyProductVariationInputEnvelope
    set?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
    disconnect?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
    delete?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
    connect?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
    update?: ProductOrderUpdateWithWhereUniqueWithoutProductVariationInput | ProductOrderUpdateWithWhereUniqueWithoutProductVariationInput[]
    updateMany?: ProductOrderUpdateManyWithWhereWithoutProductVariationInput | ProductOrderUpdateManyWithWhereWithoutProductVariationInput[]
    deleteMany?: ProductOrderScalarWhereInput | ProductOrderScalarWhereInput[]
  }

  export type ProductUpdateOneRequiredWithoutProductVariationsNestedInput = {
    create?: XOR<ProductCreateWithoutProductVariationsInput, ProductUncheckedCreateWithoutProductVariationsInput>
    connectOrCreate?: ProductCreateOrConnectWithoutProductVariationsInput
    upsert?: ProductUpsertWithoutProductVariationsInput
    connect?: ProductWhereUniqueInput
    update?: XOR<XOR<ProductUpdateToOneWithWhereWithoutProductVariationsInput, ProductUpdateWithoutProductVariationsInput>, ProductUncheckedUpdateWithoutProductVariationsInput>
  }

  export type ProductOrderUncheckedUpdateManyWithoutProductVariationNestedInput = {
    create?: XOR<ProductOrderCreateWithoutProductVariationInput, ProductOrderUncheckedCreateWithoutProductVariationInput> | ProductOrderCreateWithoutProductVariationInput[] | ProductOrderUncheckedCreateWithoutProductVariationInput[]
    connectOrCreate?: ProductOrderCreateOrConnectWithoutProductVariationInput | ProductOrderCreateOrConnectWithoutProductVariationInput[]
    upsert?: ProductOrderUpsertWithWhereUniqueWithoutProductVariationInput | ProductOrderUpsertWithWhereUniqueWithoutProductVariationInput[]
    createMany?: ProductOrderCreateManyProductVariationInputEnvelope
    set?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
    disconnect?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
    delete?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
    connect?: ProductOrderWhereUniqueInput | ProductOrderWhereUniqueInput[]
    update?: ProductOrderUpdateWithWhereUniqueWithoutProductVariationInput | ProductOrderUpdateWithWhereUniqueWithoutProductVariationInput[]
    updateMany?: ProductOrderUpdateManyWithWhereWithoutProductVariationInput | ProductOrderUpdateManyWithWhereWithoutProductVariationInput[]
    deleteMany?: ProductOrderScalarWhereInput | ProductOrderScalarWhereInput[]
  }

  export type ProductCreateNestedOneWithoutProductIncludesInput = {
    create?: XOR<ProductCreateWithoutProductIncludesInput, ProductUncheckedCreateWithoutProductIncludesInput>
    connectOrCreate?: ProductCreateOrConnectWithoutProductIncludesInput
    connect?: ProductWhereUniqueInput
  }

  export type ProductUpdateOneRequiredWithoutProductIncludesNestedInput = {
    create?: XOR<ProductCreateWithoutProductIncludesInput, ProductUncheckedCreateWithoutProductIncludesInput>
    connectOrCreate?: ProductCreateOrConnectWithoutProductIncludesInput
    upsert?: ProductUpsertWithoutProductIncludesInput
    connect?: ProductWhereUniqueInput
    update?: XOR<XOR<ProductUpdateToOneWithWhereWithoutProductIncludesInput, ProductUpdateWithoutProductIncludesInput>, ProductUncheckedUpdateWithoutProductIncludesInput>
  }

  export type ProductCreateNestedOneWithoutProductExcludesInput = {
    create?: XOR<ProductCreateWithoutProductExcludesInput, ProductUncheckedCreateWithoutProductExcludesInput>
    connectOrCreate?: ProductCreateOrConnectWithoutProductExcludesInput
    connect?: ProductWhereUniqueInput
  }

  export type ProductUpdateOneRequiredWithoutProductExcludesNestedInput = {
    create?: XOR<ProductCreateWithoutProductExcludesInput, ProductUncheckedCreateWithoutProductExcludesInput>
    connectOrCreate?: ProductCreateOrConnectWithoutProductExcludesInput
    upsert?: ProductUpsertWithoutProductExcludesInput
    connect?: ProductWhereUniqueInput
    update?: XOR<XOR<ProductUpdateToOneWithWhereWithoutProductExcludesInput, ProductUpdateWithoutProductExcludesInput>, ProductUncheckedUpdateWithoutProductExcludesInput>
  }

  export type UserCreateNestedOneWithoutProductOrdersInput = {
    create?: XOR<UserCreateWithoutProductOrdersInput, UserUncheckedCreateWithoutProductOrdersInput>
    connectOrCreate?: UserCreateOrConnectWithoutProductOrdersInput
    connect?: UserWhereUniqueInput
  }

  export type ProductCreateNestedOneWithoutProductOrdersInput = {
    create?: XOR<ProductCreateWithoutProductOrdersInput, ProductUncheckedCreateWithoutProductOrdersInput>
    connectOrCreate?: ProductCreateOrConnectWithoutProductOrdersInput
    connect?: ProductWhereUniqueInput
  }

  export type ProductVariationCreateNestedOneWithoutProductOrdersInput = {
    create?: XOR<ProductVariationCreateWithoutProductOrdersInput, ProductVariationUncheckedCreateWithoutProductOrdersInput>
    connectOrCreate?: ProductVariationCreateOrConnectWithoutProductOrdersInput
    connect?: ProductVariationWhereUniqueInput
  }

  export type UserUpdateOneRequiredWithoutProductOrdersNestedInput = {
    create?: XOR<UserCreateWithoutProductOrdersInput, UserUncheckedCreateWithoutProductOrdersInput>
    connectOrCreate?: UserCreateOrConnectWithoutProductOrdersInput
    upsert?: UserUpsertWithoutProductOrdersInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutProductOrdersInput, UserUpdateWithoutProductOrdersInput>, UserUncheckedUpdateWithoutProductOrdersInput>
  }

  export type ProductUpdateOneRequiredWithoutProductOrdersNestedInput = {
    create?: XOR<ProductCreateWithoutProductOrdersInput, ProductUncheckedCreateWithoutProductOrdersInput>
    connectOrCreate?: ProductCreateOrConnectWithoutProductOrdersInput
    upsert?: ProductUpsertWithoutProductOrdersInput
    connect?: ProductWhereUniqueInput
    update?: XOR<XOR<ProductUpdateToOneWithWhereWithoutProductOrdersInput, ProductUpdateWithoutProductOrdersInput>, ProductUncheckedUpdateWithoutProductOrdersInput>
  }

  export type ProductVariationUpdateOneWithoutProductOrdersNestedInput = {
    create?: XOR<ProductVariationCreateWithoutProductOrdersInput, ProductVariationUncheckedCreateWithoutProductOrdersInput>
    connectOrCreate?: ProductVariationCreateOrConnectWithoutProductOrdersInput
    upsert?: ProductVariationUpsertWithoutProductOrdersInput
    disconnect?: ProductVariationWhereInput | boolean
    delete?: ProductVariationWhereInput | boolean
    connect?: ProductVariationWhereUniqueInput
    update?: XOR<XOR<ProductVariationUpdateToOneWithWhereWithoutProductOrdersInput, ProductVariationUpdateWithoutProductOrdersInput>, ProductVariationUncheckedUpdateWithoutProductOrdersInput>
  }

  export type HotelCreateNestedManyWithoutVendorInput = {
    create?: XOR<HotelCreateWithoutVendorInput, HotelUncheckedCreateWithoutVendorInput> | HotelCreateWithoutVendorInput[] | HotelUncheckedCreateWithoutVendorInput[]
    connectOrCreate?: HotelCreateOrConnectWithoutVendorInput | HotelCreateOrConnectWithoutVendorInput[]
    createMany?: HotelCreateManyVendorInputEnvelope
    connect?: HotelWhereUniqueInput | HotelWhereUniqueInput[]
  }

  export type MitraPackageCreateNestedManyWithoutVendorInput = {
    create?: XOR<MitraPackageCreateWithoutVendorInput, MitraPackageUncheckedCreateWithoutVendorInput> | MitraPackageCreateWithoutVendorInput[] | MitraPackageUncheckedCreateWithoutVendorInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutVendorInput | MitraPackageCreateOrConnectWithoutVendorInput[]
    createMany?: MitraPackageCreateManyVendorInputEnvelope
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
  }

  export type HotelUncheckedCreateNestedManyWithoutVendorInput = {
    create?: XOR<HotelCreateWithoutVendorInput, HotelUncheckedCreateWithoutVendorInput> | HotelCreateWithoutVendorInput[] | HotelUncheckedCreateWithoutVendorInput[]
    connectOrCreate?: HotelCreateOrConnectWithoutVendorInput | HotelCreateOrConnectWithoutVendorInput[]
    createMany?: HotelCreateManyVendorInputEnvelope
    connect?: HotelWhereUniqueInput | HotelWhereUniqueInput[]
  }

  export type MitraPackageUncheckedCreateNestedManyWithoutVendorInput = {
    create?: XOR<MitraPackageCreateWithoutVendorInput, MitraPackageUncheckedCreateWithoutVendorInput> | MitraPackageCreateWithoutVendorInput[] | MitraPackageUncheckedCreateWithoutVendorInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutVendorInput | MitraPackageCreateOrConnectWithoutVendorInput[]
    createMany?: MitraPackageCreateManyVendorInputEnvelope
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
  }

  export type HotelUpdateManyWithoutVendorNestedInput = {
    create?: XOR<HotelCreateWithoutVendorInput, HotelUncheckedCreateWithoutVendorInput> | HotelCreateWithoutVendorInput[] | HotelUncheckedCreateWithoutVendorInput[]
    connectOrCreate?: HotelCreateOrConnectWithoutVendorInput | HotelCreateOrConnectWithoutVendorInput[]
    upsert?: HotelUpsertWithWhereUniqueWithoutVendorInput | HotelUpsertWithWhereUniqueWithoutVendorInput[]
    createMany?: HotelCreateManyVendorInputEnvelope
    set?: HotelWhereUniqueInput | HotelWhereUniqueInput[]
    disconnect?: HotelWhereUniqueInput | HotelWhereUniqueInput[]
    delete?: HotelWhereUniqueInput | HotelWhereUniqueInput[]
    connect?: HotelWhereUniqueInput | HotelWhereUniqueInput[]
    update?: HotelUpdateWithWhereUniqueWithoutVendorInput | HotelUpdateWithWhereUniqueWithoutVendorInput[]
    updateMany?: HotelUpdateManyWithWhereWithoutVendorInput | HotelUpdateManyWithWhereWithoutVendorInput[]
    deleteMany?: HotelScalarWhereInput | HotelScalarWhereInput[]
  }

  export type MitraPackageUpdateManyWithoutVendorNestedInput = {
    create?: XOR<MitraPackageCreateWithoutVendorInput, MitraPackageUncheckedCreateWithoutVendorInput> | MitraPackageCreateWithoutVendorInput[] | MitraPackageUncheckedCreateWithoutVendorInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutVendorInput | MitraPackageCreateOrConnectWithoutVendorInput[]
    upsert?: MitraPackageUpsertWithWhereUniqueWithoutVendorInput | MitraPackageUpsertWithWhereUniqueWithoutVendorInput[]
    createMany?: MitraPackageCreateManyVendorInputEnvelope
    set?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    disconnect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    delete?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    update?: MitraPackageUpdateWithWhereUniqueWithoutVendorInput | MitraPackageUpdateWithWhereUniqueWithoutVendorInput[]
    updateMany?: MitraPackageUpdateManyWithWhereWithoutVendorInput | MitraPackageUpdateManyWithWhereWithoutVendorInput[]
    deleteMany?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
  }

  export type HotelUncheckedUpdateManyWithoutVendorNestedInput = {
    create?: XOR<HotelCreateWithoutVendorInput, HotelUncheckedCreateWithoutVendorInput> | HotelCreateWithoutVendorInput[] | HotelUncheckedCreateWithoutVendorInput[]
    connectOrCreate?: HotelCreateOrConnectWithoutVendorInput | HotelCreateOrConnectWithoutVendorInput[]
    upsert?: HotelUpsertWithWhereUniqueWithoutVendorInput | HotelUpsertWithWhereUniqueWithoutVendorInput[]
    createMany?: HotelCreateManyVendorInputEnvelope
    set?: HotelWhereUniqueInput | HotelWhereUniqueInput[]
    disconnect?: HotelWhereUniqueInput | HotelWhereUniqueInput[]
    delete?: HotelWhereUniqueInput | HotelWhereUniqueInput[]
    connect?: HotelWhereUniqueInput | HotelWhereUniqueInput[]
    update?: HotelUpdateWithWhereUniqueWithoutVendorInput | HotelUpdateWithWhereUniqueWithoutVendorInput[]
    updateMany?: HotelUpdateManyWithWhereWithoutVendorInput | HotelUpdateManyWithWhereWithoutVendorInput[]
    deleteMany?: HotelScalarWhereInput | HotelScalarWhereInput[]
  }

  export type MitraPackageUncheckedUpdateManyWithoutVendorNestedInput = {
    create?: XOR<MitraPackageCreateWithoutVendorInput, MitraPackageUncheckedCreateWithoutVendorInput> | MitraPackageCreateWithoutVendorInput[] | MitraPackageUncheckedCreateWithoutVendorInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutVendorInput | MitraPackageCreateOrConnectWithoutVendorInput[]
    upsert?: MitraPackageUpsertWithWhereUniqueWithoutVendorInput | MitraPackageUpsertWithWhereUniqueWithoutVendorInput[]
    createMany?: MitraPackageCreateManyVendorInputEnvelope
    set?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    disconnect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    delete?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    update?: MitraPackageUpdateWithWhereUniqueWithoutVendorInput | MitraPackageUpdateWithWhereUniqueWithoutVendorInput[]
    updateMany?: MitraPackageUpdateManyWithWhereWithoutVendorInput | MitraPackageUpdateManyWithWhereWithoutVendorInput[]
    deleteMany?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
  }

  export type VendorCreateNestedOneWithoutHotelsInput = {
    create?: XOR<VendorCreateWithoutHotelsInput, VendorUncheckedCreateWithoutHotelsInput>
    connectOrCreate?: VendorCreateOrConnectWithoutHotelsInput
    connect?: VendorWhereUniqueInput
  }

  export type HotelPeriodPriceCreateNestedManyWithoutHotelInput = {
    create?: XOR<HotelPeriodPriceCreateWithoutHotelInput, HotelPeriodPriceUncheckedCreateWithoutHotelInput> | HotelPeriodPriceCreateWithoutHotelInput[] | HotelPeriodPriceUncheckedCreateWithoutHotelInput[]
    connectOrCreate?: HotelPeriodPriceCreateOrConnectWithoutHotelInput | HotelPeriodPriceCreateOrConnectWithoutHotelInput[]
    createMany?: HotelPeriodPriceCreateManyHotelInputEnvelope
    connect?: HotelPeriodPriceWhereUniqueInput | HotelPeriodPriceWhereUniqueInput[]
  }

  export type MitraPackageCreateNestedManyWithoutHotelMekkahInput = {
    create?: XOR<MitraPackageCreateWithoutHotelMekkahInput, MitraPackageUncheckedCreateWithoutHotelMekkahInput> | MitraPackageCreateWithoutHotelMekkahInput[] | MitraPackageUncheckedCreateWithoutHotelMekkahInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutHotelMekkahInput | MitraPackageCreateOrConnectWithoutHotelMekkahInput[]
    createMany?: MitraPackageCreateManyHotelMekkahInputEnvelope
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
  }

  export type MitraPackageCreateNestedManyWithoutHotelMadinahInput = {
    create?: XOR<MitraPackageCreateWithoutHotelMadinahInput, MitraPackageUncheckedCreateWithoutHotelMadinahInput> | MitraPackageCreateWithoutHotelMadinahInput[] | MitraPackageUncheckedCreateWithoutHotelMadinahInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutHotelMadinahInput | MitraPackageCreateOrConnectWithoutHotelMadinahInput[]
    createMany?: MitraPackageCreateManyHotelMadinahInputEnvelope
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
  }

  export type HotelPeriodPriceUncheckedCreateNestedManyWithoutHotelInput = {
    create?: XOR<HotelPeriodPriceCreateWithoutHotelInput, HotelPeriodPriceUncheckedCreateWithoutHotelInput> | HotelPeriodPriceCreateWithoutHotelInput[] | HotelPeriodPriceUncheckedCreateWithoutHotelInput[]
    connectOrCreate?: HotelPeriodPriceCreateOrConnectWithoutHotelInput | HotelPeriodPriceCreateOrConnectWithoutHotelInput[]
    createMany?: HotelPeriodPriceCreateManyHotelInputEnvelope
    connect?: HotelPeriodPriceWhereUniqueInput | HotelPeriodPriceWhereUniqueInput[]
  }

  export type MitraPackageUncheckedCreateNestedManyWithoutHotelMekkahInput = {
    create?: XOR<MitraPackageCreateWithoutHotelMekkahInput, MitraPackageUncheckedCreateWithoutHotelMekkahInput> | MitraPackageCreateWithoutHotelMekkahInput[] | MitraPackageUncheckedCreateWithoutHotelMekkahInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutHotelMekkahInput | MitraPackageCreateOrConnectWithoutHotelMekkahInput[]
    createMany?: MitraPackageCreateManyHotelMekkahInputEnvelope
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
  }

  export type MitraPackageUncheckedCreateNestedManyWithoutHotelMadinahInput = {
    create?: XOR<MitraPackageCreateWithoutHotelMadinahInput, MitraPackageUncheckedCreateWithoutHotelMadinahInput> | MitraPackageCreateWithoutHotelMadinahInput[] | MitraPackageUncheckedCreateWithoutHotelMadinahInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutHotelMadinahInput | MitraPackageCreateOrConnectWithoutHotelMadinahInput[]
    createMany?: MitraPackageCreateManyHotelMadinahInputEnvelope
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
  }

  export type EnumCityFieldUpdateOperationsInput = {
    set?: $Enums.City
  }

  export type VendorUpdateOneRequiredWithoutHotelsNestedInput = {
    create?: XOR<VendorCreateWithoutHotelsInput, VendorUncheckedCreateWithoutHotelsInput>
    connectOrCreate?: VendorCreateOrConnectWithoutHotelsInput
    upsert?: VendorUpsertWithoutHotelsInput
    connect?: VendorWhereUniqueInput
    update?: XOR<XOR<VendorUpdateToOneWithWhereWithoutHotelsInput, VendorUpdateWithoutHotelsInput>, VendorUncheckedUpdateWithoutHotelsInput>
  }

  export type HotelPeriodPriceUpdateManyWithoutHotelNestedInput = {
    create?: XOR<HotelPeriodPriceCreateWithoutHotelInput, HotelPeriodPriceUncheckedCreateWithoutHotelInput> | HotelPeriodPriceCreateWithoutHotelInput[] | HotelPeriodPriceUncheckedCreateWithoutHotelInput[]
    connectOrCreate?: HotelPeriodPriceCreateOrConnectWithoutHotelInput | HotelPeriodPriceCreateOrConnectWithoutHotelInput[]
    upsert?: HotelPeriodPriceUpsertWithWhereUniqueWithoutHotelInput | HotelPeriodPriceUpsertWithWhereUniqueWithoutHotelInput[]
    createMany?: HotelPeriodPriceCreateManyHotelInputEnvelope
    set?: HotelPeriodPriceWhereUniqueInput | HotelPeriodPriceWhereUniqueInput[]
    disconnect?: HotelPeriodPriceWhereUniqueInput | HotelPeriodPriceWhereUniqueInput[]
    delete?: HotelPeriodPriceWhereUniqueInput | HotelPeriodPriceWhereUniqueInput[]
    connect?: HotelPeriodPriceWhereUniqueInput | HotelPeriodPriceWhereUniqueInput[]
    update?: HotelPeriodPriceUpdateWithWhereUniqueWithoutHotelInput | HotelPeriodPriceUpdateWithWhereUniqueWithoutHotelInput[]
    updateMany?: HotelPeriodPriceUpdateManyWithWhereWithoutHotelInput | HotelPeriodPriceUpdateManyWithWhereWithoutHotelInput[]
    deleteMany?: HotelPeriodPriceScalarWhereInput | HotelPeriodPriceScalarWhereInput[]
  }

  export type MitraPackageUpdateManyWithoutHotelMekkahNestedInput = {
    create?: XOR<MitraPackageCreateWithoutHotelMekkahInput, MitraPackageUncheckedCreateWithoutHotelMekkahInput> | MitraPackageCreateWithoutHotelMekkahInput[] | MitraPackageUncheckedCreateWithoutHotelMekkahInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutHotelMekkahInput | MitraPackageCreateOrConnectWithoutHotelMekkahInput[]
    upsert?: MitraPackageUpsertWithWhereUniqueWithoutHotelMekkahInput | MitraPackageUpsertWithWhereUniqueWithoutHotelMekkahInput[]
    createMany?: MitraPackageCreateManyHotelMekkahInputEnvelope
    set?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    disconnect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    delete?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    update?: MitraPackageUpdateWithWhereUniqueWithoutHotelMekkahInput | MitraPackageUpdateWithWhereUniqueWithoutHotelMekkahInput[]
    updateMany?: MitraPackageUpdateManyWithWhereWithoutHotelMekkahInput | MitraPackageUpdateManyWithWhereWithoutHotelMekkahInput[]
    deleteMany?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
  }

  export type MitraPackageUpdateManyWithoutHotelMadinahNestedInput = {
    create?: XOR<MitraPackageCreateWithoutHotelMadinahInput, MitraPackageUncheckedCreateWithoutHotelMadinahInput> | MitraPackageCreateWithoutHotelMadinahInput[] | MitraPackageUncheckedCreateWithoutHotelMadinahInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutHotelMadinahInput | MitraPackageCreateOrConnectWithoutHotelMadinahInput[]
    upsert?: MitraPackageUpsertWithWhereUniqueWithoutHotelMadinahInput | MitraPackageUpsertWithWhereUniqueWithoutHotelMadinahInput[]
    createMany?: MitraPackageCreateManyHotelMadinahInputEnvelope
    set?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    disconnect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    delete?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    update?: MitraPackageUpdateWithWhereUniqueWithoutHotelMadinahInput | MitraPackageUpdateWithWhereUniqueWithoutHotelMadinahInput[]
    updateMany?: MitraPackageUpdateManyWithWhereWithoutHotelMadinahInput | MitraPackageUpdateManyWithWhereWithoutHotelMadinahInput[]
    deleteMany?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
  }

  export type HotelPeriodPriceUncheckedUpdateManyWithoutHotelNestedInput = {
    create?: XOR<HotelPeriodPriceCreateWithoutHotelInput, HotelPeriodPriceUncheckedCreateWithoutHotelInput> | HotelPeriodPriceCreateWithoutHotelInput[] | HotelPeriodPriceUncheckedCreateWithoutHotelInput[]
    connectOrCreate?: HotelPeriodPriceCreateOrConnectWithoutHotelInput | HotelPeriodPriceCreateOrConnectWithoutHotelInput[]
    upsert?: HotelPeriodPriceUpsertWithWhereUniqueWithoutHotelInput | HotelPeriodPriceUpsertWithWhereUniqueWithoutHotelInput[]
    createMany?: HotelPeriodPriceCreateManyHotelInputEnvelope
    set?: HotelPeriodPriceWhereUniqueInput | HotelPeriodPriceWhereUniqueInput[]
    disconnect?: HotelPeriodPriceWhereUniqueInput | HotelPeriodPriceWhereUniqueInput[]
    delete?: HotelPeriodPriceWhereUniqueInput | HotelPeriodPriceWhereUniqueInput[]
    connect?: HotelPeriodPriceWhereUniqueInput | HotelPeriodPriceWhereUniqueInput[]
    update?: HotelPeriodPriceUpdateWithWhereUniqueWithoutHotelInput | HotelPeriodPriceUpdateWithWhereUniqueWithoutHotelInput[]
    updateMany?: HotelPeriodPriceUpdateManyWithWhereWithoutHotelInput | HotelPeriodPriceUpdateManyWithWhereWithoutHotelInput[]
    deleteMany?: HotelPeriodPriceScalarWhereInput | HotelPeriodPriceScalarWhereInput[]
  }

  export type MitraPackageUncheckedUpdateManyWithoutHotelMekkahNestedInput = {
    create?: XOR<MitraPackageCreateWithoutHotelMekkahInput, MitraPackageUncheckedCreateWithoutHotelMekkahInput> | MitraPackageCreateWithoutHotelMekkahInput[] | MitraPackageUncheckedCreateWithoutHotelMekkahInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutHotelMekkahInput | MitraPackageCreateOrConnectWithoutHotelMekkahInput[]
    upsert?: MitraPackageUpsertWithWhereUniqueWithoutHotelMekkahInput | MitraPackageUpsertWithWhereUniqueWithoutHotelMekkahInput[]
    createMany?: MitraPackageCreateManyHotelMekkahInputEnvelope
    set?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    disconnect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    delete?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    update?: MitraPackageUpdateWithWhereUniqueWithoutHotelMekkahInput | MitraPackageUpdateWithWhereUniqueWithoutHotelMekkahInput[]
    updateMany?: MitraPackageUpdateManyWithWhereWithoutHotelMekkahInput | MitraPackageUpdateManyWithWhereWithoutHotelMekkahInput[]
    deleteMany?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
  }

  export type MitraPackageUncheckedUpdateManyWithoutHotelMadinahNestedInput = {
    create?: XOR<MitraPackageCreateWithoutHotelMadinahInput, MitraPackageUncheckedCreateWithoutHotelMadinahInput> | MitraPackageCreateWithoutHotelMadinahInput[] | MitraPackageUncheckedCreateWithoutHotelMadinahInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutHotelMadinahInput | MitraPackageCreateOrConnectWithoutHotelMadinahInput[]
    upsert?: MitraPackageUpsertWithWhereUniqueWithoutHotelMadinahInput | MitraPackageUpsertWithWhereUniqueWithoutHotelMadinahInput[]
    createMany?: MitraPackageCreateManyHotelMadinahInputEnvelope
    set?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    disconnect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    delete?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    update?: MitraPackageUpdateWithWhereUniqueWithoutHotelMadinahInput | MitraPackageUpdateWithWhereUniqueWithoutHotelMadinahInput[]
    updateMany?: MitraPackageUpdateManyWithWhereWithoutHotelMadinahInput | MitraPackageUpdateManyWithWhereWithoutHotelMadinahInput[]
    deleteMany?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
  }

  export type HotelPeriodPriceCreateNestedManyWithoutPeriodInput = {
    create?: XOR<HotelPeriodPriceCreateWithoutPeriodInput, HotelPeriodPriceUncheckedCreateWithoutPeriodInput> | HotelPeriodPriceCreateWithoutPeriodInput[] | HotelPeriodPriceUncheckedCreateWithoutPeriodInput[]
    connectOrCreate?: HotelPeriodPriceCreateOrConnectWithoutPeriodInput | HotelPeriodPriceCreateOrConnectWithoutPeriodInput[]
    createMany?: HotelPeriodPriceCreateManyPeriodInputEnvelope
    connect?: HotelPeriodPriceWhereUniqueInput | HotelPeriodPriceWhereUniqueInput[]
  }

  export type MitraPackageCreateNestedManyWithoutPeriodInput = {
    create?: XOR<MitraPackageCreateWithoutPeriodInput, MitraPackageUncheckedCreateWithoutPeriodInput> | MitraPackageCreateWithoutPeriodInput[] | MitraPackageUncheckedCreateWithoutPeriodInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutPeriodInput | MitraPackageCreateOrConnectWithoutPeriodInput[]
    createMany?: MitraPackageCreateManyPeriodInputEnvelope
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
  }

  export type HotelPeriodPriceUncheckedCreateNestedManyWithoutPeriodInput = {
    create?: XOR<HotelPeriodPriceCreateWithoutPeriodInput, HotelPeriodPriceUncheckedCreateWithoutPeriodInput> | HotelPeriodPriceCreateWithoutPeriodInput[] | HotelPeriodPriceUncheckedCreateWithoutPeriodInput[]
    connectOrCreate?: HotelPeriodPriceCreateOrConnectWithoutPeriodInput | HotelPeriodPriceCreateOrConnectWithoutPeriodInput[]
    createMany?: HotelPeriodPriceCreateManyPeriodInputEnvelope
    connect?: HotelPeriodPriceWhereUniqueInput | HotelPeriodPriceWhereUniqueInput[]
  }

  export type MitraPackageUncheckedCreateNestedManyWithoutPeriodInput = {
    create?: XOR<MitraPackageCreateWithoutPeriodInput, MitraPackageUncheckedCreateWithoutPeriodInput> | MitraPackageCreateWithoutPeriodInput[] | MitraPackageUncheckedCreateWithoutPeriodInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutPeriodInput | MitraPackageCreateOrConnectWithoutPeriodInput[]
    createMany?: MitraPackageCreateManyPeriodInputEnvelope
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
  }

  export type EnumPeriodCategoryFieldUpdateOperationsInput = {
    set?: $Enums.PeriodCategory
  }

  export type HotelPeriodPriceUpdateManyWithoutPeriodNestedInput = {
    create?: XOR<HotelPeriodPriceCreateWithoutPeriodInput, HotelPeriodPriceUncheckedCreateWithoutPeriodInput> | HotelPeriodPriceCreateWithoutPeriodInput[] | HotelPeriodPriceUncheckedCreateWithoutPeriodInput[]
    connectOrCreate?: HotelPeriodPriceCreateOrConnectWithoutPeriodInput | HotelPeriodPriceCreateOrConnectWithoutPeriodInput[]
    upsert?: HotelPeriodPriceUpsertWithWhereUniqueWithoutPeriodInput | HotelPeriodPriceUpsertWithWhereUniqueWithoutPeriodInput[]
    createMany?: HotelPeriodPriceCreateManyPeriodInputEnvelope
    set?: HotelPeriodPriceWhereUniqueInput | HotelPeriodPriceWhereUniqueInput[]
    disconnect?: HotelPeriodPriceWhereUniqueInput | HotelPeriodPriceWhereUniqueInput[]
    delete?: HotelPeriodPriceWhereUniqueInput | HotelPeriodPriceWhereUniqueInput[]
    connect?: HotelPeriodPriceWhereUniqueInput | HotelPeriodPriceWhereUniqueInput[]
    update?: HotelPeriodPriceUpdateWithWhereUniqueWithoutPeriodInput | HotelPeriodPriceUpdateWithWhereUniqueWithoutPeriodInput[]
    updateMany?: HotelPeriodPriceUpdateManyWithWhereWithoutPeriodInput | HotelPeriodPriceUpdateManyWithWhereWithoutPeriodInput[]
    deleteMany?: HotelPeriodPriceScalarWhereInput | HotelPeriodPriceScalarWhereInput[]
  }

  export type MitraPackageUpdateManyWithoutPeriodNestedInput = {
    create?: XOR<MitraPackageCreateWithoutPeriodInput, MitraPackageUncheckedCreateWithoutPeriodInput> | MitraPackageCreateWithoutPeriodInput[] | MitraPackageUncheckedCreateWithoutPeriodInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutPeriodInput | MitraPackageCreateOrConnectWithoutPeriodInput[]
    upsert?: MitraPackageUpsertWithWhereUniqueWithoutPeriodInput | MitraPackageUpsertWithWhereUniqueWithoutPeriodInput[]
    createMany?: MitraPackageCreateManyPeriodInputEnvelope
    set?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    disconnect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    delete?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    update?: MitraPackageUpdateWithWhereUniqueWithoutPeriodInput | MitraPackageUpdateWithWhereUniqueWithoutPeriodInput[]
    updateMany?: MitraPackageUpdateManyWithWhereWithoutPeriodInput | MitraPackageUpdateManyWithWhereWithoutPeriodInput[]
    deleteMany?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
  }

  export type HotelPeriodPriceUncheckedUpdateManyWithoutPeriodNestedInput = {
    create?: XOR<HotelPeriodPriceCreateWithoutPeriodInput, HotelPeriodPriceUncheckedCreateWithoutPeriodInput> | HotelPeriodPriceCreateWithoutPeriodInput[] | HotelPeriodPriceUncheckedCreateWithoutPeriodInput[]
    connectOrCreate?: HotelPeriodPriceCreateOrConnectWithoutPeriodInput | HotelPeriodPriceCreateOrConnectWithoutPeriodInput[]
    upsert?: HotelPeriodPriceUpsertWithWhereUniqueWithoutPeriodInput | HotelPeriodPriceUpsertWithWhereUniqueWithoutPeriodInput[]
    createMany?: HotelPeriodPriceCreateManyPeriodInputEnvelope
    set?: HotelPeriodPriceWhereUniqueInput | HotelPeriodPriceWhereUniqueInput[]
    disconnect?: HotelPeriodPriceWhereUniqueInput | HotelPeriodPriceWhereUniqueInput[]
    delete?: HotelPeriodPriceWhereUniqueInput | HotelPeriodPriceWhereUniqueInput[]
    connect?: HotelPeriodPriceWhereUniqueInput | HotelPeriodPriceWhereUniqueInput[]
    update?: HotelPeriodPriceUpdateWithWhereUniqueWithoutPeriodInput | HotelPeriodPriceUpdateWithWhereUniqueWithoutPeriodInput[]
    updateMany?: HotelPeriodPriceUpdateManyWithWhereWithoutPeriodInput | HotelPeriodPriceUpdateManyWithWhereWithoutPeriodInput[]
    deleteMany?: HotelPeriodPriceScalarWhereInput | HotelPeriodPriceScalarWhereInput[]
  }

  export type MitraPackageUncheckedUpdateManyWithoutPeriodNestedInput = {
    create?: XOR<MitraPackageCreateWithoutPeriodInput, MitraPackageUncheckedCreateWithoutPeriodInput> | MitraPackageCreateWithoutPeriodInput[] | MitraPackageUncheckedCreateWithoutPeriodInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutPeriodInput | MitraPackageCreateOrConnectWithoutPeriodInput[]
    upsert?: MitraPackageUpsertWithWhereUniqueWithoutPeriodInput | MitraPackageUpsertWithWhereUniqueWithoutPeriodInput[]
    createMany?: MitraPackageCreateManyPeriodInputEnvelope
    set?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    disconnect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    delete?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    update?: MitraPackageUpdateWithWhereUniqueWithoutPeriodInput | MitraPackageUpdateWithWhereUniqueWithoutPeriodInput[]
    updateMany?: MitraPackageUpdateManyWithWhereWithoutPeriodInput | MitraPackageUpdateManyWithWhereWithoutPeriodInput[]
    deleteMany?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
  }

  export type HotelCreateNestedOneWithoutHotelPeriodPricesInput = {
    create?: XOR<HotelCreateWithoutHotelPeriodPricesInput, HotelUncheckedCreateWithoutHotelPeriodPricesInput>
    connectOrCreate?: HotelCreateOrConnectWithoutHotelPeriodPricesInput
    connect?: HotelWhereUniqueInput
  }

  export type PeriodCreateNestedOneWithoutHotelPeriodPricesInput = {
    create?: XOR<PeriodCreateWithoutHotelPeriodPricesInput, PeriodUncheckedCreateWithoutHotelPeriodPricesInput>
    connectOrCreate?: PeriodCreateOrConnectWithoutHotelPeriodPricesInput
    connect?: PeriodWhereUniqueInput
  }

  export type HotelUpdateOneRequiredWithoutHotelPeriodPricesNestedInput = {
    create?: XOR<HotelCreateWithoutHotelPeriodPricesInput, HotelUncheckedCreateWithoutHotelPeriodPricesInput>
    connectOrCreate?: HotelCreateOrConnectWithoutHotelPeriodPricesInput
    upsert?: HotelUpsertWithoutHotelPeriodPricesInput
    connect?: HotelWhereUniqueInput
    update?: XOR<XOR<HotelUpdateToOneWithWhereWithoutHotelPeriodPricesInput, HotelUpdateWithoutHotelPeriodPricesInput>, HotelUncheckedUpdateWithoutHotelPeriodPricesInput>
  }

  export type PeriodUpdateOneRequiredWithoutHotelPeriodPricesNestedInput = {
    create?: XOR<PeriodCreateWithoutHotelPeriodPricesInput, PeriodUncheckedCreateWithoutHotelPeriodPricesInput>
    connectOrCreate?: PeriodCreateOrConnectWithoutHotelPeriodPricesInput
    upsert?: PeriodUpsertWithoutHotelPeriodPricesInput
    connect?: PeriodWhereUniqueInput
    update?: XOR<XOR<PeriodUpdateToOneWithWhereWithoutHotelPeriodPricesInput, PeriodUpdateWithoutHotelPeriodPricesInput>, PeriodUncheckedUpdateWithoutHotelPeriodPricesInput>
  }

  export type MitraPackageCreateNestedManyWithoutAirlineInput = {
    create?: XOR<MitraPackageCreateWithoutAirlineInput, MitraPackageUncheckedCreateWithoutAirlineInput> | MitraPackageCreateWithoutAirlineInput[] | MitraPackageUncheckedCreateWithoutAirlineInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutAirlineInput | MitraPackageCreateOrConnectWithoutAirlineInput[]
    createMany?: MitraPackageCreateManyAirlineInputEnvelope
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
  }

  export type MitraPackageUncheckedCreateNestedManyWithoutAirlineInput = {
    create?: XOR<MitraPackageCreateWithoutAirlineInput, MitraPackageUncheckedCreateWithoutAirlineInput> | MitraPackageCreateWithoutAirlineInput[] | MitraPackageUncheckedCreateWithoutAirlineInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutAirlineInput | MitraPackageCreateOrConnectWithoutAirlineInput[]
    createMany?: MitraPackageCreateManyAirlineInputEnvelope
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
  }

  export type MitraPackageUpdateManyWithoutAirlineNestedInput = {
    create?: XOR<MitraPackageCreateWithoutAirlineInput, MitraPackageUncheckedCreateWithoutAirlineInput> | MitraPackageCreateWithoutAirlineInput[] | MitraPackageUncheckedCreateWithoutAirlineInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutAirlineInput | MitraPackageCreateOrConnectWithoutAirlineInput[]
    upsert?: MitraPackageUpsertWithWhereUniqueWithoutAirlineInput | MitraPackageUpsertWithWhereUniqueWithoutAirlineInput[]
    createMany?: MitraPackageCreateManyAirlineInputEnvelope
    set?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    disconnect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    delete?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    update?: MitraPackageUpdateWithWhereUniqueWithoutAirlineInput | MitraPackageUpdateWithWhereUniqueWithoutAirlineInput[]
    updateMany?: MitraPackageUpdateManyWithWhereWithoutAirlineInput | MitraPackageUpdateManyWithWhereWithoutAirlineInput[]
    deleteMany?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
  }

  export type MitraPackageUncheckedUpdateManyWithoutAirlineNestedInput = {
    create?: XOR<MitraPackageCreateWithoutAirlineInput, MitraPackageUncheckedCreateWithoutAirlineInput> | MitraPackageCreateWithoutAirlineInput[] | MitraPackageUncheckedCreateWithoutAirlineInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutAirlineInput | MitraPackageCreateOrConnectWithoutAirlineInput[]
    upsert?: MitraPackageUpsertWithWhereUniqueWithoutAirlineInput | MitraPackageUpsertWithWhereUniqueWithoutAirlineInput[]
    createMany?: MitraPackageCreateManyAirlineInputEnvelope
    set?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    disconnect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    delete?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    update?: MitraPackageUpdateWithWhereUniqueWithoutAirlineInput | MitraPackageUpdateWithWhereUniqueWithoutAirlineInput[]
    updateMany?: MitraPackageUpdateManyWithWhereWithoutAirlineInput | MitraPackageUpdateManyWithWhereWithoutAirlineInput[]
    deleteMany?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
  }

  export type MitraPackageCreateNestedManyWithoutVisaInput = {
    create?: XOR<MitraPackageCreateWithoutVisaInput, MitraPackageUncheckedCreateWithoutVisaInput> | MitraPackageCreateWithoutVisaInput[] | MitraPackageUncheckedCreateWithoutVisaInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutVisaInput | MitraPackageCreateOrConnectWithoutVisaInput[]
    createMany?: MitraPackageCreateManyVisaInputEnvelope
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
  }

  export type MitraPackageUncheckedCreateNestedManyWithoutVisaInput = {
    create?: XOR<MitraPackageCreateWithoutVisaInput, MitraPackageUncheckedCreateWithoutVisaInput> | MitraPackageCreateWithoutVisaInput[] | MitraPackageUncheckedCreateWithoutVisaInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutVisaInput | MitraPackageCreateOrConnectWithoutVisaInput[]
    createMany?: MitraPackageCreateManyVisaInputEnvelope
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
  }

  export type MitraPackageUpdateManyWithoutVisaNestedInput = {
    create?: XOR<MitraPackageCreateWithoutVisaInput, MitraPackageUncheckedCreateWithoutVisaInput> | MitraPackageCreateWithoutVisaInput[] | MitraPackageUncheckedCreateWithoutVisaInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutVisaInput | MitraPackageCreateOrConnectWithoutVisaInput[]
    upsert?: MitraPackageUpsertWithWhereUniqueWithoutVisaInput | MitraPackageUpsertWithWhereUniqueWithoutVisaInput[]
    createMany?: MitraPackageCreateManyVisaInputEnvelope
    set?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    disconnect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    delete?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    update?: MitraPackageUpdateWithWhereUniqueWithoutVisaInput | MitraPackageUpdateWithWhereUniqueWithoutVisaInput[]
    updateMany?: MitraPackageUpdateManyWithWhereWithoutVisaInput | MitraPackageUpdateManyWithWhereWithoutVisaInput[]
    deleteMany?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
  }

  export type MitraPackageUncheckedUpdateManyWithoutVisaNestedInput = {
    create?: XOR<MitraPackageCreateWithoutVisaInput, MitraPackageUncheckedCreateWithoutVisaInput> | MitraPackageCreateWithoutVisaInput[] | MitraPackageUncheckedCreateWithoutVisaInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutVisaInput | MitraPackageCreateOrConnectWithoutVisaInput[]
    upsert?: MitraPackageUpsertWithWhereUniqueWithoutVisaInput | MitraPackageUpsertWithWhereUniqueWithoutVisaInput[]
    createMany?: MitraPackageCreateManyVisaInputEnvelope
    set?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    disconnect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    delete?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    update?: MitraPackageUpdateWithWhereUniqueWithoutVisaInput | MitraPackageUpdateWithWhereUniqueWithoutVisaInput[]
    updateMany?: MitraPackageUpdateManyWithWhereWithoutVisaInput | MitraPackageUpdateManyWithWhereWithoutVisaInput[]
    deleteMany?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
  }

  export type MitraPackageCreateNestedManyWithoutTransportationInput = {
    create?: XOR<MitraPackageCreateWithoutTransportationInput, MitraPackageUncheckedCreateWithoutTransportationInput> | MitraPackageCreateWithoutTransportationInput[] | MitraPackageUncheckedCreateWithoutTransportationInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutTransportationInput | MitraPackageCreateOrConnectWithoutTransportationInput[]
    createMany?: MitraPackageCreateManyTransportationInputEnvelope
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
  }

  export type MitraPackageUncheckedCreateNestedManyWithoutTransportationInput = {
    create?: XOR<MitraPackageCreateWithoutTransportationInput, MitraPackageUncheckedCreateWithoutTransportationInput> | MitraPackageCreateWithoutTransportationInput[] | MitraPackageUncheckedCreateWithoutTransportationInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutTransportationInput | MitraPackageCreateOrConnectWithoutTransportationInput[]
    createMany?: MitraPackageCreateManyTransportationInputEnvelope
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
  }

  export type MitraPackageUpdateManyWithoutTransportationNestedInput = {
    create?: XOR<MitraPackageCreateWithoutTransportationInput, MitraPackageUncheckedCreateWithoutTransportationInput> | MitraPackageCreateWithoutTransportationInput[] | MitraPackageUncheckedCreateWithoutTransportationInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutTransportationInput | MitraPackageCreateOrConnectWithoutTransportationInput[]
    upsert?: MitraPackageUpsertWithWhereUniqueWithoutTransportationInput | MitraPackageUpsertWithWhereUniqueWithoutTransportationInput[]
    createMany?: MitraPackageCreateManyTransportationInputEnvelope
    set?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    disconnect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    delete?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    update?: MitraPackageUpdateWithWhereUniqueWithoutTransportationInput | MitraPackageUpdateWithWhereUniqueWithoutTransportationInput[]
    updateMany?: MitraPackageUpdateManyWithWhereWithoutTransportationInput | MitraPackageUpdateManyWithWhereWithoutTransportationInput[]
    deleteMany?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
  }

  export type MitraPackageUncheckedUpdateManyWithoutTransportationNestedInput = {
    create?: XOR<MitraPackageCreateWithoutTransportationInput, MitraPackageUncheckedCreateWithoutTransportationInput> | MitraPackageCreateWithoutTransportationInput[] | MitraPackageUncheckedCreateWithoutTransportationInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutTransportationInput | MitraPackageCreateOrConnectWithoutTransportationInput[]
    upsert?: MitraPackageUpsertWithWhereUniqueWithoutTransportationInput | MitraPackageUpsertWithWhereUniqueWithoutTransportationInput[]
    createMany?: MitraPackageCreateManyTransportationInputEnvelope
    set?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    disconnect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    delete?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    update?: MitraPackageUpdateWithWhereUniqueWithoutTransportationInput | MitraPackageUpdateWithWhereUniqueWithoutTransportationInput[]
    updateMany?: MitraPackageUpdateManyWithWhereWithoutTransportationInput | MitraPackageUpdateManyWithWhereWithoutTransportationInput[]
    deleteMany?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
  }

  export type MitraPackageCreateNestedManyWithoutMuthawifInput = {
    create?: XOR<MitraPackageCreateWithoutMuthawifInput, MitraPackageUncheckedCreateWithoutMuthawifInput> | MitraPackageCreateWithoutMuthawifInput[] | MitraPackageUncheckedCreateWithoutMuthawifInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutMuthawifInput | MitraPackageCreateOrConnectWithoutMuthawifInput[]
    createMany?: MitraPackageCreateManyMuthawifInputEnvelope
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
  }

  export type MitraPackageUncheckedCreateNestedManyWithoutMuthawifInput = {
    create?: XOR<MitraPackageCreateWithoutMuthawifInput, MitraPackageUncheckedCreateWithoutMuthawifInput> | MitraPackageCreateWithoutMuthawifInput[] | MitraPackageUncheckedCreateWithoutMuthawifInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutMuthawifInput | MitraPackageCreateOrConnectWithoutMuthawifInput[]
    createMany?: MitraPackageCreateManyMuthawifInputEnvelope
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
  }

  export type MitraPackageUpdateManyWithoutMuthawifNestedInput = {
    create?: XOR<MitraPackageCreateWithoutMuthawifInput, MitraPackageUncheckedCreateWithoutMuthawifInput> | MitraPackageCreateWithoutMuthawifInput[] | MitraPackageUncheckedCreateWithoutMuthawifInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutMuthawifInput | MitraPackageCreateOrConnectWithoutMuthawifInput[]
    upsert?: MitraPackageUpsertWithWhereUniqueWithoutMuthawifInput | MitraPackageUpsertWithWhereUniqueWithoutMuthawifInput[]
    createMany?: MitraPackageCreateManyMuthawifInputEnvelope
    set?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    disconnect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    delete?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    update?: MitraPackageUpdateWithWhereUniqueWithoutMuthawifInput | MitraPackageUpdateWithWhereUniqueWithoutMuthawifInput[]
    updateMany?: MitraPackageUpdateManyWithWhereWithoutMuthawifInput | MitraPackageUpdateManyWithWhereWithoutMuthawifInput[]
    deleteMany?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
  }

  export type MitraPackageUncheckedUpdateManyWithoutMuthawifNestedInput = {
    create?: XOR<MitraPackageCreateWithoutMuthawifInput, MitraPackageUncheckedCreateWithoutMuthawifInput> | MitraPackageCreateWithoutMuthawifInput[] | MitraPackageUncheckedCreateWithoutMuthawifInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutMuthawifInput | MitraPackageCreateOrConnectWithoutMuthawifInput[]
    upsert?: MitraPackageUpsertWithWhereUniqueWithoutMuthawifInput | MitraPackageUpsertWithWhereUniqueWithoutMuthawifInput[]
    createMany?: MitraPackageCreateManyMuthawifInputEnvelope
    set?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    disconnect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    delete?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    update?: MitraPackageUpdateWithWhereUniqueWithoutMuthawifInput | MitraPackageUpdateWithWhereUniqueWithoutMuthawifInput[]
    updateMany?: MitraPackageUpdateManyWithWhereWithoutMuthawifInput | MitraPackageUpdateManyWithWhereWithoutMuthawifInput[]
    deleteMany?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
  }

  export type MitraPackageCreateNestedManyWithoutHandlingSaudiInput = {
    create?: XOR<MitraPackageCreateWithoutHandlingSaudiInput, MitraPackageUncheckedCreateWithoutHandlingSaudiInput> | MitraPackageCreateWithoutHandlingSaudiInput[] | MitraPackageUncheckedCreateWithoutHandlingSaudiInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutHandlingSaudiInput | MitraPackageCreateOrConnectWithoutHandlingSaudiInput[]
    createMany?: MitraPackageCreateManyHandlingSaudiInputEnvelope
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
  }

  export type MitraPackageUncheckedCreateNestedManyWithoutHandlingSaudiInput = {
    create?: XOR<MitraPackageCreateWithoutHandlingSaudiInput, MitraPackageUncheckedCreateWithoutHandlingSaudiInput> | MitraPackageCreateWithoutHandlingSaudiInput[] | MitraPackageUncheckedCreateWithoutHandlingSaudiInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutHandlingSaudiInput | MitraPackageCreateOrConnectWithoutHandlingSaudiInput[]
    createMany?: MitraPackageCreateManyHandlingSaudiInputEnvelope
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
  }

  export type MitraPackageUpdateManyWithoutHandlingSaudiNestedInput = {
    create?: XOR<MitraPackageCreateWithoutHandlingSaudiInput, MitraPackageUncheckedCreateWithoutHandlingSaudiInput> | MitraPackageCreateWithoutHandlingSaudiInput[] | MitraPackageUncheckedCreateWithoutHandlingSaudiInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutHandlingSaudiInput | MitraPackageCreateOrConnectWithoutHandlingSaudiInput[]
    upsert?: MitraPackageUpsertWithWhereUniqueWithoutHandlingSaudiInput | MitraPackageUpsertWithWhereUniqueWithoutHandlingSaudiInput[]
    createMany?: MitraPackageCreateManyHandlingSaudiInputEnvelope
    set?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    disconnect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    delete?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    update?: MitraPackageUpdateWithWhereUniqueWithoutHandlingSaudiInput | MitraPackageUpdateWithWhereUniqueWithoutHandlingSaudiInput[]
    updateMany?: MitraPackageUpdateManyWithWhereWithoutHandlingSaudiInput | MitraPackageUpdateManyWithWhereWithoutHandlingSaudiInput[]
    deleteMany?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
  }

  export type MitraPackageUncheckedUpdateManyWithoutHandlingSaudiNestedInput = {
    create?: XOR<MitraPackageCreateWithoutHandlingSaudiInput, MitraPackageUncheckedCreateWithoutHandlingSaudiInput> | MitraPackageCreateWithoutHandlingSaudiInput[] | MitraPackageUncheckedCreateWithoutHandlingSaudiInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutHandlingSaudiInput | MitraPackageCreateOrConnectWithoutHandlingSaudiInput[]
    upsert?: MitraPackageUpsertWithWhereUniqueWithoutHandlingSaudiInput | MitraPackageUpsertWithWhereUniqueWithoutHandlingSaudiInput[]
    createMany?: MitraPackageCreateManyHandlingSaudiInputEnvelope
    set?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    disconnect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    delete?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    update?: MitraPackageUpdateWithWhereUniqueWithoutHandlingSaudiInput | MitraPackageUpdateWithWhereUniqueWithoutHandlingSaudiInput[]
    updateMany?: MitraPackageUpdateManyWithWhereWithoutHandlingSaudiInput | MitraPackageUpdateManyWithWhereWithoutHandlingSaudiInput[]
    deleteMany?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
  }

  export type MitraPackageCreateNestedManyWithoutHandlingDomesticInput = {
    create?: XOR<MitraPackageCreateWithoutHandlingDomesticInput, MitraPackageUncheckedCreateWithoutHandlingDomesticInput> | MitraPackageCreateWithoutHandlingDomesticInput[] | MitraPackageUncheckedCreateWithoutHandlingDomesticInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutHandlingDomesticInput | MitraPackageCreateOrConnectWithoutHandlingDomesticInput[]
    createMany?: MitraPackageCreateManyHandlingDomesticInputEnvelope
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
  }

  export type MitraPackageUncheckedCreateNestedManyWithoutHandlingDomesticInput = {
    create?: XOR<MitraPackageCreateWithoutHandlingDomesticInput, MitraPackageUncheckedCreateWithoutHandlingDomesticInput> | MitraPackageCreateWithoutHandlingDomesticInput[] | MitraPackageUncheckedCreateWithoutHandlingDomesticInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutHandlingDomesticInput | MitraPackageCreateOrConnectWithoutHandlingDomesticInput[]
    createMany?: MitraPackageCreateManyHandlingDomesticInputEnvelope
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
  }

  export type MitraPackageUpdateManyWithoutHandlingDomesticNestedInput = {
    create?: XOR<MitraPackageCreateWithoutHandlingDomesticInput, MitraPackageUncheckedCreateWithoutHandlingDomesticInput> | MitraPackageCreateWithoutHandlingDomesticInput[] | MitraPackageUncheckedCreateWithoutHandlingDomesticInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutHandlingDomesticInput | MitraPackageCreateOrConnectWithoutHandlingDomesticInput[]
    upsert?: MitraPackageUpsertWithWhereUniqueWithoutHandlingDomesticInput | MitraPackageUpsertWithWhereUniqueWithoutHandlingDomesticInput[]
    createMany?: MitraPackageCreateManyHandlingDomesticInputEnvelope
    set?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    disconnect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    delete?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    update?: MitraPackageUpdateWithWhereUniqueWithoutHandlingDomesticInput | MitraPackageUpdateWithWhereUniqueWithoutHandlingDomesticInput[]
    updateMany?: MitraPackageUpdateManyWithWhereWithoutHandlingDomesticInput | MitraPackageUpdateManyWithWhereWithoutHandlingDomesticInput[]
    deleteMany?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
  }

  export type MitraPackageUncheckedUpdateManyWithoutHandlingDomesticNestedInput = {
    create?: XOR<MitraPackageCreateWithoutHandlingDomesticInput, MitraPackageUncheckedCreateWithoutHandlingDomesticInput> | MitraPackageCreateWithoutHandlingDomesticInput[] | MitraPackageUncheckedCreateWithoutHandlingDomesticInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutHandlingDomesticInput | MitraPackageCreateOrConnectWithoutHandlingDomesticInput[]
    upsert?: MitraPackageUpsertWithWhereUniqueWithoutHandlingDomesticInput | MitraPackageUpsertWithWhereUniqueWithoutHandlingDomesticInput[]
    createMany?: MitraPackageCreateManyHandlingDomesticInputEnvelope
    set?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    disconnect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    delete?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    update?: MitraPackageUpdateWithWhereUniqueWithoutHandlingDomesticInput | MitraPackageUpdateWithWhereUniqueWithoutHandlingDomesticInput[]
    updateMany?: MitraPackageUpdateManyWithWhereWithoutHandlingDomesticInput | MitraPackageUpdateManyWithWhereWithoutHandlingDomesticInput[]
    deleteMany?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
  }

  export type MitraPackageCreateNestedManyWithoutSiskopatuhInput = {
    create?: XOR<MitraPackageCreateWithoutSiskopatuhInput, MitraPackageUncheckedCreateWithoutSiskopatuhInput> | MitraPackageCreateWithoutSiskopatuhInput[] | MitraPackageUncheckedCreateWithoutSiskopatuhInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutSiskopatuhInput | MitraPackageCreateOrConnectWithoutSiskopatuhInput[]
    createMany?: MitraPackageCreateManySiskopatuhInputEnvelope
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
  }

  export type MitraPackageUncheckedCreateNestedManyWithoutSiskopatuhInput = {
    create?: XOR<MitraPackageCreateWithoutSiskopatuhInput, MitraPackageUncheckedCreateWithoutSiskopatuhInput> | MitraPackageCreateWithoutSiskopatuhInput[] | MitraPackageUncheckedCreateWithoutSiskopatuhInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutSiskopatuhInput | MitraPackageCreateOrConnectWithoutSiskopatuhInput[]
    createMany?: MitraPackageCreateManySiskopatuhInputEnvelope
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
  }

  export type MitraPackageUpdateManyWithoutSiskopatuhNestedInput = {
    create?: XOR<MitraPackageCreateWithoutSiskopatuhInput, MitraPackageUncheckedCreateWithoutSiskopatuhInput> | MitraPackageCreateWithoutSiskopatuhInput[] | MitraPackageUncheckedCreateWithoutSiskopatuhInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutSiskopatuhInput | MitraPackageCreateOrConnectWithoutSiskopatuhInput[]
    upsert?: MitraPackageUpsertWithWhereUniqueWithoutSiskopatuhInput | MitraPackageUpsertWithWhereUniqueWithoutSiskopatuhInput[]
    createMany?: MitraPackageCreateManySiskopatuhInputEnvelope
    set?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    disconnect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    delete?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    update?: MitraPackageUpdateWithWhereUniqueWithoutSiskopatuhInput | MitraPackageUpdateWithWhereUniqueWithoutSiskopatuhInput[]
    updateMany?: MitraPackageUpdateManyWithWhereWithoutSiskopatuhInput | MitraPackageUpdateManyWithWhereWithoutSiskopatuhInput[]
    deleteMany?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
  }

  export type MitraPackageUncheckedUpdateManyWithoutSiskopatuhNestedInput = {
    create?: XOR<MitraPackageCreateWithoutSiskopatuhInput, MitraPackageUncheckedCreateWithoutSiskopatuhInput> | MitraPackageCreateWithoutSiskopatuhInput[] | MitraPackageUncheckedCreateWithoutSiskopatuhInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutSiskopatuhInput | MitraPackageCreateOrConnectWithoutSiskopatuhInput[]
    upsert?: MitraPackageUpsertWithWhereUniqueWithoutSiskopatuhInput | MitraPackageUpsertWithWhereUniqueWithoutSiskopatuhInput[]
    createMany?: MitraPackageCreateManySiskopatuhInputEnvelope
    set?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    disconnect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    delete?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    update?: MitraPackageUpdateWithWhereUniqueWithoutSiskopatuhInput | MitraPackageUpdateWithWhereUniqueWithoutSiskopatuhInput[]
    updateMany?: MitraPackageUpdateManyWithWhereWithoutSiskopatuhInput | MitraPackageUpdateManyWithWhereWithoutSiskopatuhInput[]
    deleteMany?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
  }

  export type MitraPackageCreateNestedManyWithoutEquipmentInput = {
    create?: XOR<MitraPackageCreateWithoutEquipmentInput, MitraPackageUncheckedCreateWithoutEquipmentInput> | MitraPackageCreateWithoutEquipmentInput[] | MitraPackageUncheckedCreateWithoutEquipmentInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutEquipmentInput | MitraPackageCreateOrConnectWithoutEquipmentInput[]
    createMany?: MitraPackageCreateManyEquipmentInputEnvelope
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
  }

  export type MitraPackageUncheckedCreateNestedManyWithoutEquipmentInput = {
    create?: XOR<MitraPackageCreateWithoutEquipmentInput, MitraPackageUncheckedCreateWithoutEquipmentInput> | MitraPackageCreateWithoutEquipmentInput[] | MitraPackageUncheckedCreateWithoutEquipmentInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutEquipmentInput | MitraPackageCreateOrConnectWithoutEquipmentInput[]
    createMany?: MitraPackageCreateManyEquipmentInputEnvelope
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
  }

  export type MitraPackageUpdateManyWithoutEquipmentNestedInput = {
    create?: XOR<MitraPackageCreateWithoutEquipmentInput, MitraPackageUncheckedCreateWithoutEquipmentInput> | MitraPackageCreateWithoutEquipmentInput[] | MitraPackageUncheckedCreateWithoutEquipmentInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutEquipmentInput | MitraPackageCreateOrConnectWithoutEquipmentInput[]
    upsert?: MitraPackageUpsertWithWhereUniqueWithoutEquipmentInput | MitraPackageUpsertWithWhereUniqueWithoutEquipmentInput[]
    createMany?: MitraPackageCreateManyEquipmentInputEnvelope
    set?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    disconnect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    delete?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    update?: MitraPackageUpdateWithWhereUniqueWithoutEquipmentInput | MitraPackageUpdateWithWhereUniqueWithoutEquipmentInput[]
    updateMany?: MitraPackageUpdateManyWithWhereWithoutEquipmentInput | MitraPackageUpdateManyWithWhereWithoutEquipmentInput[]
    deleteMany?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
  }

  export type MitraPackageUncheckedUpdateManyWithoutEquipmentNestedInput = {
    create?: XOR<MitraPackageCreateWithoutEquipmentInput, MitraPackageUncheckedCreateWithoutEquipmentInput> | MitraPackageCreateWithoutEquipmentInput[] | MitraPackageUncheckedCreateWithoutEquipmentInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutEquipmentInput | MitraPackageCreateOrConnectWithoutEquipmentInput[]
    upsert?: MitraPackageUpsertWithWhereUniqueWithoutEquipmentInput | MitraPackageUpsertWithWhereUniqueWithoutEquipmentInput[]
    createMany?: MitraPackageCreateManyEquipmentInputEnvelope
    set?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    disconnect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    delete?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    update?: MitraPackageUpdateWithWhereUniqueWithoutEquipmentInput | MitraPackageUpdateWithWhereUniqueWithoutEquipmentInput[]
    updateMany?: MitraPackageUpdateManyWithWhereWithoutEquipmentInput | MitraPackageUpdateManyWithWhereWithoutEquipmentInput[]
    deleteMany?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
  }

  export type MitraPackageCreateNestedManyWithoutTourPlusInput = {
    create?: XOR<MitraPackageCreateWithoutTourPlusInput, MitraPackageUncheckedCreateWithoutTourPlusInput> | MitraPackageCreateWithoutTourPlusInput[] | MitraPackageUncheckedCreateWithoutTourPlusInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutTourPlusInput | MitraPackageCreateOrConnectWithoutTourPlusInput[]
    createMany?: MitraPackageCreateManyTourPlusInputEnvelope
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
  }

  export type MitraPackageUncheckedCreateNestedManyWithoutTourPlusInput = {
    create?: XOR<MitraPackageCreateWithoutTourPlusInput, MitraPackageUncheckedCreateWithoutTourPlusInput> | MitraPackageCreateWithoutTourPlusInput[] | MitraPackageUncheckedCreateWithoutTourPlusInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutTourPlusInput | MitraPackageCreateOrConnectWithoutTourPlusInput[]
    createMany?: MitraPackageCreateManyTourPlusInputEnvelope
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
  }

  export type MitraPackageUpdateManyWithoutTourPlusNestedInput = {
    create?: XOR<MitraPackageCreateWithoutTourPlusInput, MitraPackageUncheckedCreateWithoutTourPlusInput> | MitraPackageCreateWithoutTourPlusInput[] | MitraPackageUncheckedCreateWithoutTourPlusInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutTourPlusInput | MitraPackageCreateOrConnectWithoutTourPlusInput[]
    upsert?: MitraPackageUpsertWithWhereUniqueWithoutTourPlusInput | MitraPackageUpsertWithWhereUniqueWithoutTourPlusInput[]
    createMany?: MitraPackageCreateManyTourPlusInputEnvelope
    set?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    disconnect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    delete?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    update?: MitraPackageUpdateWithWhereUniqueWithoutTourPlusInput | MitraPackageUpdateWithWhereUniqueWithoutTourPlusInput[]
    updateMany?: MitraPackageUpdateManyWithWhereWithoutTourPlusInput | MitraPackageUpdateManyWithWhereWithoutTourPlusInput[]
    deleteMany?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
  }

  export type MitraPackageUncheckedUpdateManyWithoutTourPlusNestedInput = {
    create?: XOR<MitraPackageCreateWithoutTourPlusInput, MitraPackageUncheckedCreateWithoutTourPlusInput> | MitraPackageCreateWithoutTourPlusInput[] | MitraPackageUncheckedCreateWithoutTourPlusInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutTourPlusInput | MitraPackageCreateOrConnectWithoutTourPlusInput[]
    upsert?: MitraPackageUpsertWithWhereUniqueWithoutTourPlusInput | MitraPackageUpsertWithWhereUniqueWithoutTourPlusInput[]
    createMany?: MitraPackageCreateManyTourPlusInputEnvelope
    set?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    disconnect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    delete?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    update?: MitraPackageUpdateWithWhereUniqueWithoutTourPlusInput | MitraPackageUpdateWithWhereUniqueWithoutTourPlusInput[]
    updateMany?: MitraPackageUpdateManyWithWhereWithoutTourPlusInput | MitraPackageUpdateManyWithWhereWithoutTourPlusInput[]
    deleteMany?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
  }

  export type MitraPackageCreateNestedManyWithoutManasikInput = {
    create?: XOR<MitraPackageCreateWithoutManasikInput, MitraPackageUncheckedCreateWithoutManasikInput> | MitraPackageCreateWithoutManasikInput[] | MitraPackageUncheckedCreateWithoutManasikInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutManasikInput | MitraPackageCreateOrConnectWithoutManasikInput[]
    createMany?: MitraPackageCreateManyManasikInputEnvelope
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
  }

  export type MitraPackageUncheckedCreateNestedManyWithoutManasikInput = {
    create?: XOR<MitraPackageCreateWithoutManasikInput, MitraPackageUncheckedCreateWithoutManasikInput> | MitraPackageCreateWithoutManasikInput[] | MitraPackageUncheckedCreateWithoutManasikInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutManasikInput | MitraPackageCreateOrConnectWithoutManasikInput[]
    createMany?: MitraPackageCreateManyManasikInputEnvelope
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
  }

  export type MitraPackageUpdateManyWithoutManasikNestedInput = {
    create?: XOR<MitraPackageCreateWithoutManasikInput, MitraPackageUncheckedCreateWithoutManasikInput> | MitraPackageCreateWithoutManasikInput[] | MitraPackageUncheckedCreateWithoutManasikInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutManasikInput | MitraPackageCreateOrConnectWithoutManasikInput[]
    upsert?: MitraPackageUpsertWithWhereUniqueWithoutManasikInput | MitraPackageUpsertWithWhereUniqueWithoutManasikInput[]
    createMany?: MitraPackageCreateManyManasikInputEnvelope
    set?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    disconnect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    delete?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    update?: MitraPackageUpdateWithWhereUniqueWithoutManasikInput | MitraPackageUpdateWithWhereUniqueWithoutManasikInput[]
    updateMany?: MitraPackageUpdateManyWithWhereWithoutManasikInput | MitraPackageUpdateManyWithWhereWithoutManasikInput[]
    deleteMany?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
  }

  export type MitraPackageUncheckedUpdateManyWithoutManasikNestedInput = {
    create?: XOR<MitraPackageCreateWithoutManasikInput, MitraPackageUncheckedCreateWithoutManasikInput> | MitraPackageCreateWithoutManasikInput[] | MitraPackageUncheckedCreateWithoutManasikInput[]
    connectOrCreate?: MitraPackageCreateOrConnectWithoutManasikInput | MitraPackageCreateOrConnectWithoutManasikInput[]
    upsert?: MitraPackageUpsertWithWhereUniqueWithoutManasikInput | MitraPackageUpsertWithWhereUniqueWithoutManasikInput[]
    createMany?: MitraPackageCreateManyManasikInputEnvelope
    set?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    disconnect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    delete?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    connect?: MitraPackageWhereUniqueInput | MitraPackageWhereUniqueInput[]
    update?: MitraPackageUpdateWithWhereUniqueWithoutManasikInput | MitraPackageUpdateWithWhereUniqueWithoutManasikInput[]
    updateMany?: MitraPackageUpdateManyWithWhereWithoutManasikInput | MitraPackageUpdateManyWithWhereWithoutManasikInput[]
    deleteMany?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
  }

  export type MitraPackageOrderCreateNestedManyWithoutMitraPackageInput = {
    create?: XOR<MitraPackageOrderCreateWithoutMitraPackageInput, MitraPackageOrderUncheckedCreateWithoutMitraPackageInput> | MitraPackageOrderCreateWithoutMitraPackageInput[] | MitraPackageOrderUncheckedCreateWithoutMitraPackageInput[]
    connectOrCreate?: MitraPackageOrderCreateOrConnectWithoutMitraPackageInput | MitraPackageOrderCreateOrConnectWithoutMitraPackageInput[]
    createMany?: MitraPackageOrderCreateManyMitraPackageInputEnvelope
    connect?: MitraPackageOrderWhereUniqueInput | MitraPackageOrderWhereUniqueInput[]
  }

  export type PeriodCreateNestedOneWithoutMitraPackagesInput = {
    create?: XOR<PeriodCreateWithoutMitraPackagesInput, PeriodUncheckedCreateWithoutMitraPackagesInput>
    connectOrCreate?: PeriodCreateOrConnectWithoutMitraPackagesInput
    connect?: PeriodWhereUniqueInput
  }

  export type AirlineCreateNestedOneWithoutMitraPackagesInput = {
    create?: XOR<AirlineCreateWithoutMitraPackagesInput, AirlineUncheckedCreateWithoutMitraPackagesInput>
    connectOrCreate?: AirlineCreateOrConnectWithoutMitraPackagesInput
    connect?: AirlineWhereUniqueInput
  }

  export type VendorCreateNestedOneWithoutMitraPackagesInput = {
    create?: XOR<VendorCreateWithoutMitraPackagesInput, VendorUncheckedCreateWithoutMitraPackagesInput>
    connectOrCreate?: VendorCreateOrConnectWithoutMitraPackagesInput
    connect?: VendorWhereUniqueInput
  }

  export type HotelCreateNestedOneWithoutMitraPackagesMekkahInput = {
    create?: XOR<HotelCreateWithoutMitraPackagesMekkahInput, HotelUncheckedCreateWithoutMitraPackagesMekkahInput>
    connectOrCreate?: HotelCreateOrConnectWithoutMitraPackagesMekkahInput
    connect?: HotelWhereUniqueInput
  }

  export type HotelCreateNestedOneWithoutMitraPackagesMadinahInput = {
    create?: XOR<HotelCreateWithoutMitraPackagesMadinahInput, HotelUncheckedCreateWithoutMitraPackagesMadinahInput>
    connectOrCreate?: HotelCreateOrConnectWithoutMitraPackagesMadinahInput
    connect?: HotelWhereUniqueInput
  }

  export type VisaCreateNestedOneWithoutMitraPackagesInput = {
    create?: XOR<VisaCreateWithoutMitraPackagesInput, VisaUncheckedCreateWithoutMitraPackagesInput>
    connectOrCreate?: VisaCreateOrConnectWithoutMitraPackagesInput
    connect?: VisaWhereUniqueInput
  }

  export type TransportationCreateNestedOneWithoutMitraPackageInput = {
    create?: XOR<TransportationCreateWithoutMitraPackageInput, TransportationUncheckedCreateWithoutMitraPackageInput>
    connectOrCreate?: TransportationCreateOrConnectWithoutMitraPackageInput
    connect?: TransportationWhereUniqueInput
  }

  export type MuthawifCreateNestedOneWithoutMitraPackagesInput = {
    create?: XOR<MuthawifCreateWithoutMitraPackagesInput, MuthawifUncheckedCreateWithoutMitraPackagesInput>
    connectOrCreate?: MuthawifCreateOrConnectWithoutMitraPackagesInput
    connect?: MuthawifWhereUniqueInput
  }

  export type HandlingSaudiCreateNestedOneWithoutMitraPackagesInput = {
    create?: XOR<HandlingSaudiCreateWithoutMitraPackagesInput, HandlingSaudiUncheckedCreateWithoutMitraPackagesInput>
    connectOrCreate?: HandlingSaudiCreateOrConnectWithoutMitraPackagesInput
    connect?: HandlingSaudiWhereUniqueInput
  }

  export type HandlingDomesticCreateNestedOneWithoutMitraPackagesInput = {
    create?: XOR<HandlingDomesticCreateWithoutMitraPackagesInput, HandlingDomesticUncheckedCreateWithoutMitraPackagesInput>
    connectOrCreate?: HandlingDomesticCreateOrConnectWithoutMitraPackagesInput
    connect?: HandlingDomesticWhereUniqueInput
  }

  export type SiskopatuhCreateNestedOneWithoutMitraPackagesInput = {
    create?: XOR<SiskopatuhCreateWithoutMitraPackagesInput, SiskopatuhUncheckedCreateWithoutMitraPackagesInput>
    connectOrCreate?: SiskopatuhCreateOrConnectWithoutMitraPackagesInput
    connect?: SiskopatuhWhereUniqueInput
  }

  export type EquipmentCreateNestedOneWithoutMitraPackagesInput = {
    create?: XOR<EquipmentCreateWithoutMitraPackagesInput, EquipmentUncheckedCreateWithoutMitraPackagesInput>
    connectOrCreate?: EquipmentCreateOrConnectWithoutMitraPackagesInput
    connect?: EquipmentWhereUniqueInput
  }

  export type TourPlusCreateNestedOneWithoutMitraPackagesInput = {
    create?: XOR<TourPlusCreateWithoutMitraPackagesInput, TourPlusUncheckedCreateWithoutMitraPackagesInput>
    connectOrCreate?: TourPlusCreateOrConnectWithoutMitraPackagesInput
    connect?: TourPlusWhereUniqueInput
  }

  export type ManasikCreateNestedOneWithoutMitraPackagesInput = {
    create?: XOR<ManasikCreateWithoutMitraPackagesInput, ManasikUncheckedCreateWithoutMitraPackagesInput>
    connectOrCreate?: ManasikCreateOrConnectWithoutMitraPackagesInput
    connect?: ManasikWhereUniqueInput
  }

  export type MitraPackageOrderUncheckedCreateNestedManyWithoutMitraPackageInput = {
    create?: XOR<MitraPackageOrderCreateWithoutMitraPackageInput, MitraPackageOrderUncheckedCreateWithoutMitraPackageInput> | MitraPackageOrderCreateWithoutMitraPackageInput[] | MitraPackageOrderUncheckedCreateWithoutMitraPackageInput[]
    connectOrCreate?: MitraPackageOrderCreateOrConnectWithoutMitraPackageInput | MitraPackageOrderCreateOrConnectWithoutMitraPackageInput[]
    createMany?: MitraPackageOrderCreateManyMitraPackageInputEnvelope
    connect?: MitraPackageOrderWhereUniqueInput | MitraPackageOrderWhereUniqueInput[]
  }

  export type MitraPackageOrderUpdateManyWithoutMitraPackageNestedInput = {
    create?: XOR<MitraPackageOrderCreateWithoutMitraPackageInput, MitraPackageOrderUncheckedCreateWithoutMitraPackageInput> | MitraPackageOrderCreateWithoutMitraPackageInput[] | MitraPackageOrderUncheckedCreateWithoutMitraPackageInput[]
    connectOrCreate?: MitraPackageOrderCreateOrConnectWithoutMitraPackageInput | MitraPackageOrderCreateOrConnectWithoutMitraPackageInput[]
    upsert?: MitraPackageOrderUpsertWithWhereUniqueWithoutMitraPackageInput | MitraPackageOrderUpsertWithWhereUniqueWithoutMitraPackageInput[]
    createMany?: MitraPackageOrderCreateManyMitraPackageInputEnvelope
    set?: MitraPackageOrderWhereUniqueInput | MitraPackageOrderWhereUniqueInput[]
    disconnect?: MitraPackageOrderWhereUniqueInput | MitraPackageOrderWhereUniqueInput[]
    delete?: MitraPackageOrderWhereUniqueInput | MitraPackageOrderWhereUniqueInput[]
    connect?: MitraPackageOrderWhereUniqueInput | MitraPackageOrderWhereUniqueInput[]
    update?: MitraPackageOrderUpdateWithWhereUniqueWithoutMitraPackageInput | MitraPackageOrderUpdateWithWhereUniqueWithoutMitraPackageInput[]
    updateMany?: MitraPackageOrderUpdateManyWithWhereWithoutMitraPackageInput | MitraPackageOrderUpdateManyWithWhereWithoutMitraPackageInput[]
    deleteMany?: MitraPackageOrderScalarWhereInput | MitraPackageOrderScalarWhereInput[]
  }

  export type PeriodUpdateOneWithoutMitraPackagesNestedInput = {
    create?: XOR<PeriodCreateWithoutMitraPackagesInput, PeriodUncheckedCreateWithoutMitraPackagesInput>
    connectOrCreate?: PeriodCreateOrConnectWithoutMitraPackagesInput
    upsert?: PeriodUpsertWithoutMitraPackagesInput
    disconnect?: PeriodWhereInput | boolean
    delete?: PeriodWhereInput | boolean
    connect?: PeriodWhereUniqueInput
    update?: XOR<XOR<PeriodUpdateToOneWithWhereWithoutMitraPackagesInput, PeriodUpdateWithoutMitraPackagesInput>, PeriodUncheckedUpdateWithoutMitraPackagesInput>
  }

  export type AirlineUpdateOneWithoutMitraPackagesNestedInput = {
    create?: XOR<AirlineCreateWithoutMitraPackagesInput, AirlineUncheckedCreateWithoutMitraPackagesInput>
    connectOrCreate?: AirlineCreateOrConnectWithoutMitraPackagesInput
    upsert?: AirlineUpsertWithoutMitraPackagesInput
    disconnect?: AirlineWhereInput | boolean
    delete?: AirlineWhereInput | boolean
    connect?: AirlineWhereUniqueInput
    update?: XOR<XOR<AirlineUpdateToOneWithWhereWithoutMitraPackagesInput, AirlineUpdateWithoutMitraPackagesInput>, AirlineUncheckedUpdateWithoutMitraPackagesInput>
  }

  export type VendorUpdateOneWithoutMitraPackagesNestedInput = {
    create?: XOR<VendorCreateWithoutMitraPackagesInput, VendorUncheckedCreateWithoutMitraPackagesInput>
    connectOrCreate?: VendorCreateOrConnectWithoutMitraPackagesInput
    upsert?: VendorUpsertWithoutMitraPackagesInput
    disconnect?: VendorWhereInput | boolean
    delete?: VendorWhereInput | boolean
    connect?: VendorWhereUniqueInput
    update?: XOR<XOR<VendorUpdateToOneWithWhereWithoutMitraPackagesInput, VendorUpdateWithoutMitraPackagesInput>, VendorUncheckedUpdateWithoutMitraPackagesInput>
  }

  export type HotelUpdateOneWithoutMitraPackagesMekkahNestedInput = {
    create?: XOR<HotelCreateWithoutMitraPackagesMekkahInput, HotelUncheckedCreateWithoutMitraPackagesMekkahInput>
    connectOrCreate?: HotelCreateOrConnectWithoutMitraPackagesMekkahInput
    upsert?: HotelUpsertWithoutMitraPackagesMekkahInput
    disconnect?: HotelWhereInput | boolean
    delete?: HotelWhereInput | boolean
    connect?: HotelWhereUniqueInput
    update?: XOR<XOR<HotelUpdateToOneWithWhereWithoutMitraPackagesMekkahInput, HotelUpdateWithoutMitraPackagesMekkahInput>, HotelUncheckedUpdateWithoutMitraPackagesMekkahInput>
  }

  export type HotelUpdateOneWithoutMitraPackagesMadinahNestedInput = {
    create?: XOR<HotelCreateWithoutMitraPackagesMadinahInput, HotelUncheckedCreateWithoutMitraPackagesMadinahInput>
    connectOrCreate?: HotelCreateOrConnectWithoutMitraPackagesMadinahInput
    upsert?: HotelUpsertWithoutMitraPackagesMadinahInput
    disconnect?: HotelWhereInput | boolean
    delete?: HotelWhereInput | boolean
    connect?: HotelWhereUniqueInput
    update?: XOR<XOR<HotelUpdateToOneWithWhereWithoutMitraPackagesMadinahInput, HotelUpdateWithoutMitraPackagesMadinahInput>, HotelUncheckedUpdateWithoutMitraPackagesMadinahInput>
  }

  export type VisaUpdateOneWithoutMitraPackagesNestedInput = {
    create?: XOR<VisaCreateWithoutMitraPackagesInput, VisaUncheckedCreateWithoutMitraPackagesInput>
    connectOrCreate?: VisaCreateOrConnectWithoutMitraPackagesInput
    upsert?: VisaUpsertWithoutMitraPackagesInput
    disconnect?: VisaWhereInput | boolean
    delete?: VisaWhereInput | boolean
    connect?: VisaWhereUniqueInput
    update?: XOR<XOR<VisaUpdateToOneWithWhereWithoutMitraPackagesInput, VisaUpdateWithoutMitraPackagesInput>, VisaUncheckedUpdateWithoutMitraPackagesInput>
  }

  export type TransportationUpdateOneWithoutMitraPackageNestedInput = {
    create?: XOR<TransportationCreateWithoutMitraPackageInput, TransportationUncheckedCreateWithoutMitraPackageInput>
    connectOrCreate?: TransportationCreateOrConnectWithoutMitraPackageInput
    upsert?: TransportationUpsertWithoutMitraPackageInput
    disconnect?: TransportationWhereInput | boolean
    delete?: TransportationWhereInput | boolean
    connect?: TransportationWhereUniqueInput
    update?: XOR<XOR<TransportationUpdateToOneWithWhereWithoutMitraPackageInput, TransportationUpdateWithoutMitraPackageInput>, TransportationUncheckedUpdateWithoutMitraPackageInput>
  }

  export type MuthawifUpdateOneWithoutMitraPackagesNestedInput = {
    create?: XOR<MuthawifCreateWithoutMitraPackagesInput, MuthawifUncheckedCreateWithoutMitraPackagesInput>
    connectOrCreate?: MuthawifCreateOrConnectWithoutMitraPackagesInput
    upsert?: MuthawifUpsertWithoutMitraPackagesInput
    disconnect?: MuthawifWhereInput | boolean
    delete?: MuthawifWhereInput | boolean
    connect?: MuthawifWhereUniqueInput
    update?: XOR<XOR<MuthawifUpdateToOneWithWhereWithoutMitraPackagesInput, MuthawifUpdateWithoutMitraPackagesInput>, MuthawifUncheckedUpdateWithoutMitraPackagesInput>
  }

  export type HandlingSaudiUpdateOneWithoutMitraPackagesNestedInput = {
    create?: XOR<HandlingSaudiCreateWithoutMitraPackagesInput, HandlingSaudiUncheckedCreateWithoutMitraPackagesInput>
    connectOrCreate?: HandlingSaudiCreateOrConnectWithoutMitraPackagesInput
    upsert?: HandlingSaudiUpsertWithoutMitraPackagesInput
    disconnect?: HandlingSaudiWhereInput | boolean
    delete?: HandlingSaudiWhereInput | boolean
    connect?: HandlingSaudiWhereUniqueInput
    update?: XOR<XOR<HandlingSaudiUpdateToOneWithWhereWithoutMitraPackagesInput, HandlingSaudiUpdateWithoutMitraPackagesInput>, HandlingSaudiUncheckedUpdateWithoutMitraPackagesInput>
  }

  export type HandlingDomesticUpdateOneWithoutMitraPackagesNestedInput = {
    create?: XOR<HandlingDomesticCreateWithoutMitraPackagesInput, HandlingDomesticUncheckedCreateWithoutMitraPackagesInput>
    connectOrCreate?: HandlingDomesticCreateOrConnectWithoutMitraPackagesInput
    upsert?: HandlingDomesticUpsertWithoutMitraPackagesInput
    disconnect?: HandlingDomesticWhereInput | boolean
    delete?: HandlingDomesticWhereInput | boolean
    connect?: HandlingDomesticWhereUniqueInput
    update?: XOR<XOR<HandlingDomesticUpdateToOneWithWhereWithoutMitraPackagesInput, HandlingDomesticUpdateWithoutMitraPackagesInput>, HandlingDomesticUncheckedUpdateWithoutMitraPackagesInput>
  }

  export type SiskopatuhUpdateOneWithoutMitraPackagesNestedInput = {
    create?: XOR<SiskopatuhCreateWithoutMitraPackagesInput, SiskopatuhUncheckedCreateWithoutMitraPackagesInput>
    connectOrCreate?: SiskopatuhCreateOrConnectWithoutMitraPackagesInput
    upsert?: SiskopatuhUpsertWithoutMitraPackagesInput
    disconnect?: SiskopatuhWhereInput | boolean
    delete?: SiskopatuhWhereInput | boolean
    connect?: SiskopatuhWhereUniqueInput
    update?: XOR<XOR<SiskopatuhUpdateToOneWithWhereWithoutMitraPackagesInput, SiskopatuhUpdateWithoutMitraPackagesInput>, SiskopatuhUncheckedUpdateWithoutMitraPackagesInput>
  }

  export type EquipmentUpdateOneWithoutMitraPackagesNestedInput = {
    create?: XOR<EquipmentCreateWithoutMitraPackagesInput, EquipmentUncheckedCreateWithoutMitraPackagesInput>
    connectOrCreate?: EquipmentCreateOrConnectWithoutMitraPackagesInput
    upsert?: EquipmentUpsertWithoutMitraPackagesInput
    disconnect?: EquipmentWhereInput | boolean
    delete?: EquipmentWhereInput | boolean
    connect?: EquipmentWhereUniqueInput
    update?: XOR<XOR<EquipmentUpdateToOneWithWhereWithoutMitraPackagesInput, EquipmentUpdateWithoutMitraPackagesInput>, EquipmentUncheckedUpdateWithoutMitraPackagesInput>
  }

  export type TourPlusUpdateOneWithoutMitraPackagesNestedInput = {
    create?: XOR<TourPlusCreateWithoutMitraPackagesInput, TourPlusUncheckedCreateWithoutMitraPackagesInput>
    connectOrCreate?: TourPlusCreateOrConnectWithoutMitraPackagesInput
    upsert?: TourPlusUpsertWithoutMitraPackagesInput
    disconnect?: TourPlusWhereInput | boolean
    delete?: TourPlusWhereInput | boolean
    connect?: TourPlusWhereUniqueInput
    update?: XOR<XOR<TourPlusUpdateToOneWithWhereWithoutMitraPackagesInput, TourPlusUpdateWithoutMitraPackagesInput>, TourPlusUncheckedUpdateWithoutMitraPackagesInput>
  }

  export type ManasikUpdateOneWithoutMitraPackagesNestedInput = {
    create?: XOR<ManasikCreateWithoutMitraPackagesInput, ManasikUncheckedCreateWithoutMitraPackagesInput>
    connectOrCreate?: ManasikCreateOrConnectWithoutMitraPackagesInput
    upsert?: ManasikUpsertWithoutMitraPackagesInput
    disconnect?: ManasikWhereInput | boolean
    delete?: ManasikWhereInput | boolean
    connect?: ManasikWhereUniqueInput
    update?: XOR<XOR<ManasikUpdateToOneWithWhereWithoutMitraPackagesInput, ManasikUpdateWithoutMitraPackagesInput>, ManasikUncheckedUpdateWithoutMitraPackagesInput>
  }

  export type MitraPackageOrderUncheckedUpdateManyWithoutMitraPackageNestedInput = {
    create?: XOR<MitraPackageOrderCreateWithoutMitraPackageInput, MitraPackageOrderUncheckedCreateWithoutMitraPackageInput> | MitraPackageOrderCreateWithoutMitraPackageInput[] | MitraPackageOrderUncheckedCreateWithoutMitraPackageInput[]
    connectOrCreate?: MitraPackageOrderCreateOrConnectWithoutMitraPackageInput | MitraPackageOrderCreateOrConnectWithoutMitraPackageInput[]
    upsert?: MitraPackageOrderUpsertWithWhereUniqueWithoutMitraPackageInput | MitraPackageOrderUpsertWithWhereUniqueWithoutMitraPackageInput[]
    createMany?: MitraPackageOrderCreateManyMitraPackageInputEnvelope
    set?: MitraPackageOrderWhereUniqueInput | MitraPackageOrderWhereUniqueInput[]
    disconnect?: MitraPackageOrderWhereUniqueInput | MitraPackageOrderWhereUniqueInput[]
    delete?: MitraPackageOrderWhereUniqueInput | MitraPackageOrderWhereUniqueInput[]
    connect?: MitraPackageOrderWhereUniqueInput | MitraPackageOrderWhereUniqueInput[]
    update?: MitraPackageOrderUpdateWithWhereUniqueWithoutMitraPackageInput | MitraPackageOrderUpdateWithWhereUniqueWithoutMitraPackageInput[]
    updateMany?: MitraPackageOrderUpdateManyWithWhereWithoutMitraPackageInput | MitraPackageOrderUpdateManyWithWhereWithoutMitraPackageInput[]
    deleteMany?: MitraPackageOrderScalarWhereInput | MitraPackageOrderScalarWhereInput[]
  }

  export type MitraPackageCreateNestedOneWithoutMitraPackageOrdersInput = {
    create?: XOR<MitraPackageCreateWithoutMitraPackageOrdersInput, MitraPackageUncheckedCreateWithoutMitraPackageOrdersInput>
    connectOrCreate?: MitraPackageCreateOrConnectWithoutMitraPackageOrdersInput
    connect?: MitraPackageWhereUniqueInput
  }

  export type UserCreateNestedOneWithoutMitraPackageOrderInput = {
    create?: XOR<UserCreateWithoutMitraPackageOrderInput, UserUncheckedCreateWithoutMitraPackageOrderInput>
    connectOrCreate?: UserCreateOrConnectWithoutMitraPackageOrderInput
    connect?: UserWhereUniqueInput
  }

  export type MitraPackageUpdateOneRequiredWithoutMitraPackageOrdersNestedInput = {
    create?: XOR<MitraPackageCreateWithoutMitraPackageOrdersInput, MitraPackageUncheckedCreateWithoutMitraPackageOrdersInput>
    connectOrCreate?: MitraPackageCreateOrConnectWithoutMitraPackageOrdersInput
    upsert?: MitraPackageUpsertWithoutMitraPackageOrdersInput
    connect?: MitraPackageWhereUniqueInput
    update?: XOR<XOR<MitraPackageUpdateToOneWithWhereWithoutMitraPackageOrdersInput, MitraPackageUpdateWithoutMitraPackageOrdersInput>, MitraPackageUncheckedUpdateWithoutMitraPackageOrdersInput>
  }

  export type UserUpdateOneRequiredWithoutMitraPackageOrderNestedInput = {
    create?: XOR<UserCreateWithoutMitraPackageOrderInput, UserUncheckedCreateWithoutMitraPackageOrderInput>
    connectOrCreate?: UserCreateOrConnectWithoutMitraPackageOrderInput
    upsert?: UserUpsertWithoutMitraPackageOrderInput
    connect?: UserWhereUniqueInput
    update?: XOR<XOR<UserUpdateToOneWithWhereWithoutMitraPackageOrderInput, UserUpdateWithoutMitraPackageOrderInput>, UserUncheckedUpdateWithoutMitraPackageOrderInput>
  }

  export type EnumContentTypeFieldUpdateOperationsInput = {
    set?: $Enums.ContentType
  }

  export type FooterItemCreateNestedManyWithoutFooterInput = {
    create?: XOR<FooterItemCreateWithoutFooterInput, FooterItemUncheckedCreateWithoutFooterInput> | FooterItemCreateWithoutFooterInput[] | FooterItemUncheckedCreateWithoutFooterInput[]
    connectOrCreate?: FooterItemCreateOrConnectWithoutFooterInput | FooterItemCreateOrConnectWithoutFooterInput[]
    createMany?: FooterItemCreateManyFooterInputEnvelope
    connect?: FooterItemWhereUniqueInput | FooterItemWhereUniqueInput[]
  }

  export type FooterItemUncheckedCreateNestedManyWithoutFooterInput = {
    create?: XOR<FooterItemCreateWithoutFooterInput, FooterItemUncheckedCreateWithoutFooterInput> | FooterItemCreateWithoutFooterInput[] | FooterItemUncheckedCreateWithoutFooterInput[]
    connectOrCreate?: FooterItemCreateOrConnectWithoutFooterInput | FooterItemCreateOrConnectWithoutFooterInput[]
    createMany?: FooterItemCreateManyFooterInputEnvelope
    connect?: FooterItemWhereUniqueInput | FooterItemWhereUniqueInput[]
  }

  export type EnumFooterTypeFieldUpdateOperationsInput = {
    set?: $Enums.FooterType
  }

  export type FooterItemUpdateManyWithoutFooterNestedInput = {
    create?: XOR<FooterItemCreateWithoutFooterInput, FooterItemUncheckedCreateWithoutFooterInput> | FooterItemCreateWithoutFooterInput[] | FooterItemUncheckedCreateWithoutFooterInput[]
    connectOrCreate?: FooterItemCreateOrConnectWithoutFooterInput | FooterItemCreateOrConnectWithoutFooterInput[]
    upsert?: FooterItemUpsertWithWhereUniqueWithoutFooterInput | FooterItemUpsertWithWhereUniqueWithoutFooterInput[]
    createMany?: FooterItemCreateManyFooterInputEnvelope
    set?: FooterItemWhereUniqueInput | FooterItemWhereUniqueInput[]
    disconnect?: FooterItemWhereUniqueInput | FooterItemWhereUniqueInput[]
    delete?: FooterItemWhereUniqueInput | FooterItemWhereUniqueInput[]
    connect?: FooterItemWhereUniqueInput | FooterItemWhereUniqueInput[]
    update?: FooterItemUpdateWithWhereUniqueWithoutFooterInput | FooterItemUpdateWithWhereUniqueWithoutFooterInput[]
    updateMany?: FooterItemUpdateManyWithWhereWithoutFooterInput | FooterItemUpdateManyWithWhereWithoutFooterInput[]
    deleteMany?: FooterItemScalarWhereInput | FooterItemScalarWhereInput[]
  }

  export type FooterItemUncheckedUpdateManyWithoutFooterNestedInput = {
    create?: XOR<FooterItemCreateWithoutFooterInput, FooterItemUncheckedCreateWithoutFooterInput> | FooterItemCreateWithoutFooterInput[] | FooterItemUncheckedCreateWithoutFooterInput[]
    connectOrCreate?: FooterItemCreateOrConnectWithoutFooterInput | FooterItemCreateOrConnectWithoutFooterInput[]
    upsert?: FooterItemUpsertWithWhereUniqueWithoutFooterInput | FooterItemUpsertWithWhereUniqueWithoutFooterInput[]
    createMany?: FooterItemCreateManyFooterInputEnvelope
    set?: FooterItemWhereUniqueInput | FooterItemWhereUniqueInput[]
    disconnect?: FooterItemWhereUniqueInput | FooterItemWhereUniqueInput[]
    delete?: FooterItemWhereUniqueInput | FooterItemWhereUniqueInput[]
    connect?: FooterItemWhereUniqueInput | FooterItemWhereUniqueInput[]
    update?: FooterItemUpdateWithWhereUniqueWithoutFooterInput | FooterItemUpdateWithWhereUniqueWithoutFooterInput[]
    updateMany?: FooterItemUpdateManyWithWhereWithoutFooterInput | FooterItemUpdateManyWithWhereWithoutFooterInput[]
    deleteMany?: FooterItemScalarWhereInput | FooterItemScalarWhereInput[]
  }

  export type FooterCreateNestedOneWithoutFooterItemInput = {
    create?: XOR<FooterCreateWithoutFooterItemInput, FooterUncheckedCreateWithoutFooterItemInput>
    connectOrCreate?: FooterCreateOrConnectWithoutFooterItemInput
    connect?: FooterWhereUniqueInput
  }

  export type FooterUpdateOneRequiredWithoutFooterItemNestedInput = {
    create?: XOR<FooterCreateWithoutFooterItemInput, FooterUncheckedCreateWithoutFooterItemInput>
    connectOrCreate?: FooterCreateOrConnectWithoutFooterItemInput
    upsert?: FooterUpsertWithoutFooterItemInput
    connect?: FooterWhereUniqueInput
    update?: XOR<XOR<FooterUpdateToOneWithWhereWithoutFooterItemInput, FooterUpdateWithoutFooterItemInput>, FooterUncheckedUpdateWithoutFooterItemInput>
  }

  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 NestedEnumRoleFilter<$PrismaModel = never> = {
    equals?: $Enums.Role | EnumRoleFieldRefInput<$PrismaModel>
    in?: $Enums.Role[]
    notIn?: $Enums.Role[]
    not?: NestedEnumRoleFilter<$PrismaModel> | $Enums.Role
  }

  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 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 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 NestedEnumRoleWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.Role | EnumRoleFieldRefInput<$PrismaModel>
    in?: $Enums.Role[]
    notIn?: $Enums.Role[]
    not?: NestedEnumRoleWithAggregatesFilter<$PrismaModel> | $Enums.Role
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumRoleFilter<$PrismaModel>
    _max?: NestedEnumRoleFilter<$PrismaModel>
  }

  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 NestedDecimalFilter<$PrismaModel = never> = {
    equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    in?: Decimal[] | DecimalJsLike[] | number[] | string[]
    notIn?: Decimal[] | DecimalJsLike[] | number[] | string[]
    lt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    lte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    not?: NestedDecimalFilter<$PrismaModel> | Decimal | DecimalJsLike | number | string
  }

  export type NestedEnumRequestStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.RequestStatus | EnumRequestStatusFieldRefInput<$PrismaModel>
    in?: $Enums.RequestStatus[]
    notIn?: $Enums.RequestStatus[]
    not?: NestedEnumRequestStatusFilter<$PrismaModel> | $Enums.RequestStatus
  }

  export type NestedDecimalWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    in?: Decimal[] | DecimalJsLike[] | number[] | string[]
    notIn?: Decimal[] | DecimalJsLike[] | number[] | string[]
    lt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    lte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gt?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    gte?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    not?: NestedDecimalWithAggregatesFilter<$PrismaModel> | Decimal | DecimalJsLike | number | string
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedDecimalFilter<$PrismaModel>
    _sum?: NestedDecimalFilter<$PrismaModel>
    _min?: NestedDecimalFilter<$PrismaModel>
    _max?: NestedDecimalFilter<$PrismaModel>
  }

  export type NestedEnumRequestStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.RequestStatus | EnumRequestStatusFieldRefInput<$PrismaModel>
    in?: $Enums.RequestStatus[]
    notIn?: $Enums.RequestStatus[]
    not?: NestedEnumRequestStatusWithAggregatesFilter<$PrismaModel> | $Enums.RequestStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumRequestStatusFilter<$PrismaModel>
    _max?: NestedEnumRequestStatusFilter<$PrismaModel>
  }

  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 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 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 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 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 NestedEnumCityFilter<$PrismaModel = never> = {
    equals?: $Enums.City | EnumCityFieldRefInput<$PrismaModel>
    in?: $Enums.City[]
    notIn?: $Enums.City[]
    not?: NestedEnumCityFilter<$PrismaModel> | $Enums.City
  }

  export type NestedEnumCityWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.City | EnumCityFieldRefInput<$PrismaModel>
    in?: $Enums.City[]
    notIn?: $Enums.City[]
    not?: NestedEnumCityWithAggregatesFilter<$PrismaModel> | $Enums.City
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumCityFilter<$PrismaModel>
    _max?: NestedEnumCityFilter<$PrismaModel>
  }

  export type NestedEnumPeriodCategoryFilter<$PrismaModel = never> = {
    equals?: $Enums.PeriodCategory | EnumPeriodCategoryFieldRefInput<$PrismaModel>
    in?: $Enums.PeriodCategory[]
    notIn?: $Enums.PeriodCategory[]
    not?: NestedEnumPeriodCategoryFilter<$PrismaModel> | $Enums.PeriodCategory
  }

  export type NestedEnumPeriodCategoryWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.PeriodCategory | EnumPeriodCategoryFieldRefInput<$PrismaModel>
    in?: $Enums.PeriodCategory[]
    notIn?: $Enums.PeriodCategory[]
    not?: NestedEnumPeriodCategoryWithAggregatesFilter<$PrismaModel> | $Enums.PeriodCategory
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumPeriodCategoryFilter<$PrismaModel>
    _max?: NestedEnumPeriodCategoryFilter<$PrismaModel>
  }

  export type NestedEnumContentTypeFilter<$PrismaModel = never> = {
    equals?: $Enums.ContentType | EnumContentTypeFieldRefInput<$PrismaModel>
    in?: $Enums.ContentType[]
    notIn?: $Enums.ContentType[]
    not?: NestedEnumContentTypeFilter<$PrismaModel> | $Enums.ContentType
  }

  export type NestedEnumContentTypeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.ContentType | EnumContentTypeFieldRefInput<$PrismaModel>
    in?: $Enums.ContentType[]
    notIn?: $Enums.ContentType[]
    not?: NestedEnumContentTypeWithAggregatesFilter<$PrismaModel> | $Enums.ContentType
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumContentTypeFilter<$PrismaModel>
    _max?: NestedEnumContentTypeFilter<$PrismaModel>
  }
  export type NestedJsonFilter<$PrismaModel = never> = 
    | PatchUndefined<
        Either<Required<NestedJsonFilterBase<$PrismaModel>>, Exclude<keyof Required<NestedJsonFilterBase<$PrismaModel>>, 'path'>>,
        Required<NestedJsonFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<NestedJsonFilterBase<$PrismaModel>>, 'path'>>

  export type NestedJsonFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string
    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 NestedEnumFooterTypeFilter<$PrismaModel = never> = {
    equals?: $Enums.FooterType | EnumFooterTypeFieldRefInput<$PrismaModel>
    in?: $Enums.FooterType[]
    notIn?: $Enums.FooterType[]
    not?: NestedEnumFooterTypeFilter<$PrismaModel> | $Enums.FooterType
  }

  export type NestedEnumFooterTypeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.FooterType | EnumFooterTypeFieldRefInput<$PrismaModel>
    in?: $Enums.FooterType[]
    notIn?: $Enums.FooterType[]
    not?: NestedEnumFooterTypeWithAggregatesFilter<$PrismaModel> | $Enums.FooterType
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumFooterTypeFilter<$PrismaModel>
    _max?: NestedEnumFooterTypeFilter<$PrismaModel>
  }

  export type ProductOrderCreateWithoutUserInput = {
    id?: string
    departure: Date | string
    number_of_pax: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    Product: ProductCreateNestedOneWithoutProductOrdersInput
    ProductVariation?: ProductVariationCreateNestedOneWithoutProductOrdersInput
  }

  export type ProductOrderUncheckedCreateWithoutUserInput = {
    id?: string
    product_id: string
    variation_id?: string | null
    departure: Date | string
    number_of_pax: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type ProductOrderCreateOrConnectWithoutUserInput = {
    where: ProductOrderWhereUniqueInput
    create: XOR<ProductOrderCreateWithoutUserInput, ProductOrderUncheckedCreateWithoutUserInput>
  }

  export type ProductOrderCreateManyUserInputEnvelope = {
    data: ProductOrderCreateManyUserInput | ProductOrderCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type MitraPackageOrderCreateWithoutUserInput = {
    id?: string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackage: MitraPackageCreateNestedOneWithoutMitraPackageOrdersInput
  }

  export type MitraPackageOrderUncheckedCreateWithoutUserInput = {
    id?: string
    mitra_package_id: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MitraPackageOrderCreateOrConnectWithoutUserInput = {
    where: MitraPackageOrderWhereUniqueInput
    create: XOR<MitraPackageOrderCreateWithoutUserInput, MitraPackageOrderUncheckedCreateWithoutUserInput>
  }

  export type MitraPackageOrderCreateManyUserInputEnvelope = {
    data: MitraPackageOrderCreateManyUserInput | MitraPackageOrderCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type MitraRequestCreateWithoutUserInput = {
    id?: string
    ktp: string
    upgrade_amount: Decimal | DecimalJsLike | number | string
    payment_proof: string
    status?: $Enums.RequestStatus
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MitraRequestUncheckedCreateWithoutUserInput = {
    id?: string
    ktp: string
    upgrade_amount: Decimal | DecimalJsLike | number | string
    payment_proof: string
    status?: $Enums.RequestStatus
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MitraRequestCreateOrConnectWithoutUserInput = {
    where: MitraRequestWhereUniqueInput
    create: XOR<MitraRequestCreateWithoutUserInput, MitraRequestUncheckedCreateWithoutUserInput>
  }

  export type MitraRequestCreateManyUserInputEnvelope = {
    data: MitraRequestCreateManyUserInput | MitraRequestCreateManyUserInput[]
    skipDuplicates?: boolean
  }

  export type ProductOrderUpsertWithWhereUniqueWithoutUserInput = {
    where: ProductOrderWhereUniqueInput
    update: XOR<ProductOrderUpdateWithoutUserInput, ProductOrderUncheckedUpdateWithoutUserInput>
    create: XOR<ProductOrderCreateWithoutUserInput, ProductOrderUncheckedCreateWithoutUserInput>
  }

  export type ProductOrderUpdateWithWhereUniqueWithoutUserInput = {
    where: ProductOrderWhereUniqueInput
    data: XOR<ProductOrderUpdateWithoutUserInput, ProductOrderUncheckedUpdateWithoutUserInput>
  }

  export type ProductOrderUpdateManyWithWhereWithoutUserInput = {
    where: ProductOrderScalarWhereInput
    data: XOR<ProductOrderUpdateManyMutationInput, ProductOrderUncheckedUpdateManyWithoutUserInput>
  }

  export type ProductOrderScalarWhereInput = {
    AND?: ProductOrderScalarWhereInput | ProductOrderScalarWhereInput[]
    OR?: ProductOrderScalarWhereInput[]
    NOT?: ProductOrderScalarWhereInput | ProductOrderScalarWhereInput[]
    id?: StringFilter<"ProductOrder"> | string
    user_id?: StringFilter<"ProductOrder"> | string
    product_id?: StringFilter<"ProductOrder"> | string
    variation_id?: StringNullableFilter<"ProductOrder"> | string | null
    departure?: DateTimeFilter<"ProductOrder"> | Date | string
    number_of_pax?: IntFilter<"ProductOrder"> | number
    per_pax_price?: DecimalFilter<"ProductOrder"> | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFilter<"ProductOrder"> | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFilter<"ProductOrder"> | Date | string
    updated_at?: DateTimeFilter<"ProductOrder"> | Date | string
  }

  export type MitraPackageOrderUpsertWithWhereUniqueWithoutUserInput = {
    where: MitraPackageOrderWhereUniqueInput
    update: XOR<MitraPackageOrderUpdateWithoutUserInput, MitraPackageOrderUncheckedUpdateWithoutUserInput>
    create: XOR<MitraPackageOrderCreateWithoutUserInput, MitraPackageOrderUncheckedCreateWithoutUserInput>
  }

  export type MitraPackageOrderUpdateWithWhereUniqueWithoutUserInput = {
    where: MitraPackageOrderWhereUniqueInput
    data: XOR<MitraPackageOrderUpdateWithoutUserInput, MitraPackageOrderUncheckedUpdateWithoutUserInput>
  }

  export type MitraPackageOrderUpdateManyWithWhereWithoutUserInput = {
    where: MitraPackageOrderScalarWhereInput
    data: XOR<MitraPackageOrderUpdateManyMutationInput, MitraPackageOrderUncheckedUpdateManyWithoutUserInput>
  }

  export type MitraPackageOrderScalarWhereInput = {
    AND?: MitraPackageOrderScalarWhereInput | MitraPackageOrderScalarWhereInput[]
    OR?: MitraPackageOrderScalarWhereInput[]
    NOT?: MitraPackageOrderScalarWhereInput | MitraPackageOrderScalarWhereInput[]
    id?: StringFilter<"MitraPackageOrder"> | string
    user_id?: StringFilter<"MitraPackageOrder"> | string
    mitra_package_id?: StringFilter<"MitraPackageOrder"> | string
    created_at?: DateTimeFilter<"MitraPackageOrder"> | Date | string
    updated_at?: DateTimeFilter<"MitraPackageOrder"> | Date | string
  }

  export type MitraRequestUpsertWithWhereUniqueWithoutUserInput = {
    where: MitraRequestWhereUniqueInput
    update: XOR<MitraRequestUpdateWithoutUserInput, MitraRequestUncheckedUpdateWithoutUserInput>
    create: XOR<MitraRequestCreateWithoutUserInput, MitraRequestUncheckedCreateWithoutUserInput>
  }

  export type MitraRequestUpdateWithWhereUniqueWithoutUserInput = {
    where: MitraRequestWhereUniqueInput
    data: XOR<MitraRequestUpdateWithoutUserInput, MitraRequestUncheckedUpdateWithoutUserInput>
  }

  export type MitraRequestUpdateManyWithWhereWithoutUserInput = {
    where: MitraRequestScalarWhereInput
    data: XOR<MitraRequestUpdateManyMutationInput, MitraRequestUncheckedUpdateManyWithoutUserInput>
  }

  export type MitraRequestScalarWhereInput = {
    AND?: MitraRequestScalarWhereInput | MitraRequestScalarWhereInput[]
    OR?: MitraRequestScalarWhereInput[]
    NOT?: MitraRequestScalarWhereInput | MitraRequestScalarWhereInput[]
    id?: StringFilter<"MitraRequest"> | string
    user_id?: StringFilter<"MitraRequest"> | string
    ktp?: StringFilter<"MitraRequest"> | string
    upgrade_amount?: DecimalFilter<"MitraRequest"> | Decimal | DecimalJsLike | number | string
    payment_proof?: StringFilter<"MitraRequest"> | string
    status?: EnumRequestStatusFilter<"MitraRequest"> | $Enums.RequestStatus
    created_at?: DateTimeFilter<"MitraRequest"> | Date | string
    updated_at?: DateTimeFilter<"MitraRequest"> | Date | string
  }

  export type UserCreateWithoutMitraRequestInput = {
    id?: string
    email: string
    full_name: string
    password: string
    whatsapp_number: string
    role?: $Enums.Role
    created_at?: Date | string
    updated_at?: Date | string
    ProductOrders?: ProductOrderCreateNestedManyWithoutUserInput
    MitraPackageOrder?: MitraPackageOrderCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutMitraRequestInput = {
    id?: string
    email: string
    full_name: string
    password: string
    whatsapp_number: string
    role?: $Enums.Role
    created_at?: Date | string
    updated_at?: Date | string
    ProductOrders?: ProductOrderUncheckedCreateNestedManyWithoutUserInput
    MitraPackageOrder?: MitraPackageOrderUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutMitraRequestInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutMitraRequestInput, UserUncheckedCreateWithoutMitraRequestInput>
  }

  export type UserUpsertWithoutMitraRequestInput = {
    update: XOR<UserUpdateWithoutMitraRequestInput, UserUncheckedUpdateWithoutMitraRequestInput>
    create: XOR<UserCreateWithoutMitraRequestInput, UserUncheckedCreateWithoutMitraRequestInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutMitraRequestInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutMitraRequestInput, UserUncheckedUpdateWithoutMitraRequestInput>
  }

  export type UserUpdateWithoutMitraRequestInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    full_name?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    whatsapp_number?: StringFieldUpdateOperationsInput | string
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ProductOrders?: ProductOrderUpdateManyWithoutUserNestedInput
    MitraPackageOrder?: MitraPackageOrderUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutMitraRequestInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    full_name?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    whatsapp_number?: StringFieldUpdateOperationsInput | string
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ProductOrders?: ProductOrderUncheckedUpdateManyWithoutUserNestedInput
    MitraPackageOrder?: MitraPackageOrderUncheckedUpdateManyWithoutUserNestedInput
  }

  export type UserPackageOrderCreateWithoutUserPackageInput = {
    id?: string
    full_name: string
    email: string
    whatsapp_number: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type UserPackageOrderUncheckedCreateWithoutUserPackageInput = {
    id?: string
    full_name: string
    email: string
    whatsapp_number: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type UserPackageOrderCreateOrConnectWithoutUserPackageInput = {
    where: UserPackageOrderWhereUniqueInput
    create: XOR<UserPackageOrderCreateWithoutUserPackageInput, UserPackageOrderUncheckedCreateWithoutUserPackageInput>
  }

  export type UserPackageOrderCreateManyUserPackageInputEnvelope = {
    data: UserPackageOrderCreateManyUserPackageInput | UserPackageOrderCreateManyUserPackageInput[]
    skipDuplicates?: boolean
  }

  export type UserPackageOptionCreateWithoutTransportationsInput = {
    id?: string
    name: string
    price: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    flights?: UserPackageCreateNestedManyWithoutFlightInput
    hotelMekkahs?: UserPackageCreateNestedManyWithoutHotelMekkahInput
    hotelMadinahs?: UserPackageCreateNestedManyWithoutHotelMadinahInput
    muthawifs?: UserPackageCreateNestedManyWithoutMuthawifInput
    handlings?: UserPackageCreateNestedManyWithoutHandlingInput
    PackageType: PackageTypeCreateNestedOneWithoutUserPackageOptionsInput
  }

  export type UserPackageOptionUncheckedCreateWithoutTransportationsInput = {
    id?: string
    package_type_id: string
    name: string
    price: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    flights?: UserPackageUncheckedCreateNestedManyWithoutFlightInput
    hotelMekkahs?: UserPackageUncheckedCreateNestedManyWithoutHotelMekkahInput
    hotelMadinahs?: UserPackageUncheckedCreateNestedManyWithoutHotelMadinahInput
    muthawifs?: UserPackageUncheckedCreateNestedManyWithoutMuthawifInput
    handlings?: UserPackageUncheckedCreateNestedManyWithoutHandlingInput
  }

  export type UserPackageOptionCreateOrConnectWithoutTransportationsInput = {
    where: UserPackageOptionWhereUniqueInput
    create: XOR<UserPackageOptionCreateWithoutTransportationsInput, UserPackageOptionUncheckedCreateWithoutTransportationsInput>
  }

  export type UserPackageOptionCreateWithoutFlightsInput = {
    id?: string
    name: string
    price: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    transportations?: UserPackageCreateNestedManyWithoutTransportationInput
    hotelMekkahs?: UserPackageCreateNestedManyWithoutHotelMekkahInput
    hotelMadinahs?: UserPackageCreateNestedManyWithoutHotelMadinahInput
    muthawifs?: UserPackageCreateNestedManyWithoutMuthawifInput
    handlings?: UserPackageCreateNestedManyWithoutHandlingInput
    PackageType: PackageTypeCreateNestedOneWithoutUserPackageOptionsInput
  }

  export type UserPackageOptionUncheckedCreateWithoutFlightsInput = {
    id?: string
    package_type_id: string
    name: string
    price: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    transportations?: UserPackageUncheckedCreateNestedManyWithoutTransportationInput
    hotelMekkahs?: UserPackageUncheckedCreateNestedManyWithoutHotelMekkahInput
    hotelMadinahs?: UserPackageUncheckedCreateNestedManyWithoutHotelMadinahInput
    muthawifs?: UserPackageUncheckedCreateNestedManyWithoutMuthawifInput
    handlings?: UserPackageUncheckedCreateNestedManyWithoutHandlingInput
  }

  export type UserPackageOptionCreateOrConnectWithoutFlightsInput = {
    where: UserPackageOptionWhereUniqueInput
    create: XOR<UserPackageOptionCreateWithoutFlightsInput, UserPackageOptionUncheckedCreateWithoutFlightsInput>
  }

  export type UserPackageOptionCreateWithoutHotelMekkahsInput = {
    id?: string
    name: string
    price: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    transportations?: UserPackageCreateNestedManyWithoutTransportationInput
    flights?: UserPackageCreateNestedManyWithoutFlightInput
    hotelMadinahs?: UserPackageCreateNestedManyWithoutHotelMadinahInput
    muthawifs?: UserPackageCreateNestedManyWithoutMuthawifInput
    handlings?: UserPackageCreateNestedManyWithoutHandlingInput
    PackageType: PackageTypeCreateNestedOneWithoutUserPackageOptionsInput
  }

  export type UserPackageOptionUncheckedCreateWithoutHotelMekkahsInput = {
    id?: string
    package_type_id: string
    name: string
    price: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    transportations?: UserPackageUncheckedCreateNestedManyWithoutTransportationInput
    flights?: UserPackageUncheckedCreateNestedManyWithoutFlightInput
    hotelMadinahs?: UserPackageUncheckedCreateNestedManyWithoutHotelMadinahInput
    muthawifs?: UserPackageUncheckedCreateNestedManyWithoutMuthawifInput
    handlings?: UserPackageUncheckedCreateNestedManyWithoutHandlingInput
  }

  export type UserPackageOptionCreateOrConnectWithoutHotelMekkahsInput = {
    where: UserPackageOptionWhereUniqueInput
    create: XOR<UserPackageOptionCreateWithoutHotelMekkahsInput, UserPackageOptionUncheckedCreateWithoutHotelMekkahsInput>
  }

  export type UserPackageOptionCreateWithoutHotelMadinahsInput = {
    id?: string
    name: string
    price: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    transportations?: UserPackageCreateNestedManyWithoutTransportationInput
    flights?: UserPackageCreateNestedManyWithoutFlightInput
    hotelMekkahs?: UserPackageCreateNestedManyWithoutHotelMekkahInput
    muthawifs?: UserPackageCreateNestedManyWithoutMuthawifInput
    handlings?: UserPackageCreateNestedManyWithoutHandlingInput
    PackageType: PackageTypeCreateNestedOneWithoutUserPackageOptionsInput
  }

  export type UserPackageOptionUncheckedCreateWithoutHotelMadinahsInput = {
    id?: string
    package_type_id: string
    name: string
    price: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    transportations?: UserPackageUncheckedCreateNestedManyWithoutTransportationInput
    flights?: UserPackageUncheckedCreateNestedManyWithoutFlightInput
    hotelMekkahs?: UserPackageUncheckedCreateNestedManyWithoutHotelMekkahInput
    muthawifs?: UserPackageUncheckedCreateNestedManyWithoutMuthawifInput
    handlings?: UserPackageUncheckedCreateNestedManyWithoutHandlingInput
  }

  export type UserPackageOptionCreateOrConnectWithoutHotelMadinahsInput = {
    where: UserPackageOptionWhereUniqueInput
    create: XOR<UserPackageOptionCreateWithoutHotelMadinahsInput, UserPackageOptionUncheckedCreateWithoutHotelMadinahsInput>
  }

  export type UserPackageOptionCreateWithoutMuthawifsInput = {
    id?: string
    name: string
    price: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    transportations?: UserPackageCreateNestedManyWithoutTransportationInput
    flights?: UserPackageCreateNestedManyWithoutFlightInput
    hotelMekkahs?: UserPackageCreateNestedManyWithoutHotelMekkahInput
    hotelMadinahs?: UserPackageCreateNestedManyWithoutHotelMadinahInput
    handlings?: UserPackageCreateNestedManyWithoutHandlingInput
    PackageType: PackageTypeCreateNestedOneWithoutUserPackageOptionsInput
  }

  export type UserPackageOptionUncheckedCreateWithoutMuthawifsInput = {
    id?: string
    package_type_id: string
    name: string
    price: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    transportations?: UserPackageUncheckedCreateNestedManyWithoutTransportationInput
    flights?: UserPackageUncheckedCreateNestedManyWithoutFlightInput
    hotelMekkahs?: UserPackageUncheckedCreateNestedManyWithoutHotelMekkahInput
    hotelMadinahs?: UserPackageUncheckedCreateNestedManyWithoutHotelMadinahInput
    handlings?: UserPackageUncheckedCreateNestedManyWithoutHandlingInput
  }

  export type UserPackageOptionCreateOrConnectWithoutMuthawifsInput = {
    where: UserPackageOptionWhereUniqueInput
    create: XOR<UserPackageOptionCreateWithoutMuthawifsInput, UserPackageOptionUncheckedCreateWithoutMuthawifsInput>
  }

  export type UserPackageOptionCreateWithoutHandlingsInput = {
    id?: string
    name: string
    price: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    transportations?: UserPackageCreateNestedManyWithoutTransportationInput
    flights?: UserPackageCreateNestedManyWithoutFlightInput
    hotelMekkahs?: UserPackageCreateNestedManyWithoutHotelMekkahInput
    hotelMadinahs?: UserPackageCreateNestedManyWithoutHotelMadinahInput
    muthawifs?: UserPackageCreateNestedManyWithoutMuthawifInput
    PackageType: PackageTypeCreateNestedOneWithoutUserPackageOptionsInput
  }

  export type UserPackageOptionUncheckedCreateWithoutHandlingsInput = {
    id?: string
    package_type_id: string
    name: string
    price: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    transportations?: UserPackageUncheckedCreateNestedManyWithoutTransportationInput
    flights?: UserPackageUncheckedCreateNestedManyWithoutFlightInput
    hotelMekkahs?: UserPackageUncheckedCreateNestedManyWithoutHotelMekkahInput
    hotelMadinahs?: UserPackageUncheckedCreateNestedManyWithoutHotelMadinahInput
    muthawifs?: UserPackageUncheckedCreateNestedManyWithoutMuthawifInput
  }

  export type UserPackageOptionCreateOrConnectWithoutHandlingsInput = {
    where: UserPackageOptionWhereUniqueInput
    create: XOR<UserPackageOptionCreateWithoutHandlingsInput, UserPackageOptionUncheckedCreateWithoutHandlingsInput>
  }

  export type UserPackageOrderUpsertWithWhereUniqueWithoutUserPackageInput = {
    where: UserPackageOrderWhereUniqueInput
    update: XOR<UserPackageOrderUpdateWithoutUserPackageInput, UserPackageOrderUncheckedUpdateWithoutUserPackageInput>
    create: XOR<UserPackageOrderCreateWithoutUserPackageInput, UserPackageOrderUncheckedCreateWithoutUserPackageInput>
  }

  export type UserPackageOrderUpdateWithWhereUniqueWithoutUserPackageInput = {
    where: UserPackageOrderWhereUniqueInput
    data: XOR<UserPackageOrderUpdateWithoutUserPackageInput, UserPackageOrderUncheckedUpdateWithoutUserPackageInput>
  }

  export type UserPackageOrderUpdateManyWithWhereWithoutUserPackageInput = {
    where: UserPackageOrderScalarWhereInput
    data: XOR<UserPackageOrderUpdateManyMutationInput, UserPackageOrderUncheckedUpdateManyWithoutUserPackageInput>
  }

  export type UserPackageOrderScalarWhereInput = {
    AND?: UserPackageOrderScalarWhereInput | UserPackageOrderScalarWhereInput[]
    OR?: UserPackageOrderScalarWhereInput[]
    NOT?: UserPackageOrderScalarWhereInput | UserPackageOrderScalarWhereInput[]
    id?: StringFilter<"UserPackageOrder"> | string
    full_name?: StringFilter<"UserPackageOrder"> | string
    email?: StringFilter<"UserPackageOrder"> | string
    whatsapp_number?: StringFilter<"UserPackageOrder"> | string
    user_package_id?: StringFilter<"UserPackageOrder"> | string
    created_at?: DateTimeFilter<"UserPackageOrder"> | Date | string
    updated_at?: DateTimeFilter<"UserPackageOrder"> | Date | string
  }

  export type UserPackageOptionUpsertWithoutTransportationsInput = {
    update: XOR<UserPackageOptionUpdateWithoutTransportationsInput, UserPackageOptionUncheckedUpdateWithoutTransportationsInput>
    create: XOR<UserPackageOptionCreateWithoutTransportationsInput, UserPackageOptionUncheckedCreateWithoutTransportationsInput>
    where?: UserPackageOptionWhereInput
  }

  export type UserPackageOptionUpdateToOneWithWhereWithoutTransportationsInput = {
    where?: UserPackageOptionWhereInput
    data: XOR<UserPackageOptionUpdateWithoutTransportationsInput, UserPackageOptionUncheckedUpdateWithoutTransportationsInput>
  }

  export type UserPackageOptionUpdateWithoutTransportationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    flights?: UserPackageUpdateManyWithoutFlightNestedInput
    hotelMekkahs?: UserPackageUpdateManyWithoutHotelMekkahNestedInput
    hotelMadinahs?: UserPackageUpdateManyWithoutHotelMadinahNestedInput
    muthawifs?: UserPackageUpdateManyWithoutMuthawifNestedInput
    handlings?: UserPackageUpdateManyWithoutHandlingNestedInput
    PackageType?: PackageTypeUpdateOneRequiredWithoutUserPackageOptionsNestedInput
  }

  export type UserPackageOptionUncheckedUpdateWithoutTransportationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    package_type_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    flights?: UserPackageUncheckedUpdateManyWithoutFlightNestedInput
    hotelMekkahs?: UserPackageUncheckedUpdateManyWithoutHotelMekkahNestedInput
    hotelMadinahs?: UserPackageUncheckedUpdateManyWithoutHotelMadinahNestedInput
    muthawifs?: UserPackageUncheckedUpdateManyWithoutMuthawifNestedInput
    handlings?: UserPackageUncheckedUpdateManyWithoutHandlingNestedInput
  }

  export type UserPackageOptionUpsertWithoutFlightsInput = {
    update: XOR<UserPackageOptionUpdateWithoutFlightsInput, UserPackageOptionUncheckedUpdateWithoutFlightsInput>
    create: XOR<UserPackageOptionCreateWithoutFlightsInput, UserPackageOptionUncheckedCreateWithoutFlightsInput>
    where?: UserPackageOptionWhereInput
  }

  export type UserPackageOptionUpdateToOneWithWhereWithoutFlightsInput = {
    where?: UserPackageOptionWhereInput
    data: XOR<UserPackageOptionUpdateWithoutFlightsInput, UserPackageOptionUncheckedUpdateWithoutFlightsInput>
  }

  export type UserPackageOptionUpdateWithoutFlightsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    transportations?: UserPackageUpdateManyWithoutTransportationNestedInput
    hotelMekkahs?: UserPackageUpdateManyWithoutHotelMekkahNestedInput
    hotelMadinahs?: UserPackageUpdateManyWithoutHotelMadinahNestedInput
    muthawifs?: UserPackageUpdateManyWithoutMuthawifNestedInput
    handlings?: UserPackageUpdateManyWithoutHandlingNestedInput
    PackageType?: PackageTypeUpdateOneRequiredWithoutUserPackageOptionsNestedInput
  }

  export type UserPackageOptionUncheckedUpdateWithoutFlightsInput = {
    id?: StringFieldUpdateOperationsInput | string
    package_type_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    transportations?: UserPackageUncheckedUpdateManyWithoutTransportationNestedInput
    hotelMekkahs?: UserPackageUncheckedUpdateManyWithoutHotelMekkahNestedInput
    hotelMadinahs?: UserPackageUncheckedUpdateManyWithoutHotelMadinahNestedInput
    muthawifs?: UserPackageUncheckedUpdateManyWithoutMuthawifNestedInput
    handlings?: UserPackageUncheckedUpdateManyWithoutHandlingNestedInput
  }

  export type UserPackageOptionUpsertWithoutHotelMekkahsInput = {
    update: XOR<UserPackageOptionUpdateWithoutHotelMekkahsInput, UserPackageOptionUncheckedUpdateWithoutHotelMekkahsInput>
    create: XOR<UserPackageOptionCreateWithoutHotelMekkahsInput, UserPackageOptionUncheckedCreateWithoutHotelMekkahsInput>
    where?: UserPackageOptionWhereInput
  }

  export type UserPackageOptionUpdateToOneWithWhereWithoutHotelMekkahsInput = {
    where?: UserPackageOptionWhereInput
    data: XOR<UserPackageOptionUpdateWithoutHotelMekkahsInput, UserPackageOptionUncheckedUpdateWithoutHotelMekkahsInput>
  }

  export type UserPackageOptionUpdateWithoutHotelMekkahsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    transportations?: UserPackageUpdateManyWithoutTransportationNestedInput
    flights?: UserPackageUpdateManyWithoutFlightNestedInput
    hotelMadinahs?: UserPackageUpdateManyWithoutHotelMadinahNestedInput
    muthawifs?: UserPackageUpdateManyWithoutMuthawifNestedInput
    handlings?: UserPackageUpdateManyWithoutHandlingNestedInput
    PackageType?: PackageTypeUpdateOneRequiredWithoutUserPackageOptionsNestedInput
  }

  export type UserPackageOptionUncheckedUpdateWithoutHotelMekkahsInput = {
    id?: StringFieldUpdateOperationsInput | string
    package_type_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    transportations?: UserPackageUncheckedUpdateManyWithoutTransportationNestedInput
    flights?: UserPackageUncheckedUpdateManyWithoutFlightNestedInput
    hotelMadinahs?: UserPackageUncheckedUpdateManyWithoutHotelMadinahNestedInput
    muthawifs?: UserPackageUncheckedUpdateManyWithoutMuthawifNestedInput
    handlings?: UserPackageUncheckedUpdateManyWithoutHandlingNestedInput
  }

  export type UserPackageOptionUpsertWithoutHotelMadinahsInput = {
    update: XOR<UserPackageOptionUpdateWithoutHotelMadinahsInput, UserPackageOptionUncheckedUpdateWithoutHotelMadinahsInput>
    create: XOR<UserPackageOptionCreateWithoutHotelMadinahsInput, UserPackageOptionUncheckedCreateWithoutHotelMadinahsInput>
    where?: UserPackageOptionWhereInput
  }

  export type UserPackageOptionUpdateToOneWithWhereWithoutHotelMadinahsInput = {
    where?: UserPackageOptionWhereInput
    data: XOR<UserPackageOptionUpdateWithoutHotelMadinahsInput, UserPackageOptionUncheckedUpdateWithoutHotelMadinahsInput>
  }

  export type UserPackageOptionUpdateWithoutHotelMadinahsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    transportations?: UserPackageUpdateManyWithoutTransportationNestedInput
    flights?: UserPackageUpdateManyWithoutFlightNestedInput
    hotelMekkahs?: UserPackageUpdateManyWithoutHotelMekkahNestedInput
    muthawifs?: UserPackageUpdateManyWithoutMuthawifNestedInput
    handlings?: UserPackageUpdateManyWithoutHandlingNestedInput
    PackageType?: PackageTypeUpdateOneRequiredWithoutUserPackageOptionsNestedInput
  }

  export type UserPackageOptionUncheckedUpdateWithoutHotelMadinahsInput = {
    id?: StringFieldUpdateOperationsInput | string
    package_type_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    transportations?: UserPackageUncheckedUpdateManyWithoutTransportationNestedInput
    flights?: UserPackageUncheckedUpdateManyWithoutFlightNestedInput
    hotelMekkahs?: UserPackageUncheckedUpdateManyWithoutHotelMekkahNestedInput
    muthawifs?: UserPackageUncheckedUpdateManyWithoutMuthawifNestedInput
    handlings?: UserPackageUncheckedUpdateManyWithoutHandlingNestedInput
  }

  export type UserPackageOptionUpsertWithoutMuthawifsInput = {
    update: XOR<UserPackageOptionUpdateWithoutMuthawifsInput, UserPackageOptionUncheckedUpdateWithoutMuthawifsInput>
    create: XOR<UserPackageOptionCreateWithoutMuthawifsInput, UserPackageOptionUncheckedCreateWithoutMuthawifsInput>
    where?: UserPackageOptionWhereInput
  }

  export type UserPackageOptionUpdateToOneWithWhereWithoutMuthawifsInput = {
    where?: UserPackageOptionWhereInput
    data: XOR<UserPackageOptionUpdateWithoutMuthawifsInput, UserPackageOptionUncheckedUpdateWithoutMuthawifsInput>
  }

  export type UserPackageOptionUpdateWithoutMuthawifsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    transportations?: UserPackageUpdateManyWithoutTransportationNestedInput
    flights?: UserPackageUpdateManyWithoutFlightNestedInput
    hotelMekkahs?: UserPackageUpdateManyWithoutHotelMekkahNestedInput
    hotelMadinahs?: UserPackageUpdateManyWithoutHotelMadinahNestedInput
    handlings?: UserPackageUpdateManyWithoutHandlingNestedInput
    PackageType?: PackageTypeUpdateOneRequiredWithoutUserPackageOptionsNestedInput
  }

  export type UserPackageOptionUncheckedUpdateWithoutMuthawifsInput = {
    id?: StringFieldUpdateOperationsInput | string
    package_type_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    transportations?: UserPackageUncheckedUpdateManyWithoutTransportationNestedInput
    flights?: UserPackageUncheckedUpdateManyWithoutFlightNestedInput
    hotelMekkahs?: UserPackageUncheckedUpdateManyWithoutHotelMekkahNestedInput
    hotelMadinahs?: UserPackageUncheckedUpdateManyWithoutHotelMadinahNestedInput
    handlings?: UserPackageUncheckedUpdateManyWithoutHandlingNestedInput
  }

  export type UserPackageOptionUpsertWithoutHandlingsInput = {
    update: XOR<UserPackageOptionUpdateWithoutHandlingsInput, UserPackageOptionUncheckedUpdateWithoutHandlingsInput>
    create: XOR<UserPackageOptionCreateWithoutHandlingsInput, UserPackageOptionUncheckedCreateWithoutHandlingsInput>
    where?: UserPackageOptionWhereInput
  }

  export type UserPackageOptionUpdateToOneWithWhereWithoutHandlingsInput = {
    where?: UserPackageOptionWhereInput
    data: XOR<UserPackageOptionUpdateWithoutHandlingsInput, UserPackageOptionUncheckedUpdateWithoutHandlingsInput>
  }

  export type UserPackageOptionUpdateWithoutHandlingsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    transportations?: UserPackageUpdateManyWithoutTransportationNestedInput
    flights?: UserPackageUpdateManyWithoutFlightNestedInput
    hotelMekkahs?: UserPackageUpdateManyWithoutHotelMekkahNestedInput
    hotelMadinahs?: UserPackageUpdateManyWithoutHotelMadinahNestedInput
    muthawifs?: UserPackageUpdateManyWithoutMuthawifNestedInput
    PackageType?: PackageTypeUpdateOneRequiredWithoutUserPackageOptionsNestedInput
  }

  export type UserPackageOptionUncheckedUpdateWithoutHandlingsInput = {
    id?: StringFieldUpdateOperationsInput | string
    package_type_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    transportations?: UserPackageUncheckedUpdateManyWithoutTransportationNestedInput
    flights?: UserPackageUncheckedUpdateManyWithoutFlightNestedInput
    hotelMekkahs?: UserPackageUncheckedUpdateManyWithoutHotelMekkahNestedInput
    hotelMadinahs?: UserPackageUncheckedUpdateManyWithoutHotelMadinahNestedInput
    muthawifs?: UserPackageUncheckedUpdateManyWithoutMuthawifNestedInput
  }

  export type UserPackageOptionCreateWithoutPackageTypeInput = {
    id?: string
    name: string
    price: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    transportations?: UserPackageCreateNestedManyWithoutTransportationInput
    flights?: UserPackageCreateNestedManyWithoutFlightInput
    hotelMekkahs?: UserPackageCreateNestedManyWithoutHotelMekkahInput
    hotelMadinahs?: UserPackageCreateNestedManyWithoutHotelMadinahInput
    muthawifs?: UserPackageCreateNestedManyWithoutMuthawifInput
    handlings?: UserPackageCreateNestedManyWithoutHandlingInput
  }

  export type UserPackageOptionUncheckedCreateWithoutPackageTypeInput = {
    id?: string
    name: string
    price: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    transportations?: UserPackageUncheckedCreateNestedManyWithoutTransportationInput
    flights?: UserPackageUncheckedCreateNestedManyWithoutFlightInput
    hotelMekkahs?: UserPackageUncheckedCreateNestedManyWithoutHotelMekkahInput
    hotelMadinahs?: UserPackageUncheckedCreateNestedManyWithoutHotelMadinahInput
    muthawifs?: UserPackageUncheckedCreateNestedManyWithoutMuthawifInput
    handlings?: UserPackageUncheckedCreateNestedManyWithoutHandlingInput
  }

  export type UserPackageOptionCreateOrConnectWithoutPackageTypeInput = {
    where: UserPackageOptionWhereUniqueInput
    create: XOR<UserPackageOptionCreateWithoutPackageTypeInput, UserPackageOptionUncheckedCreateWithoutPackageTypeInput>
  }

  export type UserPackageOptionCreateManyPackageTypeInputEnvelope = {
    data: UserPackageOptionCreateManyPackageTypeInput | UserPackageOptionCreateManyPackageTypeInput[]
    skipDuplicates?: boolean
  }

  export type UserPackageOptionUpsertWithWhereUniqueWithoutPackageTypeInput = {
    where: UserPackageOptionWhereUniqueInput
    update: XOR<UserPackageOptionUpdateWithoutPackageTypeInput, UserPackageOptionUncheckedUpdateWithoutPackageTypeInput>
    create: XOR<UserPackageOptionCreateWithoutPackageTypeInput, UserPackageOptionUncheckedCreateWithoutPackageTypeInput>
  }

  export type UserPackageOptionUpdateWithWhereUniqueWithoutPackageTypeInput = {
    where: UserPackageOptionWhereUniqueInput
    data: XOR<UserPackageOptionUpdateWithoutPackageTypeInput, UserPackageOptionUncheckedUpdateWithoutPackageTypeInput>
  }

  export type UserPackageOptionUpdateManyWithWhereWithoutPackageTypeInput = {
    where: UserPackageOptionScalarWhereInput
    data: XOR<UserPackageOptionUpdateManyMutationInput, UserPackageOptionUncheckedUpdateManyWithoutPackageTypeInput>
  }

  export type UserPackageOptionScalarWhereInput = {
    AND?: UserPackageOptionScalarWhereInput | UserPackageOptionScalarWhereInput[]
    OR?: UserPackageOptionScalarWhereInput[]
    NOT?: UserPackageOptionScalarWhereInput | UserPackageOptionScalarWhereInput[]
    id?: StringFilter<"UserPackageOption"> | string
    package_type_id?: StringFilter<"UserPackageOption"> | string
    name?: StringFilter<"UserPackageOption"> | string
    price?: DecimalFilter<"UserPackageOption"> | Decimal | DecimalJsLike | number | string
    order_number?: IntFilter<"UserPackageOption"> | number
    created_at?: DateTimeFilter<"UserPackageOption"> | Date | string
    updated_at?: DateTimeFilter<"UserPackageOption"> | Date | string
  }

  export type UserPackageCreateWithoutTransportationInput = {
    id?: string
    number_of_pax: number
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    UserPackageOrders?: UserPackageOrderCreateNestedManyWithoutUserPackageInput
    flight?: UserPackageOptionCreateNestedOneWithoutFlightsInput
    hotelMekkah?: UserPackageOptionCreateNestedOneWithoutHotelMekkahsInput
    hotelMadinah?: UserPackageOptionCreateNestedOneWithoutHotelMadinahsInput
    muthawif?: UserPackageOptionCreateNestedOneWithoutMuthawifsInput
    handling?: UserPackageOptionCreateNestedOneWithoutHandlingsInput
  }

  export type UserPackageUncheckedCreateWithoutTransportationInput = {
    id?: string
    flight_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    muthawif_id?: string | null
    handling_id?: string | null
    number_of_pax: number
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    UserPackageOrders?: UserPackageOrderUncheckedCreateNestedManyWithoutUserPackageInput
  }

  export type UserPackageCreateOrConnectWithoutTransportationInput = {
    where: UserPackageWhereUniqueInput
    create: XOR<UserPackageCreateWithoutTransportationInput, UserPackageUncheckedCreateWithoutTransportationInput>
  }

  export type UserPackageCreateManyTransportationInputEnvelope = {
    data: UserPackageCreateManyTransportationInput | UserPackageCreateManyTransportationInput[]
    skipDuplicates?: boolean
  }

  export type UserPackageCreateWithoutFlightInput = {
    id?: string
    number_of_pax: number
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    UserPackageOrders?: UserPackageOrderCreateNestedManyWithoutUserPackageInput
    transportation?: UserPackageOptionCreateNestedOneWithoutTransportationsInput
    hotelMekkah?: UserPackageOptionCreateNestedOneWithoutHotelMekkahsInput
    hotelMadinah?: UserPackageOptionCreateNestedOneWithoutHotelMadinahsInput
    muthawif?: UserPackageOptionCreateNestedOneWithoutMuthawifsInput
    handling?: UserPackageOptionCreateNestedOneWithoutHandlingsInput
  }

  export type UserPackageUncheckedCreateWithoutFlightInput = {
    id?: string
    transportation_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    muthawif_id?: string | null
    handling_id?: string | null
    number_of_pax: number
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    UserPackageOrders?: UserPackageOrderUncheckedCreateNestedManyWithoutUserPackageInput
  }

  export type UserPackageCreateOrConnectWithoutFlightInput = {
    where: UserPackageWhereUniqueInput
    create: XOR<UserPackageCreateWithoutFlightInput, UserPackageUncheckedCreateWithoutFlightInput>
  }

  export type UserPackageCreateManyFlightInputEnvelope = {
    data: UserPackageCreateManyFlightInput | UserPackageCreateManyFlightInput[]
    skipDuplicates?: boolean
  }

  export type UserPackageCreateWithoutHotelMekkahInput = {
    id?: string
    number_of_pax: number
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    UserPackageOrders?: UserPackageOrderCreateNestedManyWithoutUserPackageInput
    transportation?: UserPackageOptionCreateNestedOneWithoutTransportationsInput
    flight?: UserPackageOptionCreateNestedOneWithoutFlightsInput
    hotelMadinah?: UserPackageOptionCreateNestedOneWithoutHotelMadinahsInput
    muthawif?: UserPackageOptionCreateNestedOneWithoutMuthawifsInput
    handling?: UserPackageOptionCreateNestedOneWithoutHandlingsInput
  }

  export type UserPackageUncheckedCreateWithoutHotelMekkahInput = {
    id?: string
    transportation_id?: string | null
    flight_id?: string | null
    hotel_madinah_id?: string | null
    muthawif_id?: string | null
    handling_id?: string | null
    number_of_pax: number
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    UserPackageOrders?: UserPackageOrderUncheckedCreateNestedManyWithoutUserPackageInput
  }

  export type UserPackageCreateOrConnectWithoutHotelMekkahInput = {
    where: UserPackageWhereUniqueInput
    create: XOR<UserPackageCreateWithoutHotelMekkahInput, UserPackageUncheckedCreateWithoutHotelMekkahInput>
  }

  export type UserPackageCreateManyHotelMekkahInputEnvelope = {
    data: UserPackageCreateManyHotelMekkahInput | UserPackageCreateManyHotelMekkahInput[]
    skipDuplicates?: boolean
  }

  export type UserPackageCreateWithoutHotelMadinahInput = {
    id?: string
    number_of_pax: number
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    UserPackageOrders?: UserPackageOrderCreateNestedManyWithoutUserPackageInput
    transportation?: UserPackageOptionCreateNestedOneWithoutTransportationsInput
    flight?: UserPackageOptionCreateNestedOneWithoutFlightsInput
    hotelMekkah?: UserPackageOptionCreateNestedOneWithoutHotelMekkahsInput
    muthawif?: UserPackageOptionCreateNestedOneWithoutMuthawifsInput
    handling?: UserPackageOptionCreateNestedOneWithoutHandlingsInput
  }

  export type UserPackageUncheckedCreateWithoutHotelMadinahInput = {
    id?: string
    transportation_id?: string | null
    flight_id?: string | null
    hotel_mekkah_id?: string | null
    muthawif_id?: string | null
    handling_id?: string | null
    number_of_pax: number
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    UserPackageOrders?: UserPackageOrderUncheckedCreateNestedManyWithoutUserPackageInput
  }

  export type UserPackageCreateOrConnectWithoutHotelMadinahInput = {
    where: UserPackageWhereUniqueInput
    create: XOR<UserPackageCreateWithoutHotelMadinahInput, UserPackageUncheckedCreateWithoutHotelMadinahInput>
  }

  export type UserPackageCreateManyHotelMadinahInputEnvelope = {
    data: UserPackageCreateManyHotelMadinahInput | UserPackageCreateManyHotelMadinahInput[]
    skipDuplicates?: boolean
  }

  export type UserPackageCreateWithoutMuthawifInput = {
    id?: string
    number_of_pax: number
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    UserPackageOrders?: UserPackageOrderCreateNestedManyWithoutUserPackageInput
    transportation?: UserPackageOptionCreateNestedOneWithoutTransportationsInput
    flight?: UserPackageOptionCreateNestedOneWithoutFlightsInput
    hotelMekkah?: UserPackageOptionCreateNestedOneWithoutHotelMekkahsInput
    hotelMadinah?: UserPackageOptionCreateNestedOneWithoutHotelMadinahsInput
    handling?: UserPackageOptionCreateNestedOneWithoutHandlingsInput
  }

  export type UserPackageUncheckedCreateWithoutMuthawifInput = {
    id?: string
    transportation_id?: string | null
    flight_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    handling_id?: string | null
    number_of_pax: number
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    UserPackageOrders?: UserPackageOrderUncheckedCreateNestedManyWithoutUserPackageInput
  }

  export type UserPackageCreateOrConnectWithoutMuthawifInput = {
    where: UserPackageWhereUniqueInput
    create: XOR<UserPackageCreateWithoutMuthawifInput, UserPackageUncheckedCreateWithoutMuthawifInput>
  }

  export type UserPackageCreateManyMuthawifInputEnvelope = {
    data: UserPackageCreateManyMuthawifInput | UserPackageCreateManyMuthawifInput[]
    skipDuplicates?: boolean
  }

  export type UserPackageCreateWithoutHandlingInput = {
    id?: string
    number_of_pax: number
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    UserPackageOrders?: UserPackageOrderCreateNestedManyWithoutUserPackageInput
    transportation?: UserPackageOptionCreateNestedOneWithoutTransportationsInput
    flight?: UserPackageOptionCreateNestedOneWithoutFlightsInput
    hotelMekkah?: UserPackageOptionCreateNestedOneWithoutHotelMekkahsInput
    hotelMadinah?: UserPackageOptionCreateNestedOneWithoutHotelMadinahsInput
    muthawif?: UserPackageOptionCreateNestedOneWithoutMuthawifsInput
  }

  export type UserPackageUncheckedCreateWithoutHandlingInput = {
    id?: string
    transportation_id?: string | null
    flight_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    muthawif_id?: string | null
    number_of_pax: number
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    UserPackageOrders?: UserPackageOrderUncheckedCreateNestedManyWithoutUserPackageInput
  }

  export type UserPackageCreateOrConnectWithoutHandlingInput = {
    where: UserPackageWhereUniqueInput
    create: XOR<UserPackageCreateWithoutHandlingInput, UserPackageUncheckedCreateWithoutHandlingInput>
  }

  export type UserPackageCreateManyHandlingInputEnvelope = {
    data: UserPackageCreateManyHandlingInput | UserPackageCreateManyHandlingInput[]
    skipDuplicates?: boolean
  }

  export type PackageTypeCreateWithoutUserPackageOptionsInput = {
    id?: string
    name: string
    is_public?: boolean
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type PackageTypeUncheckedCreateWithoutUserPackageOptionsInput = {
    id?: string
    name: string
    is_public?: boolean
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type PackageTypeCreateOrConnectWithoutUserPackageOptionsInput = {
    where: PackageTypeWhereUniqueInput
    create: XOR<PackageTypeCreateWithoutUserPackageOptionsInput, PackageTypeUncheckedCreateWithoutUserPackageOptionsInput>
  }

  export type UserPackageUpsertWithWhereUniqueWithoutTransportationInput = {
    where: UserPackageWhereUniqueInput
    update: XOR<UserPackageUpdateWithoutTransportationInput, UserPackageUncheckedUpdateWithoutTransportationInput>
    create: XOR<UserPackageCreateWithoutTransportationInput, UserPackageUncheckedCreateWithoutTransportationInput>
  }

  export type UserPackageUpdateWithWhereUniqueWithoutTransportationInput = {
    where: UserPackageWhereUniqueInput
    data: XOR<UserPackageUpdateWithoutTransportationInput, UserPackageUncheckedUpdateWithoutTransportationInput>
  }

  export type UserPackageUpdateManyWithWhereWithoutTransportationInput = {
    where: UserPackageScalarWhereInput
    data: XOR<UserPackageUpdateManyMutationInput, UserPackageUncheckedUpdateManyWithoutTransportationInput>
  }

  export type UserPackageScalarWhereInput = {
    AND?: UserPackageScalarWhereInput | UserPackageScalarWhereInput[]
    OR?: UserPackageScalarWhereInput[]
    NOT?: UserPackageScalarWhereInput | UserPackageScalarWhereInput[]
    id?: StringFilter<"UserPackage"> | string
    transportation_id?: StringNullableFilter<"UserPackage"> | string | null
    flight_id?: StringNullableFilter<"UserPackage"> | string | null
    hotel_mekkah_id?: StringNullableFilter<"UserPackage"> | string | null
    hotel_madinah_id?: StringNullableFilter<"UserPackage"> | string | null
    muthawif_id?: StringNullableFilter<"UserPackage"> | string | null
    handling_id?: StringNullableFilter<"UserPackage"> | string | null
    number_of_pax?: IntFilter<"UserPackage"> | number
    travel_duration?: IntFilter<"UserPackage"> | number
    mekkah_duration?: IntFilter<"UserPackage"> | number
    madinah_duration?: IntFilter<"UserPackage"> | number
    per_pax_price?: DecimalFilter<"UserPackage"> | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFilter<"UserPackage"> | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFilter<"UserPackage"> | Date | string
    updated_at?: DateTimeFilter<"UserPackage"> | Date | string
  }

  export type UserPackageUpsertWithWhereUniqueWithoutFlightInput = {
    where: UserPackageWhereUniqueInput
    update: XOR<UserPackageUpdateWithoutFlightInput, UserPackageUncheckedUpdateWithoutFlightInput>
    create: XOR<UserPackageCreateWithoutFlightInput, UserPackageUncheckedCreateWithoutFlightInput>
  }

  export type UserPackageUpdateWithWhereUniqueWithoutFlightInput = {
    where: UserPackageWhereUniqueInput
    data: XOR<UserPackageUpdateWithoutFlightInput, UserPackageUncheckedUpdateWithoutFlightInput>
  }

  export type UserPackageUpdateManyWithWhereWithoutFlightInput = {
    where: UserPackageScalarWhereInput
    data: XOR<UserPackageUpdateManyMutationInput, UserPackageUncheckedUpdateManyWithoutFlightInput>
  }

  export type UserPackageUpsertWithWhereUniqueWithoutHotelMekkahInput = {
    where: UserPackageWhereUniqueInput
    update: XOR<UserPackageUpdateWithoutHotelMekkahInput, UserPackageUncheckedUpdateWithoutHotelMekkahInput>
    create: XOR<UserPackageCreateWithoutHotelMekkahInput, UserPackageUncheckedCreateWithoutHotelMekkahInput>
  }

  export type UserPackageUpdateWithWhereUniqueWithoutHotelMekkahInput = {
    where: UserPackageWhereUniqueInput
    data: XOR<UserPackageUpdateWithoutHotelMekkahInput, UserPackageUncheckedUpdateWithoutHotelMekkahInput>
  }

  export type UserPackageUpdateManyWithWhereWithoutHotelMekkahInput = {
    where: UserPackageScalarWhereInput
    data: XOR<UserPackageUpdateManyMutationInput, UserPackageUncheckedUpdateManyWithoutHotelMekkahInput>
  }

  export type UserPackageUpsertWithWhereUniqueWithoutHotelMadinahInput = {
    where: UserPackageWhereUniqueInput
    update: XOR<UserPackageUpdateWithoutHotelMadinahInput, UserPackageUncheckedUpdateWithoutHotelMadinahInput>
    create: XOR<UserPackageCreateWithoutHotelMadinahInput, UserPackageUncheckedCreateWithoutHotelMadinahInput>
  }

  export type UserPackageUpdateWithWhereUniqueWithoutHotelMadinahInput = {
    where: UserPackageWhereUniqueInput
    data: XOR<UserPackageUpdateWithoutHotelMadinahInput, UserPackageUncheckedUpdateWithoutHotelMadinahInput>
  }

  export type UserPackageUpdateManyWithWhereWithoutHotelMadinahInput = {
    where: UserPackageScalarWhereInput
    data: XOR<UserPackageUpdateManyMutationInput, UserPackageUncheckedUpdateManyWithoutHotelMadinahInput>
  }

  export type UserPackageUpsertWithWhereUniqueWithoutMuthawifInput = {
    where: UserPackageWhereUniqueInput
    update: XOR<UserPackageUpdateWithoutMuthawifInput, UserPackageUncheckedUpdateWithoutMuthawifInput>
    create: XOR<UserPackageCreateWithoutMuthawifInput, UserPackageUncheckedCreateWithoutMuthawifInput>
  }

  export type UserPackageUpdateWithWhereUniqueWithoutMuthawifInput = {
    where: UserPackageWhereUniqueInput
    data: XOR<UserPackageUpdateWithoutMuthawifInput, UserPackageUncheckedUpdateWithoutMuthawifInput>
  }

  export type UserPackageUpdateManyWithWhereWithoutMuthawifInput = {
    where: UserPackageScalarWhereInput
    data: XOR<UserPackageUpdateManyMutationInput, UserPackageUncheckedUpdateManyWithoutMuthawifInput>
  }

  export type UserPackageUpsertWithWhereUniqueWithoutHandlingInput = {
    where: UserPackageWhereUniqueInput
    update: XOR<UserPackageUpdateWithoutHandlingInput, UserPackageUncheckedUpdateWithoutHandlingInput>
    create: XOR<UserPackageCreateWithoutHandlingInput, UserPackageUncheckedCreateWithoutHandlingInput>
  }

  export type UserPackageUpdateWithWhereUniqueWithoutHandlingInput = {
    where: UserPackageWhereUniqueInput
    data: XOR<UserPackageUpdateWithoutHandlingInput, UserPackageUncheckedUpdateWithoutHandlingInput>
  }

  export type UserPackageUpdateManyWithWhereWithoutHandlingInput = {
    where: UserPackageScalarWhereInput
    data: XOR<UserPackageUpdateManyMutationInput, UserPackageUncheckedUpdateManyWithoutHandlingInput>
  }

  export type PackageTypeUpsertWithoutUserPackageOptionsInput = {
    update: XOR<PackageTypeUpdateWithoutUserPackageOptionsInput, PackageTypeUncheckedUpdateWithoutUserPackageOptionsInput>
    create: XOR<PackageTypeCreateWithoutUserPackageOptionsInput, PackageTypeUncheckedCreateWithoutUserPackageOptionsInput>
    where?: PackageTypeWhereInput
  }

  export type PackageTypeUpdateToOneWithWhereWithoutUserPackageOptionsInput = {
    where?: PackageTypeWhereInput
    data: XOR<PackageTypeUpdateWithoutUserPackageOptionsInput, PackageTypeUncheckedUpdateWithoutUserPackageOptionsInput>
  }

  export type PackageTypeUpdateWithoutUserPackageOptionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    is_public?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PackageTypeUncheckedUpdateWithoutUserPackageOptionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    is_public?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserPackageCreateWithoutUserPackageOrdersInput = {
    id?: string
    number_of_pax: number
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    transportation?: UserPackageOptionCreateNestedOneWithoutTransportationsInput
    flight?: UserPackageOptionCreateNestedOneWithoutFlightsInput
    hotelMekkah?: UserPackageOptionCreateNestedOneWithoutHotelMekkahsInput
    hotelMadinah?: UserPackageOptionCreateNestedOneWithoutHotelMadinahsInput
    muthawif?: UserPackageOptionCreateNestedOneWithoutMuthawifsInput
    handling?: UserPackageOptionCreateNestedOneWithoutHandlingsInput
  }

  export type UserPackageUncheckedCreateWithoutUserPackageOrdersInput = {
    id?: string
    transportation_id?: string | null
    flight_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    muthawif_id?: string | null
    handling_id?: string | null
    number_of_pax: number
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type UserPackageCreateOrConnectWithoutUserPackageOrdersInput = {
    where: UserPackageWhereUniqueInput
    create: XOR<UserPackageCreateWithoutUserPackageOrdersInput, UserPackageUncheckedCreateWithoutUserPackageOrdersInput>
  }

  export type UserPackageUpsertWithoutUserPackageOrdersInput = {
    update: XOR<UserPackageUpdateWithoutUserPackageOrdersInput, UserPackageUncheckedUpdateWithoutUserPackageOrdersInput>
    create: XOR<UserPackageCreateWithoutUserPackageOrdersInput, UserPackageUncheckedCreateWithoutUserPackageOrdersInput>
    where?: UserPackageWhereInput
  }

  export type UserPackageUpdateToOneWithWhereWithoutUserPackageOrdersInput = {
    where?: UserPackageWhereInput
    data: XOR<UserPackageUpdateWithoutUserPackageOrdersInput, UserPackageUncheckedUpdateWithoutUserPackageOrdersInput>
  }

  export type UserPackageUpdateWithoutUserPackageOrdersInput = {
    id?: StringFieldUpdateOperationsInput | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    transportation?: UserPackageOptionUpdateOneWithoutTransportationsNestedInput
    flight?: UserPackageOptionUpdateOneWithoutFlightsNestedInput
    hotelMekkah?: UserPackageOptionUpdateOneWithoutHotelMekkahsNestedInput
    hotelMadinah?: UserPackageOptionUpdateOneWithoutHotelMadinahsNestedInput
    muthawif?: UserPackageOptionUpdateOneWithoutMuthawifsNestedInput
    handling?: UserPackageOptionUpdateOneWithoutHandlingsNestedInput
  }

  export type UserPackageUncheckedUpdateWithoutUserPackageOrdersInput = {
    id?: StringFieldUpdateOperationsInput | string
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    flight_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProductCategoryCreateWithoutCategoryInput = {
    id?: string
    Product: ProductCreateNestedOneWithoutProductCategoriesInput
  }

  export type ProductCategoryUncheckedCreateWithoutCategoryInput = {
    id?: string
    product_id: string
  }

  export type ProductCategoryCreateOrConnectWithoutCategoryInput = {
    where: ProductCategoryWhereUniqueInput
    create: XOR<ProductCategoryCreateWithoutCategoryInput, ProductCategoryUncheckedCreateWithoutCategoryInput>
  }

  export type ProductCategoryCreateManyCategoryInputEnvelope = {
    data: ProductCategoryCreateManyCategoryInput | ProductCategoryCreateManyCategoryInput[]
    skipDuplicates?: boolean
  }

  export type ProductCategoryUpsertWithWhereUniqueWithoutCategoryInput = {
    where: ProductCategoryWhereUniqueInput
    update: XOR<ProductCategoryUpdateWithoutCategoryInput, ProductCategoryUncheckedUpdateWithoutCategoryInput>
    create: XOR<ProductCategoryCreateWithoutCategoryInput, ProductCategoryUncheckedCreateWithoutCategoryInput>
  }

  export type ProductCategoryUpdateWithWhereUniqueWithoutCategoryInput = {
    where: ProductCategoryWhereUniqueInput
    data: XOR<ProductCategoryUpdateWithoutCategoryInput, ProductCategoryUncheckedUpdateWithoutCategoryInput>
  }

  export type ProductCategoryUpdateManyWithWhereWithoutCategoryInput = {
    where: ProductCategoryScalarWhereInput
    data: XOR<ProductCategoryUpdateManyMutationInput, ProductCategoryUncheckedUpdateManyWithoutCategoryInput>
  }

  export type ProductCategoryScalarWhereInput = {
    AND?: ProductCategoryScalarWhereInput | ProductCategoryScalarWhereInput[]
    OR?: ProductCategoryScalarWhereInput[]
    NOT?: ProductCategoryScalarWhereInput | ProductCategoryScalarWhereInput[]
    id?: StringFilter<"ProductCategory"> | string
    product_id?: StringFilter<"ProductCategory"> | string
    category_id?: StringFilter<"ProductCategory"> | string
  }

  export type ProductThumbnailCreateWithoutProductInput = {
    id?: string
    increment?: number
    image_url: string
  }

  export type ProductThumbnailUncheckedCreateWithoutProductInput = {
    id?: string
    increment?: number
    image_url: string
  }

  export type ProductThumbnailCreateOrConnectWithoutProductInput = {
    where: ProductThumbnailWhereUniqueInput
    create: XOR<ProductThumbnailCreateWithoutProductInput, ProductThumbnailUncheckedCreateWithoutProductInput>
  }

  export type ProductThumbnailCreateManyProductInputEnvelope = {
    data: ProductThumbnailCreateManyProductInput | ProductThumbnailCreateManyProductInput[]
    skipDuplicates?: boolean
  }

  export type ProductCategoryCreateWithoutProductInput = {
    id?: string
    Category: CategoryCreateNestedOneWithoutProductCategoriesInput
  }

  export type ProductCategoryUncheckedCreateWithoutProductInput = {
    id?: string
    category_id: string
  }

  export type ProductCategoryCreateOrConnectWithoutProductInput = {
    where: ProductCategoryWhereUniqueInput
    create: XOR<ProductCategoryCreateWithoutProductInput, ProductCategoryUncheckedCreateWithoutProductInput>
  }

  export type ProductCategoryCreateManyProductInputEnvelope = {
    data: ProductCategoryCreateManyProductInput | ProductCategoryCreateManyProductInput[]
    skipDuplicates?: boolean
  }

  export type ProductVariationCreateWithoutProductInput = {
    id?: string
    increment?: number
    name: string
    price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    ProductOrders?: ProductOrderCreateNestedManyWithoutProductVariationInput
  }

  export type ProductVariationUncheckedCreateWithoutProductInput = {
    id?: string
    increment?: number
    name: string
    price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    ProductOrders?: ProductOrderUncheckedCreateNestedManyWithoutProductVariationInput
  }

  export type ProductVariationCreateOrConnectWithoutProductInput = {
    where: ProductVariationWhereUniqueInput
    create: XOR<ProductVariationCreateWithoutProductInput, ProductVariationUncheckedCreateWithoutProductInput>
  }

  export type ProductVariationCreateManyProductInputEnvelope = {
    data: ProductVariationCreateManyProductInput | ProductVariationCreateManyProductInput[]
    skipDuplicates?: boolean
  }

  export type ProductIncludeCreateWithoutProductInput = {
    id?: string
    increment?: number
    description: string
  }

  export type ProductIncludeUncheckedCreateWithoutProductInput = {
    id?: string
    increment?: number
    description: string
  }

  export type ProductIncludeCreateOrConnectWithoutProductInput = {
    where: ProductIncludeWhereUniqueInput
    create: XOR<ProductIncludeCreateWithoutProductInput, ProductIncludeUncheckedCreateWithoutProductInput>
  }

  export type ProductIncludeCreateManyProductInputEnvelope = {
    data: ProductIncludeCreateManyProductInput | ProductIncludeCreateManyProductInput[]
    skipDuplicates?: boolean
  }

  export type ProductExcludeCreateWithoutProductInput = {
    id?: string
    increment?: number
    description: string
  }

  export type ProductExcludeUncheckedCreateWithoutProductInput = {
    id?: string
    increment?: number
    description: string
  }

  export type ProductExcludeCreateOrConnectWithoutProductInput = {
    where: ProductExcludeWhereUniqueInput
    create: XOR<ProductExcludeCreateWithoutProductInput, ProductExcludeUncheckedCreateWithoutProductInput>
  }

  export type ProductExcludeCreateManyProductInputEnvelope = {
    data: ProductExcludeCreateManyProductInput | ProductExcludeCreateManyProductInput[]
    skipDuplicates?: boolean
  }

  export type ProductOrderCreateWithoutProductInput = {
    id?: string
    departure: Date | string
    number_of_pax: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    User: UserCreateNestedOneWithoutProductOrdersInput
    ProductVariation?: ProductVariationCreateNestedOneWithoutProductOrdersInput
  }

  export type ProductOrderUncheckedCreateWithoutProductInput = {
    id?: string
    user_id: string
    variation_id?: string | null
    departure: Date | string
    number_of_pax: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type ProductOrderCreateOrConnectWithoutProductInput = {
    where: ProductOrderWhereUniqueInput
    create: XOR<ProductOrderCreateWithoutProductInput, ProductOrderUncheckedCreateWithoutProductInput>
  }

  export type ProductOrderCreateManyProductInputEnvelope = {
    data: ProductOrderCreateManyProductInput | ProductOrderCreateManyProductInput[]
    skipDuplicates?: boolean
  }

  export type ProductThumbnailUpsertWithWhereUniqueWithoutProductInput = {
    where: ProductThumbnailWhereUniqueInput
    update: XOR<ProductThumbnailUpdateWithoutProductInput, ProductThumbnailUncheckedUpdateWithoutProductInput>
    create: XOR<ProductThumbnailCreateWithoutProductInput, ProductThumbnailUncheckedCreateWithoutProductInput>
  }

  export type ProductThumbnailUpdateWithWhereUniqueWithoutProductInput = {
    where: ProductThumbnailWhereUniqueInput
    data: XOR<ProductThumbnailUpdateWithoutProductInput, ProductThumbnailUncheckedUpdateWithoutProductInput>
  }

  export type ProductThumbnailUpdateManyWithWhereWithoutProductInput = {
    where: ProductThumbnailScalarWhereInput
    data: XOR<ProductThumbnailUpdateManyMutationInput, ProductThumbnailUncheckedUpdateManyWithoutProductInput>
  }

  export type ProductThumbnailScalarWhereInput = {
    AND?: ProductThumbnailScalarWhereInput | ProductThumbnailScalarWhereInput[]
    OR?: ProductThumbnailScalarWhereInput[]
    NOT?: ProductThumbnailScalarWhereInput | ProductThumbnailScalarWhereInput[]
    id?: StringFilter<"ProductThumbnail"> | string
    increment?: IntFilter<"ProductThumbnail"> | number
    product_id?: StringFilter<"ProductThumbnail"> | string
    image_url?: StringFilter<"ProductThumbnail"> | string
  }

  export type ProductCategoryUpsertWithWhereUniqueWithoutProductInput = {
    where: ProductCategoryWhereUniqueInput
    update: XOR<ProductCategoryUpdateWithoutProductInput, ProductCategoryUncheckedUpdateWithoutProductInput>
    create: XOR<ProductCategoryCreateWithoutProductInput, ProductCategoryUncheckedCreateWithoutProductInput>
  }

  export type ProductCategoryUpdateWithWhereUniqueWithoutProductInput = {
    where: ProductCategoryWhereUniqueInput
    data: XOR<ProductCategoryUpdateWithoutProductInput, ProductCategoryUncheckedUpdateWithoutProductInput>
  }

  export type ProductCategoryUpdateManyWithWhereWithoutProductInput = {
    where: ProductCategoryScalarWhereInput
    data: XOR<ProductCategoryUpdateManyMutationInput, ProductCategoryUncheckedUpdateManyWithoutProductInput>
  }

  export type ProductVariationUpsertWithWhereUniqueWithoutProductInput = {
    where: ProductVariationWhereUniqueInput
    update: XOR<ProductVariationUpdateWithoutProductInput, ProductVariationUncheckedUpdateWithoutProductInput>
    create: XOR<ProductVariationCreateWithoutProductInput, ProductVariationUncheckedCreateWithoutProductInput>
  }

  export type ProductVariationUpdateWithWhereUniqueWithoutProductInput = {
    where: ProductVariationWhereUniqueInput
    data: XOR<ProductVariationUpdateWithoutProductInput, ProductVariationUncheckedUpdateWithoutProductInput>
  }

  export type ProductVariationUpdateManyWithWhereWithoutProductInput = {
    where: ProductVariationScalarWhereInput
    data: XOR<ProductVariationUpdateManyMutationInput, ProductVariationUncheckedUpdateManyWithoutProductInput>
  }

  export type ProductVariationScalarWhereInput = {
    AND?: ProductVariationScalarWhereInput | ProductVariationScalarWhereInput[]
    OR?: ProductVariationScalarWhereInput[]
    NOT?: ProductVariationScalarWhereInput | ProductVariationScalarWhereInput[]
    id?: StringFilter<"ProductVariation"> | string
    increment?: IntFilter<"ProductVariation"> | number
    product_id?: StringFilter<"ProductVariation"> | string
    name?: StringFilter<"ProductVariation"> | string
    price?: DecimalFilter<"ProductVariation"> | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFilter<"ProductVariation"> | Date | string
    updated_at?: DateTimeFilter<"ProductVariation"> | Date | string
  }

  export type ProductIncludeUpsertWithWhereUniqueWithoutProductInput = {
    where: ProductIncludeWhereUniqueInput
    update: XOR<ProductIncludeUpdateWithoutProductInput, ProductIncludeUncheckedUpdateWithoutProductInput>
    create: XOR<ProductIncludeCreateWithoutProductInput, ProductIncludeUncheckedCreateWithoutProductInput>
  }

  export type ProductIncludeUpdateWithWhereUniqueWithoutProductInput = {
    where: ProductIncludeWhereUniqueInput
    data: XOR<ProductIncludeUpdateWithoutProductInput, ProductIncludeUncheckedUpdateWithoutProductInput>
  }

  export type ProductIncludeUpdateManyWithWhereWithoutProductInput = {
    where: ProductIncludeScalarWhereInput
    data: XOR<ProductIncludeUpdateManyMutationInput, ProductIncludeUncheckedUpdateManyWithoutProductInput>
  }

  export type ProductIncludeScalarWhereInput = {
    AND?: ProductIncludeScalarWhereInput | ProductIncludeScalarWhereInput[]
    OR?: ProductIncludeScalarWhereInput[]
    NOT?: ProductIncludeScalarWhereInput | ProductIncludeScalarWhereInput[]
    id?: StringFilter<"ProductInclude"> | string
    increment?: IntFilter<"ProductInclude"> | number
    product_id?: StringFilter<"ProductInclude"> | string
    description?: StringFilter<"ProductInclude"> | string
  }

  export type ProductExcludeUpsertWithWhereUniqueWithoutProductInput = {
    where: ProductExcludeWhereUniqueInput
    update: XOR<ProductExcludeUpdateWithoutProductInput, ProductExcludeUncheckedUpdateWithoutProductInput>
    create: XOR<ProductExcludeCreateWithoutProductInput, ProductExcludeUncheckedCreateWithoutProductInput>
  }

  export type ProductExcludeUpdateWithWhereUniqueWithoutProductInput = {
    where: ProductExcludeWhereUniqueInput
    data: XOR<ProductExcludeUpdateWithoutProductInput, ProductExcludeUncheckedUpdateWithoutProductInput>
  }

  export type ProductExcludeUpdateManyWithWhereWithoutProductInput = {
    where: ProductExcludeScalarWhereInput
    data: XOR<ProductExcludeUpdateManyMutationInput, ProductExcludeUncheckedUpdateManyWithoutProductInput>
  }

  export type ProductExcludeScalarWhereInput = {
    AND?: ProductExcludeScalarWhereInput | ProductExcludeScalarWhereInput[]
    OR?: ProductExcludeScalarWhereInput[]
    NOT?: ProductExcludeScalarWhereInput | ProductExcludeScalarWhereInput[]
    id?: StringFilter<"ProductExclude"> | string
    increment?: IntFilter<"ProductExclude"> | number
    product_id?: StringFilter<"ProductExclude"> | string
    description?: StringFilter<"ProductExclude"> | string
  }

  export type ProductOrderUpsertWithWhereUniqueWithoutProductInput = {
    where: ProductOrderWhereUniqueInput
    update: XOR<ProductOrderUpdateWithoutProductInput, ProductOrderUncheckedUpdateWithoutProductInput>
    create: XOR<ProductOrderCreateWithoutProductInput, ProductOrderUncheckedCreateWithoutProductInput>
  }

  export type ProductOrderUpdateWithWhereUniqueWithoutProductInput = {
    where: ProductOrderWhereUniqueInput
    data: XOR<ProductOrderUpdateWithoutProductInput, ProductOrderUncheckedUpdateWithoutProductInput>
  }

  export type ProductOrderUpdateManyWithWhereWithoutProductInput = {
    where: ProductOrderScalarWhereInput
    data: XOR<ProductOrderUpdateManyMutationInput, ProductOrderUncheckedUpdateManyWithoutProductInput>
  }

  export type ProductCreateWithoutProductThumbnailsInput = {
    id?: string
    name: string
    description?: string | null
    price?: Decimal | DecimalJsLike | number | string
    has_variation?: boolean
    created_at?: Date | string
    updated_at?: Date | string
    ProductCategories?: ProductCategoryCreateNestedManyWithoutProductInput
    ProductVariations?: ProductVariationCreateNestedManyWithoutProductInput
    ProductIncludes?: ProductIncludeCreateNestedManyWithoutProductInput
    ProductExcludes?: ProductExcludeCreateNestedManyWithoutProductInput
    ProductOrders?: ProductOrderCreateNestedManyWithoutProductInput
  }

  export type ProductUncheckedCreateWithoutProductThumbnailsInput = {
    id?: string
    name: string
    description?: string | null
    price?: Decimal | DecimalJsLike | number | string
    has_variation?: boolean
    created_at?: Date | string
    updated_at?: Date | string
    ProductCategories?: ProductCategoryUncheckedCreateNestedManyWithoutProductInput
    ProductVariations?: ProductVariationUncheckedCreateNestedManyWithoutProductInput
    ProductIncludes?: ProductIncludeUncheckedCreateNestedManyWithoutProductInput
    ProductExcludes?: ProductExcludeUncheckedCreateNestedManyWithoutProductInput
    ProductOrders?: ProductOrderUncheckedCreateNestedManyWithoutProductInput
  }

  export type ProductCreateOrConnectWithoutProductThumbnailsInput = {
    where: ProductWhereUniqueInput
    create: XOR<ProductCreateWithoutProductThumbnailsInput, ProductUncheckedCreateWithoutProductThumbnailsInput>
  }

  export type ProductUpsertWithoutProductThumbnailsInput = {
    update: XOR<ProductUpdateWithoutProductThumbnailsInput, ProductUncheckedUpdateWithoutProductThumbnailsInput>
    create: XOR<ProductCreateWithoutProductThumbnailsInput, ProductUncheckedCreateWithoutProductThumbnailsInput>
    where?: ProductWhereInput
  }

  export type ProductUpdateToOneWithWhereWithoutProductThumbnailsInput = {
    where?: ProductWhereInput
    data: XOR<ProductUpdateWithoutProductThumbnailsInput, ProductUncheckedUpdateWithoutProductThumbnailsInput>
  }

  export type ProductUpdateWithoutProductThumbnailsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    has_variation?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ProductCategories?: ProductCategoryUpdateManyWithoutProductNestedInput
    ProductVariations?: ProductVariationUpdateManyWithoutProductNestedInput
    ProductIncludes?: ProductIncludeUpdateManyWithoutProductNestedInput
    ProductExcludes?: ProductExcludeUpdateManyWithoutProductNestedInput
    ProductOrders?: ProductOrderUpdateManyWithoutProductNestedInput
  }

  export type ProductUncheckedUpdateWithoutProductThumbnailsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    has_variation?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ProductCategories?: ProductCategoryUncheckedUpdateManyWithoutProductNestedInput
    ProductVariations?: ProductVariationUncheckedUpdateManyWithoutProductNestedInput
    ProductIncludes?: ProductIncludeUncheckedUpdateManyWithoutProductNestedInput
    ProductExcludes?: ProductExcludeUncheckedUpdateManyWithoutProductNestedInput
    ProductOrders?: ProductOrderUncheckedUpdateManyWithoutProductNestedInput
  }

  export type ProductCreateWithoutProductCategoriesInput = {
    id?: string
    name: string
    description?: string | null
    price?: Decimal | DecimalJsLike | number | string
    has_variation?: boolean
    created_at?: Date | string
    updated_at?: Date | string
    ProductThumbnails?: ProductThumbnailCreateNestedManyWithoutProductInput
    ProductVariations?: ProductVariationCreateNestedManyWithoutProductInput
    ProductIncludes?: ProductIncludeCreateNestedManyWithoutProductInput
    ProductExcludes?: ProductExcludeCreateNestedManyWithoutProductInput
    ProductOrders?: ProductOrderCreateNestedManyWithoutProductInput
  }

  export type ProductUncheckedCreateWithoutProductCategoriesInput = {
    id?: string
    name: string
    description?: string | null
    price?: Decimal | DecimalJsLike | number | string
    has_variation?: boolean
    created_at?: Date | string
    updated_at?: Date | string
    ProductThumbnails?: ProductThumbnailUncheckedCreateNestedManyWithoutProductInput
    ProductVariations?: ProductVariationUncheckedCreateNestedManyWithoutProductInput
    ProductIncludes?: ProductIncludeUncheckedCreateNestedManyWithoutProductInput
    ProductExcludes?: ProductExcludeUncheckedCreateNestedManyWithoutProductInput
    ProductOrders?: ProductOrderUncheckedCreateNestedManyWithoutProductInput
  }

  export type ProductCreateOrConnectWithoutProductCategoriesInput = {
    where: ProductWhereUniqueInput
    create: XOR<ProductCreateWithoutProductCategoriesInput, ProductUncheckedCreateWithoutProductCategoriesInput>
  }

  export type CategoryCreateWithoutProductCategoriesInput = {
    id?: string
    name: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type CategoryUncheckedCreateWithoutProductCategoriesInput = {
    id?: string
    name: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type CategoryCreateOrConnectWithoutProductCategoriesInput = {
    where: CategoryWhereUniqueInput
    create: XOR<CategoryCreateWithoutProductCategoriesInput, CategoryUncheckedCreateWithoutProductCategoriesInput>
  }

  export type ProductUpsertWithoutProductCategoriesInput = {
    update: XOR<ProductUpdateWithoutProductCategoriesInput, ProductUncheckedUpdateWithoutProductCategoriesInput>
    create: XOR<ProductCreateWithoutProductCategoriesInput, ProductUncheckedCreateWithoutProductCategoriesInput>
    where?: ProductWhereInput
  }

  export type ProductUpdateToOneWithWhereWithoutProductCategoriesInput = {
    where?: ProductWhereInput
    data: XOR<ProductUpdateWithoutProductCategoriesInput, ProductUncheckedUpdateWithoutProductCategoriesInput>
  }

  export type ProductUpdateWithoutProductCategoriesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    has_variation?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ProductThumbnails?: ProductThumbnailUpdateManyWithoutProductNestedInput
    ProductVariations?: ProductVariationUpdateManyWithoutProductNestedInput
    ProductIncludes?: ProductIncludeUpdateManyWithoutProductNestedInput
    ProductExcludes?: ProductExcludeUpdateManyWithoutProductNestedInput
    ProductOrders?: ProductOrderUpdateManyWithoutProductNestedInput
  }

  export type ProductUncheckedUpdateWithoutProductCategoriesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    has_variation?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ProductThumbnails?: ProductThumbnailUncheckedUpdateManyWithoutProductNestedInput
    ProductVariations?: ProductVariationUncheckedUpdateManyWithoutProductNestedInput
    ProductIncludes?: ProductIncludeUncheckedUpdateManyWithoutProductNestedInput
    ProductExcludes?: ProductExcludeUncheckedUpdateManyWithoutProductNestedInput
    ProductOrders?: ProductOrderUncheckedUpdateManyWithoutProductNestedInput
  }

  export type CategoryUpsertWithoutProductCategoriesInput = {
    update: XOR<CategoryUpdateWithoutProductCategoriesInput, CategoryUncheckedUpdateWithoutProductCategoriesInput>
    create: XOR<CategoryCreateWithoutProductCategoriesInput, CategoryUncheckedCreateWithoutProductCategoriesInput>
    where?: CategoryWhereInput
  }

  export type CategoryUpdateToOneWithWhereWithoutProductCategoriesInput = {
    where?: CategoryWhereInput
    data: XOR<CategoryUpdateWithoutProductCategoriesInput, CategoryUncheckedUpdateWithoutProductCategoriesInput>
  }

  export type CategoryUpdateWithoutProductCategoriesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CategoryUncheckedUpdateWithoutProductCategoriesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProductOrderCreateWithoutProductVariationInput = {
    id?: string
    departure: Date | string
    number_of_pax: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    User: UserCreateNestedOneWithoutProductOrdersInput
    Product: ProductCreateNestedOneWithoutProductOrdersInput
  }

  export type ProductOrderUncheckedCreateWithoutProductVariationInput = {
    id?: string
    user_id: string
    product_id: string
    departure: Date | string
    number_of_pax: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type ProductOrderCreateOrConnectWithoutProductVariationInput = {
    where: ProductOrderWhereUniqueInput
    create: XOR<ProductOrderCreateWithoutProductVariationInput, ProductOrderUncheckedCreateWithoutProductVariationInput>
  }

  export type ProductOrderCreateManyProductVariationInputEnvelope = {
    data: ProductOrderCreateManyProductVariationInput | ProductOrderCreateManyProductVariationInput[]
    skipDuplicates?: boolean
  }

  export type ProductCreateWithoutProductVariationsInput = {
    id?: string
    name: string
    description?: string | null
    price?: Decimal | DecimalJsLike | number | string
    has_variation?: boolean
    created_at?: Date | string
    updated_at?: Date | string
    ProductThumbnails?: ProductThumbnailCreateNestedManyWithoutProductInput
    ProductCategories?: ProductCategoryCreateNestedManyWithoutProductInput
    ProductIncludes?: ProductIncludeCreateNestedManyWithoutProductInput
    ProductExcludes?: ProductExcludeCreateNestedManyWithoutProductInput
    ProductOrders?: ProductOrderCreateNestedManyWithoutProductInput
  }

  export type ProductUncheckedCreateWithoutProductVariationsInput = {
    id?: string
    name: string
    description?: string | null
    price?: Decimal | DecimalJsLike | number | string
    has_variation?: boolean
    created_at?: Date | string
    updated_at?: Date | string
    ProductThumbnails?: ProductThumbnailUncheckedCreateNestedManyWithoutProductInput
    ProductCategories?: ProductCategoryUncheckedCreateNestedManyWithoutProductInput
    ProductIncludes?: ProductIncludeUncheckedCreateNestedManyWithoutProductInput
    ProductExcludes?: ProductExcludeUncheckedCreateNestedManyWithoutProductInput
    ProductOrders?: ProductOrderUncheckedCreateNestedManyWithoutProductInput
  }

  export type ProductCreateOrConnectWithoutProductVariationsInput = {
    where: ProductWhereUniqueInput
    create: XOR<ProductCreateWithoutProductVariationsInput, ProductUncheckedCreateWithoutProductVariationsInput>
  }

  export type ProductOrderUpsertWithWhereUniqueWithoutProductVariationInput = {
    where: ProductOrderWhereUniqueInput
    update: XOR<ProductOrderUpdateWithoutProductVariationInput, ProductOrderUncheckedUpdateWithoutProductVariationInput>
    create: XOR<ProductOrderCreateWithoutProductVariationInput, ProductOrderUncheckedCreateWithoutProductVariationInput>
  }

  export type ProductOrderUpdateWithWhereUniqueWithoutProductVariationInput = {
    where: ProductOrderWhereUniqueInput
    data: XOR<ProductOrderUpdateWithoutProductVariationInput, ProductOrderUncheckedUpdateWithoutProductVariationInput>
  }

  export type ProductOrderUpdateManyWithWhereWithoutProductVariationInput = {
    where: ProductOrderScalarWhereInput
    data: XOR<ProductOrderUpdateManyMutationInput, ProductOrderUncheckedUpdateManyWithoutProductVariationInput>
  }

  export type ProductUpsertWithoutProductVariationsInput = {
    update: XOR<ProductUpdateWithoutProductVariationsInput, ProductUncheckedUpdateWithoutProductVariationsInput>
    create: XOR<ProductCreateWithoutProductVariationsInput, ProductUncheckedCreateWithoutProductVariationsInput>
    where?: ProductWhereInput
  }

  export type ProductUpdateToOneWithWhereWithoutProductVariationsInput = {
    where?: ProductWhereInput
    data: XOR<ProductUpdateWithoutProductVariationsInput, ProductUncheckedUpdateWithoutProductVariationsInput>
  }

  export type ProductUpdateWithoutProductVariationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    has_variation?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ProductThumbnails?: ProductThumbnailUpdateManyWithoutProductNestedInput
    ProductCategories?: ProductCategoryUpdateManyWithoutProductNestedInput
    ProductIncludes?: ProductIncludeUpdateManyWithoutProductNestedInput
    ProductExcludes?: ProductExcludeUpdateManyWithoutProductNestedInput
    ProductOrders?: ProductOrderUpdateManyWithoutProductNestedInput
  }

  export type ProductUncheckedUpdateWithoutProductVariationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    has_variation?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ProductThumbnails?: ProductThumbnailUncheckedUpdateManyWithoutProductNestedInput
    ProductCategories?: ProductCategoryUncheckedUpdateManyWithoutProductNestedInput
    ProductIncludes?: ProductIncludeUncheckedUpdateManyWithoutProductNestedInput
    ProductExcludes?: ProductExcludeUncheckedUpdateManyWithoutProductNestedInput
    ProductOrders?: ProductOrderUncheckedUpdateManyWithoutProductNestedInput
  }

  export type ProductCreateWithoutProductIncludesInput = {
    id?: string
    name: string
    description?: string | null
    price?: Decimal | DecimalJsLike | number | string
    has_variation?: boolean
    created_at?: Date | string
    updated_at?: Date | string
    ProductThumbnails?: ProductThumbnailCreateNestedManyWithoutProductInput
    ProductCategories?: ProductCategoryCreateNestedManyWithoutProductInput
    ProductVariations?: ProductVariationCreateNestedManyWithoutProductInput
    ProductExcludes?: ProductExcludeCreateNestedManyWithoutProductInput
    ProductOrders?: ProductOrderCreateNestedManyWithoutProductInput
  }

  export type ProductUncheckedCreateWithoutProductIncludesInput = {
    id?: string
    name: string
    description?: string | null
    price?: Decimal | DecimalJsLike | number | string
    has_variation?: boolean
    created_at?: Date | string
    updated_at?: Date | string
    ProductThumbnails?: ProductThumbnailUncheckedCreateNestedManyWithoutProductInput
    ProductCategories?: ProductCategoryUncheckedCreateNestedManyWithoutProductInput
    ProductVariations?: ProductVariationUncheckedCreateNestedManyWithoutProductInput
    ProductExcludes?: ProductExcludeUncheckedCreateNestedManyWithoutProductInput
    ProductOrders?: ProductOrderUncheckedCreateNestedManyWithoutProductInput
  }

  export type ProductCreateOrConnectWithoutProductIncludesInput = {
    where: ProductWhereUniqueInput
    create: XOR<ProductCreateWithoutProductIncludesInput, ProductUncheckedCreateWithoutProductIncludesInput>
  }

  export type ProductUpsertWithoutProductIncludesInput = {
    update: XOR<ProductUpdateWithoutProductIncludesInput, ProductUncheckedUpdateWithoutProductIncludesInput>
    create: XOR<ProductCreateWithoutProductIncludesInput, ProductUncheckedCreateWithoutProductIncludesInput>
    where?: ProductWhereInput
  }

  export type ProductUpdateToOneWithWhereWithoutProductIncludesInput = {
    where?: ProductWhereInput
    data: XOR<ProductUpdateWithoutProductIncludesInput, ProductUncheckedUpdateWithoutProductIncludesInput>
  }

  export type ProductUpdateWithoutProductIncludesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    has_variation?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ProductThumbnails?: ProductThumbnailUpdateManyWithoutProductNestedInput
    ProductCategories?: ProductCategoryUpdateManyWithoutProductNestedInput
    ProductVariations?: ProductVariationUpdateManyWithoutProductNestedInput
    ProductExcludes?: ProductExcludeUpdateManyWithoutProductNestedInput
    ProductOrders?: ProductOrderUpdateManyWithoutProductNestedInput
  }

  export type ProductUncheckedUpdateWithoutProductIncludesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    has_variation?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ProductThumbnails?: ProductThumbnailUncheckedUpdateManyWithoutProductNestedInput
    ProductCategories?: ProductCategoryUncheckedUpdateManyWithoutProductNestedInput
    ProductVariations?: ProductVariationUncheckedUpdateManyWithoutProductNestedInput
    ProductExcludes?: ProductExcludeUncheckedUpdateManyWithoutProductNestedInput
    ProductOrders?: ProductOrderUncheckedUpdateManyWithoutProductNestedInput
  }

  export type ProductCreateWithoutProductExcludesInput = {
    id?: string
    name: string
    description?: string | null
    price?: Decimal | DecimalJsLike | number | string
    has_variation?: boolean
    created_at?: Date | string
    updated_at?: Date | string
    ProductThumbnails?: ProductThumbnailCreateNestedManyWithoutProductInput
    ProductCategories?: ProductCategoryCreateNestedManyWithoutProductInput
    ProductVariations?: ProductVariationCreateNestedManyWithoutProductInput
    ProductIncludes?: ProductIncludeCreateNestedManyWithoutProductInput
    ProductOrders?: ProductOrderCreateNestedManyWithoutProductInput
  }

  export type ProductUncheckedCreateWithoutProductExcludesInput = {
    id?: string
    name: string
    description?: string | null
    price?: Decimal | DecimalJsLike | number | string
    has_variation?: boolean
    created_at?: Date | string
    updated_at?: Date | string
    ProductThumbnails?: ProductThumbnailUncheckedCreateNestedManyWithoutProductInput
    ProductCategories?: ProductCategoryUncheckedCreateNestedManyWithoutProductInput
    ProductVariations?: ProductVariationUncheckedCreateNestedManyWithoutProductInput
    ProductIncludes?: ProductIncludeUncheckedCreateNestedManyWithoutProductInput
    ProductOrders?: ProductOrderUncheckedCreateNestedManyWithoutProductInput
  }

  export type ProductCreateOrConnectWithoutProductExcludesInput = {
    where: ProductWhereUniqueInput
    create: XOR<ProductCreateWithoutProductExcludesInput, ProductUncheckedCreateWithoutProductExcludesInput>
  }

  export type ProductUpsertWithoutProductExcludesInput = {
    update: XOR<ProductUpdateWithoutProductExcludesInput, ProductUncheckedUpdateWithoutProductExcludesInput>
    create: XOR<ProductCreateWithoutProductExcludesInput, ProductUncheckedCreateWithoutProductExcludesInput>
    where?: ProductWhereInput
  }

  export type ProductUpdateToOneWithWhereWithoutProductExcludesInput = {
    where?: ProductWhereInput
    data: XOR<ProductUpdateWithoutProductExcludesInput, ProductUncheckedUpdateWithoutProductExcludesInput>
  }

  export type ProductUpdateWithoutProductExcludesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    has_variation?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ProductThumbnails?: ProductThumbnailUpdateManyWithoutProductNestedInput
    ProductCategories?: ProductCategoryUpdateManyWithoutProductNestedInput
    ProductVariations?: ProductVariationUpdateManyWithoutProductNestedInput
    ProductIncludes?: ProductIncludeUpdateManyWithoutProductNestedInput
    ProductOrders?: ProductOrderUpdateManyWithoutProductNestedInput
  }

  export type ProductUncheckedUpdateWithoutProductExcludesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    has_variation?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ProductThumbnails?: ProductThumbnailUncheckedUpdateManyWithoutProductNestedInput
    ProductCategories?: ProductCategoryUncheckedUpdateManyWithoutProductNestedInput
    ProductVariations?: ProductVariationUncheckedUpdateManyWithoutProductNestedInput
    ProductIncludes?: ProductIncludeUncheckedUpdateManyWithoutProductNestedInput
    ProductOrders?: ProductOrderUncheckedUpdateManyWithoutProductNestedInput
  }

  export type UserCreateWithoutProductOrdersInput = {
    id?: string
    email: string
    full_name: string
    password: string
    whatsapp_number: string
    role?: $Enums.Role
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrder?: MitraPackageOrderCreateNestedManyWithoutUserInput
    MitraRequest?: MitraRequestCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutProductOrdersInput = {
    id?: string
    email: string
    full_name: string
    password: string
    whatsapp_number: string
    role?: $Enums.Role
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrder?: MitraPackageOrderUncheckedCreateNestedManyWithoutUserInput
    MitraRequest?: MitraRequestUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutProductOrdersInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutProductOrdersInput, UserUncheckedCreateWithoutProductOrdersInput>
  }

  export type ProductCreateWithoutProductOrdersInput = {
    id?: string
    name: string
    description?: string | null
    price?: Decimal | DecimalJsLike | number | string
    has_variation?: boolean
    created_at?: Date | string
    updated_at?: Date | string
    ProductThumbnails?: ProductThumbnailCreateNestedManyWithoutProductInput
    ProductCategories?: ProductCategoryCreateNestedManyWithoutProductInput
    ProductVariations?: ProductVariationCreateNestedManyWithoutProductInput
    ProductIncludes?: ProductIncludeCreateNestedManyWithoutProductInput
    ProductExcludes?: ProductExcludeCreateNestedManyWithoutProductInput
  }

  export type ProductUncheckedCreateWithoutProductOrdersInput = {
    id?: string
    name: string
    description?: string | null
    price?: Decimal | DecimalJsLike | number | string
    has_variation?: boolean
    created_at?: Date | string
    updated_at?: Date | string
    ProductThumbnails?: ProductThumbnailUncheckedCreateNestedManyWithoutProductInput
    ProductCategories?: ProductCategoryUncheckedCreateNestedManyWithoutProductInput
    ProductVariations?: ProductVariationUncheckedCreateNestedManyWithoutProductInput
    ProductIncludes?: ProductIncludeUncheckedCreateNestedManyWithoutProductInput
    ProductExcludes?: ProductExcludeUncheckedCreateNestedManyWithoutProductInput
  }

  export type ProductCreateOrConnectWithoutProductOrdersInput = {
    where: ProductWhereUniqueInput
    create: XOR<ProductCreateWithoutProductOrdersInput, ProductUncheckedCreateWithoutProductOrdersInput>
  }

  export type ProductVariationCreateWithoutProductOrdersInput = {
    id?: string
    increment?: number
    name: string
    price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    Product: ProductCreateNestedOneWithoutProductVariationsInput
  }

  export type ProductVariationUncheckedCreateWithoutProductOrdersInput = {
    id?: string
    increment?: number
    product_id: string
    name: string
    price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type ProductVariationCreateOrConnectWithoutProductOrdersInput = {
    where: ProductVariationWhereUniqueInput
    create: XOR<ProductVariationCreateWithoutProductOrdersInput, ProductVariationUncheckedCreateWithoutProductOrdersInput>
  }

  export type UserUpsertWithoutProductOrdersInput = {
    update: XOR<UserUpdateWithoutProductOrdersInput, UserUncheckedUpdateWithoutProductOrdersInput>
    create: XOR<UserCreateWithoutProductOrdersInput, UserUncheckedCreateWithoutProductOrdersInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutProductOrdersInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutProductOrdersInput, UserUncheckedUpdateWithoutProductOrdersInput>
  }

  export type UserUpdateWithoutProductOrdersInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    full_name?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    whatsapp_number?: StringFieldUpdateOperationsInput | string
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrder?: MitraPackageOrderUpdateManyWithoutUserNestedInput
    MitraRequest?: MitraRequestUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutProductOrdersInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    full_name?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    whatsapp_number?: StringFieldUpdateOperationsInput | string
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrder?: MitraPackageOrderUncheckedUpdateManyWithoutUserNestedInput
    MitraRequest?: MitraRequestUncheckedUpdateManyWithoutUserNestedInput
  }

  export type ProductUpsertWithoutProductOrdersInput = {
    update: XOR<ProductUpdateWithoutProductOrdersInput, ProductUncheckedUpdateWithoutProductOrdersInput>
    create: XOR<ProductCreateWithoutProductOrdersInput, ProductUncheckedCreateWithoutProductOrdersInput>
    where?: ProductWhereInput
  }

  export type ProductUpdateToOneWithWhereWithoutProductOrdersInput = {
    where?: ProductWhereInput
    data: XOR<ProductUpdateWithoutProductOrdersInput, ProductUncheckedUpdateWithoutProductOrdersInput>
  }

  export type ProductUpdateWithoutProductOrdersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    has_variation?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ProductThumbnails?: ProductThumbnailUpdateManyWithoutProductNestedInput
    ProductCategories?: ProductCategoryUpdateManyWithoutProductNestedInput
    ProductVariations?: ProductVariationUpdateManyWithoutProductNestedInput
    ProductIncludes?: ProductIncludeUpdateManyWithoutProductNestedInput
    ProductExcludes?: ProductExcludeUpdateManyWithoutProductNestedInput
  }

  export type ProductUncheckedUpdateWithoutProductOrdersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    has_variation?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ProductThumbnails?: ProductThumbnailUncheckedUpdateManyWithoutProductNestedInput
    ProductCategories?: ProductCategoryUncheckedUpdateManyWithoutProductNestedInput
    ProductVariations?: ProductVariationUncheckedUpdateManyWithoutProductNestedInput
    ProductIncludes?: ProductIncludeUncheckedUpdateManyWithoutProductNestedInput
    ProductExcludes?: ProductExcludeUncheckedUpdateManyWithoutProductNestedInput
  }

  export type ProductVariationUpsertWithoutProductOrdersInput = {
    update: XOR<ProductVariationUpdateWithoutProductOrdersInput, ProductVariationUncheckedUpdateWithoutProductOrdersInput>
    create: XOR<ProductVariationCreateWithoutProductOrdersInput, ProductVariationUncheckedCreateWithoutProductOrdersInput>
    where?: ProductVariationWhereInput
  }

  export type ProductVariationUpdateToOneWithWhereWithoutProductOrdersInput = {
    where?: ProductVariationWhereInput
    data: XOR<ProductVariationUpdateWithoutProductOrdersInput, ProductVariationUncheckedUpdateWithoutProductOrdersInput>
  }

  export type ProductVariationUpdateWithoutProductOrdersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    Product?: ProductUpdateOneRequiredWithoutProductVariationsNestedInput
  }

  export type ProductVariationUncheckedUpdateWithoutProductOrdersInput = {
    id?: StringFieldUpdateOperationsInput | string
    increment?: IntFieldUpdateOperationsInput | number
    product_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type HotelCreateWithoutVendorInput = {
    id?: string
    name: string
    city: $Enums.City
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    HotelPeriodPrices?: HotelPeriodPriceCreateNestedManyWithoutHotelInput
    MitraPackagesMekkah?: MitraPackageCreateNestedManyWithoutHotelMekkahInput
    MitraPackagesMadinah?: MitraPackageCreateNestedManyWithoutHotelMadinahInput
  }

  export type HotelUncheckedCreateWithoutVendorInput = {
    id?: string
    name: string
    city: $Enums.City
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    HotelPeriodPrices?: HotelPeriodPriceUncheckedCreateNestedManyWithoutHotelInput
    MitraPackagesMekkah?: MitraPackageUncheckedCreateNestedManyWithoutHotelMekkahInput
    MitraPackagesMadinah?: MitraPackageUncheckedCreateNestedManyWithoutHotelMadinahInput
  }

  export type HotelCreateOrConnectWithoutVendorInput = {
    where: HotelWhereUniqueInput
    create: XOR<HotelCreateWithoutVendorInput, HotelUncheckedCreateWithoutVendorInput>
  }

  export type HotelCreateManyVendorInputEnvelope = {
    data: HotelCreateManyVendorInput | HotelCreateManyVendorInput[]
    skipDuplicates?: boolean
  }

  export type MitraPackageCreateWithoutVendorInput = {
    id?: string
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderCreateNestedManyWithoutMitraPackageInput
    period?: PeriodCreateNestedOneWithoutMitraPackagesInput
    airline?: AirlineCreateNestedOneWithoutMitraPackagesInput
    hotelMekkah?: HotelCreateNestedOneWithoutMitraPackagesMekkahInput
    hotelMadinah?: HotelCreateNestedOneWithoutMitraPackagesMadinahInput
    visa?: VisaCreateNestedOneWithoutMitraPackagesInput
    transportation?: TransportationCreateNestedOneWithoutMitraPackageInput
    muthawif?: MuthawifCreateNestedOneWithoutMitraPackagesInput
    handlingSaudi?: HandlingSaudiCreateNestedOneWithoutMitraPackagesInput
    handlingDomestic?: HandlingDomesticCreateNestedOneWithoutMitraPackagesInput
    siskopatuh?: SiskopatuhCreateNestedOneWithoutMitraPackagesInput
    equipment?: EquipmentCreateNestedOneWithoutMitraPackagesInput
    tourPlus?: TourPlusCreateNestedOneWithoutMitraPackagesInput
    manasik?: ManasikCreateNestedOneWithoutMitraPackagesInput
  }

  export type MitraPackageUncheckedCreateWithoutVendorInput = {
    id?: string
    period_id?: string | null
    airline_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    visa_id?: string | null
    transportation_id?: string | null
    muthawif_id?: string | null
    handling_saudi_id?: string | null
    handling_domestic_id?: string | null
    siskopatuh_id?: string | null
    equipment_id?: string | null
    tour_plus_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedCreateNestedManyWithoutMitraPackageInput
  }

  export type MitraPackageCreateOrConnectWithoutVendorInput = {
    where: MitraPackageWhereUniqueInput
    create: XOR<MitraPackageCreateWithoutVendorInput, MitraPackageUncheckedCreateWithoutVendorInput>
  }

  export type MitraPackageCreateManyVendorInputEnvelope = {
    data: MitraPackageCreateManyVendorInput | MitraPackageCreateManyVendorInput[]
    skipDuplicates?: boolean
  }

  export type HotelUpsertWithWhereUniqueWithoutVendorInput = {
    where: HotelWhereUniqueInput
    update: XOR<HotelUpdateWithoutVendorInput, HotelUncheckedUpdateWithoutVendorInput>
    create: XOR<HotelCreateWithoutVendorInput, HotelUncheckedCreateWithoutVendorInput>
  }

  export type HotelUpdateWithWhereUniqueWithoutVendorInput = {
    where: HotelWhereUniqueInput
    data: XOR<HotelUpdateWithoutVendorInput, HotelUncheckedUpdateWithoutVendorInput>
  }

  export type HotelUpdateManyWithWhereWithoutVendorInput = {
    where: HotelScalarWhereInput
    data: XOR<HotelUpdateManyMutationInput, HotelUncheckedUpdateManyWithoutVendorInput>
  }

  export type HotelScalarWhereInput = {
    AND?: HotelScalarWhereInput | HotelScalarWhereInput[]
    OR?: HotelScalarWhereInput[]
    NOT?: HotelScalarWhereInput | HotelScalarWhereInput[]
    id?: StringFilter<"Hotel"> | string
    vendor_id?: StringFilter<"Hotel"> | string
    name?: StringFilter<"Hotel"> | string
    city?: EnumCityFilter<"Hotel"> | $Enums.City
    order_number?: IntFilter<"Hotel"> | number
    created_at?: DateTimeFilter<"Hotel"> | Date | string
    updated_at?: DateTimeFilter<"Hotel"> | Date | string
  }

  export type MitraPackageUpsertWithWhereUniqueWithoutVendorInput = {
    where: MitraPackageWhereUniqueInput
    update: XOR<MitraPackageUpdateWithoutVendorInput, MitraPackageUncheckedUpdateWithoutVendorInput>
    create: XOR<MitraPackageCreateWithoutVendorInput, MitraPackageUncheckedCreateWithoutVendorInput>
  }

  export type MitraPackageUpdateWithWhereUniqueWithoutVendorInput = {
    where: MitraPackageWhereUniqueInput
    data: XOR<MitraPackageUpdateWithoutVendorInput, MitraPackageUncheckedUpdateWithoutVendorInput>
  }

  export type MitraPackageUpdateManyWithWhereWithoutVendorInput = {
    where: MitraPackageScalarWhereInput
    data: XOR<MitraPackageUpdateManyMutationInput, MitraPackageUncheckedUpdateManyWithoutVendorInput>
  }

  export type MitraPackageScalarWhereInput = {
    AND?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
    OR?: MitraPackageScalarWhereInput[]
    NOT?: MitraPackageScalarWhereInput | MitraPackageScalarWhereInput[]
    id?: StringFilter<"MitraPackage"> | string
    period_id?: StringNullableFilter<"MitraPackage"> | string | null
    airline_id?: StringNullableFilter<"MitraPackage"> | string | null
    vendor_id?: StringNullableFilter<"MitraPackage"> | string | null
    hotel_mekkah_id?: StringNullableFilter<"MitraPackage"> | string | null
    hotel_madinah_id?: StringNullableFilter<"MitraPackage"> | string | null
    visa_id?: StringNullableFilter<"MitraPackage"> | string | null
    transportation_id?: StringNullableFilter<"MitraPackage"> | string | null
    muthawif_id?: StringNullableFilter<"MitraPackage"> | string | null
    handling_saudi_id?: StringNullableFilter<"MitraPackage"> | string | null
    handling_domestic_id?: StringNullableFilter<"MitraPackage"> | string | null
    siskopatuh_id?: StringNullableFilter<"MitraPackage"> | string | null
    equipment_id?: StringNullableFilter<"MitraPackage"> | string | null
    tour_plus_id?: StringNullableFilter<"MitraPackage"> | string | null
    manasik_id?: StringNullableFilter<"MitraPackage"> | string | null
    number_of_pax?: IntFilter<"MitraPackage"> | number
    departure_date?: DateTimeFilter<"MitraPackage"> | Date | string
    travel_duration?: IntFilter<"MitraPackage"> | number
    mekkah_duration?: IntFilter<"MitraPackage"> | number
    madinah_duration?: IntFilter<"MitraPackage"> | number
    tour_leader?: IntFilter<"MitraPackage"> | number
    margin?: DecimalFilter<"MitraPackage"> | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFilter<"MitraPackage"> | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFilter<"MitraPackage"> | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFilter<"MitraPackage"> | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFilter<"MitraPackage"> | Date | string
    updated_at?: DateTimeFilter<"MitraPackage"> | Date | string
  }

  export type VendorCreateWithoutHotelsInput = {
    id?: string
    name: string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackages?: MitraPackageCreateNestedManyWithoutVendorInput
  }

  export type VendorUncheckedCreateWithoutHotelsInput = {
    id?: string
    name: string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackages?: MitraPackageUncheckedCreateNestedManyWithoutVendorInput
  }

  export type VendorCreateOrConnectWithoutHotelsInput = {
    where: VendorWhereUniqueInput
    create: XOR<VendorCreateWithoutHotelsInput, VendorUncheckedCreateWithoutHotelsInput>
  }

  export type HotelPeriodPriceCreateWithoutHotelInput = {
    id?: string
    price_double: Decimal | DecimalJsLike | number | string
    price_triple: Decimal | DecimalJsLike | number | string
    price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    Period: PeriodCreateNestedOneWithoutHotelPeriodPricesInput
  }

  export type HotelPeriodPriceUncheckedCreateWithoutHotelInput = {
    id?: string
    period_id: string
    price_double: Decimal | DecimalJsLike | number | string
    price_triple: Decimal | DecimalJsLike | number | string
    price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type HotelPeriodPriceCreateOrConnectWithoutHotelInput = {
    where: HotelPeriodPriceWhereUniqueInput
    create: XOR<HotelPeriodPriceCreateWithoutHotelInput, HotelPeriodPriceUncheckedCreateWithoutHotelInput>
  }

  export type HotelPeriodPriceCreateManyHotelInputEnvelope = {
    data: HotelPeriodPriceCreateManyHotelInput | HotelPeriodPriceCreateManyHotelInput[]
    skipDuplicates?: boolean
  }

  export type MitraPackageCreateWithoutHotelMekkahInput = {
    id?: string
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderCreateNestedManyWithoutMitraPackageInput
    period?: PeriodCreateNestedOneWithoutMitraPackagesInput
    airline?: AirlineCreateNestedOneWithoutMitraPackagesInput
    vendor?: VendorCreateNestedOneWithoutMitraPackagesInput
    hotelMadinah?: HotelCreateNestedOneWithoutMitraPackagesMadinahInput
    visa?: VisaCreateNestedOneWithoutMitraPackagesInput
    transportation?: TransportationCreateNestedOneWithoutMitraPackageInput
    muthawif?: MuthawifCreateNestedOneWithoutMitraPackagesInput
    handlingSaudi?: HandlingSaudiCreateNestedOneWithoutMitraPackagesInput
    handlingDomestic?: HandlingDomesticCreateNestedOneWithoutMitraPackagesInput
    siskopatuh?: SiskopatuhCreateNestedOneWithoutMitraPackagesInput
    equipment?: EquipmentCreateNestedOneWithoutMitraPackagesInput
    tourPlus?: TourPlusCreateNestedOneWithoutMitraPackagesInput
    manasik?: ManasikCreateNestedOneWithoutMitraPackagesInput
  }

  export type MitraPackageUncheckedCreateWithoutHotelMekkahInput = {
    id?: string
    period_id?: string | null
    airline_id?: string | null
    vendor_id?: string | null
    hotel_madinah_id?: string | null
    visa_id?: string | null
    transportation_id?: string | null
    muthawif_id?: string | null
    handling_saudi_id?: string | null
    handling_domestic_id?: string | null
    siskopatuh_id?: string | null
    equipment_id?: string | null
    tour_plus_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedCreateNestedManyWithoutMitraPackageInput
  }

  export type MitraPackageCreateOrConnectWithoutHotelMekkahInput = {
    where: MitraPackageWhereUniqueInput
    create: XOR<MitraPackageCreateWithoutHotelMekkahInput, MitraPackageUncheckedCreateWithoutHotelMekkahInput>
  }

  export type MitraPackageCreateManyHotelMekkahInputEnvelope = {
    data: MitraPackageCreateManyHotelMekkahInput | MitraPackageCreateManyHotelMekkahInput[]
    skipDuplicates?: boolean
  }

  export type MitraPackageCreateWithoutHotelMadinahInput = {
    id?: string
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderCreateNestedManyWithoutMitraPackageInput
    period?: PeriodCreateNestedOneWithoutMitraPackagesInput
    airline?: AirlineCreateNestedOneWithoutMitraPackagesInput
    vendor?: VendorCreateNestedOneWithoutMitraPackagesInput
    hotelMekkah?: HotelCreateNestedOneWithoutMitraPackagesMekkahInput
    visa?: VisaCreateNestedOneWithoutMitraPackagesInput
    transportation?: TransportationCreateNestedOneWithoutMitraPackageInput
    muthawif?: MuthawifCreateNestedOneWithoutMitraPackagesInput
    handlingSaudi?: HandlingSaudiCreateNestedOneWithoutMitraPackagesInput
    handlingDomestic?: HandlingDomesticCreateNestedOneWithoutMitraPackagesInput
    siskopatuh?: SiskopatuhCreateNestedOneWithoutMitraPackagesInput
    equipment?: EquipmentCreateNestedOneWithoutMitraPackagesInput
    tourPlus?: TourPlusCreateNestedOneWithoutMitraPackagesInput
    manasik?: ManasikCreateNestedOneWithoutMitraPackagesInput
  }

  export type MitraPackageUncheckedCreateWithoutHotelMadinahInput = {
    id?: string
    period_id?: string | null
    airline_id?: string | null
    vendor_id?: string | null
    hotel_mekkah_id?: string | null
    visa_id?: string | null
    transportation_id?: string | null
    muthawif_id?: string | null
    handling_saudi_id?: string | null
    handling_domestic_id?: string | null
    siskopatuh_id?: string | null
    equipment_id?: string | null
    tour_plus_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedCreateNestedManyWithoutMitraPackageInput
  }

  export type MitraPackageCreateOrConnectWithoutHotelMadinahInput = {
    where: MitraPackageWhereUniqueInput
    create: XOR<MitraPackageCreateWithoutHotelMadinahInput, MitraPackageUncheckedCreateWithoutHotelMadinahInput>
  }

  export type MitraPackageCreateManyHotelMadinahInputEnvelope = {
    data: MitraPackageCreateManyHotelMadinahInput | MitraPackageCreateManyHotelMadinahInput[]
    skipDuplicates?: boolean
  }

  export type VendorUpsertWithoutHotelsInput = {
    update: XOR<VendorUpdateWithoutHotelsInput, VendorUncheckedUpdateWithoutHotelsInput>
    create: XOR<VendorCreateWithoutHotelsInput, VendorUncheckedCreateWithoutHotelsInput>
    where?: VendorWhereInput
  }

  export type VendorUpdateToOneWithWhereWithoutHotelsInput = {
    where?: VendorWhereInput
    data: XOR<VendorUpdateWithoutHotelsInput, VendorUncheckedUpdateWithoutHotelsInput>
  }

  export type VendorUpdateWithoutHotelsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackages?: MitraPackageUpdateManyWithoutVendorNestedInput
  }

  export type VendorUncheckedUpdateWithoutHotelsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackages?: MitraPackageUncheckedUpdateManyWithoutVendorNestedInput
  }

  export type HotelPeriodPriceUpsertWithWhereUniqueWithoutHotelInput = {
    where: HotelPeriodPriceWhereUniqueInput
    update: XOR<HotelPeriodPriceUpdateWithoutHotelInput, HotelPeriodPriceUncheckedUpdateWithoutHotelInput>
    create: XOR<HotelPeriodPriceCreateWithoutHotelInput, HotelPeriodPriceUncheckedCreateWithoutHotelInput>
  }

  export type HotelPeriodPriceUpdateWithWhereUniqueWithoutHotelInput = {
    where: HotelPeriodPriceWhereUniqueInput
    data: XOR<HotelPeriodPriceUpdateWithoutHotelInput, HotelPeriodPriceUncheckedUpdateWithoutHotelInput>
  }

  export type HotelPeriodPriceUpdateManyWithWhereWithoutHotelInput = {
    where: HotelPeriodPriceScalarWhereInput
    data: XOR<HotelPeriodPriceUpdateManyMutationInput, HotelPeriodPriceUncheckedUpdateManyWithoutHotelInput>
  }

  export type HotelPeriodPriceScalarWhereInput = {
    AND?: HotelPeriodPriceScalarWhereInput | HotelPeriodPriceScalarWhereInput[]
    OR?: HotelPeriodPriceScalarWhereInput[]
    NOT?: HotelPeriodPriceScalarWhereInput | HotelPeriodPriceScalarWhereInput[]
    id?: StringFilter<"HotelPeriodPrice"> | string
    hotel_id?: StringFilter<"HotelPeriodPrice"> | string
    period_id?: StringFilter<"HotelPeriodPrice"> | string
    price_double?: DecimalFilter<"HotelPeriodPrice"> | Decimal | DecimalJsLike | number | string
    price_triple?: DecimalFilter<"HotelPeriodPrice"> | Decimal | DecimalJsLike | number | string
    price_quad?: DecimalFilter<"HotelPeriodPrice"> | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFilter<"HotelPeriodPrice"> | Date | string
    updated_at?: DateTimeFilter<"HotelPeriodPrice"> | Date | string
  }

  export type MitraPackageUpsertWithWhereUniqueWithoutHotelMekkahInput = {
    where: MitraPackageWhereUniqueInput
    update: XOR<MitraPackageUpdateWithoutHotelMekkahInput, MitraPackageUncheckedUpdateWithoutHotelMekkahInput>
    create: XOR<MitraPackageCreateWithoutHotelMekkahInput, MitraPackageUncheckedCreateWithoutHotelMekkahInput>
  }

  export type MitraPackageUpdateWithWhereUniqueWithoutHotelMekkahInput = {
    where: MitraPackageWhereUniqueInput
    data: XOR<MitraPackageUpdateWithoutHotelMekkahInput, MitraPackageUncheckedUpdateWithoutHotelMekkahInput>
  }

  export type MitraPackageUpdateManyWithWhereWithoutHotelMekkahInput = {
    where: MitraPackageScalarWhereInput
    data: XOR<MitraPackageUpdateManyMutationInput, MitraPackageUncheckedUpdateManyWithoutHotelMekkahInput>
  }

  export type MitraPackageUpsertWithWhereUniqueWithoutHotelMadinahInput = {
    where: MitraPackageWhereUniqueInput
    update: XOR<MitraPackageUpdateWithoutHotelMadinahInput, MitraPackageUncheckedUpdateWithoutHotelMadinahInput>
    create: XOR<MitraPackageCreateWithoutHotelMadinahInput, MitraPackageUncheckedCreateWithoutHotelMadinahInput>
  }

  export type MitraPackageUpdateWithWhereUniqueWithoutHotelMadinahInput = {
    where: MitraPackageWhereUniqueInput
    data: XOR<MitraPackageUpdateWithoutHotelMadinahInput, MitraPackageUncheckedUpdateWithoutHotelMadinahInput>
  }

  export type MitraPackageUpdateManyWithWhereWithoutHotelMadinahInput = {
    where: MitraPackageScalarWhereInput
    data: XOR<MitraPackageUpdateManyMutationInput, MitraPackageUncheckedUpdateManyWithoutHotelMadinahInput>
  }

  export type HotelPeriodPriceCreateWithoutPeriodInput = {
    id?: string
    price_double: Decimal | DecimalJsLike | number | string
    price_triple: Decimal | DecimalJsLike | number | string
    price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    Hotel: HotelCreateNestedOneWithoutHotelPeriodPricesInput
  }

  export type HotelPeriodPriceUncheckedCreateWithoutPeriodInput = {
    id?: string
    hotel_id: string
    price_double: Decimal | DecimalJsLike | number | string
    price_triple: Decimal | DecimalJsLike | number | string
    price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type HotelPeriodPriceCreateOrConnectWithoutPeriodInput = {
    where: HotelPeriodPriceWhereUniqueInput
    create: XOR<HotelPeriodPriceCreateWithoutPeriodInput, HotelPeriodPriceUncheckedCreateWithoutPeriodInput>
  }

  export type HotelPeriodPriceCreateManyPeriodInputEnvelope = {
    data: HotelPeriodPriceCreateManyPeriodInput | HotelPeriodPriceCreateManyPeriodInput[]
    skipDuplicates?: boolean
  }

  export type MitraPackageCreateWithoutPeriodInput = {
    id?: string
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderCreateNestedManyWithoutMitraPackageInput
    airline?: AirlineCreateNestedOneWithoutMitraPackagesInput
    vendor?: VendorCreateNestedOneWithoutMitraPackagesInput
    hotelMekkah?: HotelCreateNestedOneWithoutMitraPackagesMekkahInput
    hotelMadinah?: HotelCreateNestedOneWithoutMitraPackagesMadinahInput
    visa?: VisaCreateNestedOneWithoutMitraPackagesInput
    transportation?: TransportationCreateNestedOneWithoutMitraPackageInput
    muthawif?: MuthawifCreateNestedOneWithoutMitraPackagesInput
    handlingSaudi?: HandlingSaudiCreateNestedOneWithoutMitraPackagesInput
    handlingDomestic?: HandlingDomesticCreateNestedOneWithoutMitraPackagesInput
    siskopatuh?: SiskopatuhCreateNestedOneWithoutMitraPackagesInput
    equipment?: EquipmentCreateNestedOneWithoutMitraPackagesInput
    tourPlus?: TourPlusCreateNestedOneWithoutMitraPackagesInput
    manasik?: ManasikCreateNestedOneWithoutMitraPackagesInput
  }

  export type MitraPackageUncheckedCreateWithoutPeriodInput = {
    id?: string
    airline_id?: string | null
    vendor_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    visa_id?: string | null
    transportation_id?: string | null
    muthawif_id?: string | null
    handling_saudi_id?: string | null
    handling_domestic_id?: string | null
    siskopatuh_id?: string | null
    equipment_id?: string | null
    tour_plus_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedCreateNestedManyWithoutMitraPackageInput
  }

  export type MitraPackageCreateOrConnectWithoutPeriodInput = {
    where: MitraPackageWhereUniqueInput
    create: XOR<MitraPackageCreateWithoutPeriodInput, MitraPackageUncheckedCreateWithoutPeriodInput>
  }

  export type MitraPackageCreateManyPeriodInputEnvelope = {
    data: MitraPackageCreateManyPeriodInput | MitraPackageCreateManyPeriodInput[]
    skipDuplicates?: boolean
  }

  export type HotelPeriodPriceUpsertWithWhereUniqueWithoutPeriodInput = {
    where: HotelPeriodPriceWhereUniqueInput
    update: XOR<HotelPeriodPriceUpdateWithoutPeriodInput, HotelPeriodPriceUncheckedUpdateWithoutPeriodInput>
    create: XOR<HotelPeriodPriceCreateWithoutPeriodInput, HotelPeriodPriceUncheckedCreateWithoutPeriodInput>
  }

  export type HotelPeriodPriceUpdateWithWhereUniqueWithoutPeriodInput = {
    where: HotelPeriodPriceWhereUniqueInput
    data: XOR<HotelPeriodPriceUpdateWithoutPeriodInput, HotelPeriodPriceUncheckedUpdateWithoutPeriodInput>
  }

  export type HotelPeriodPriceUpdateManyWithWhereWithoutPeriodInput = {
    where: HotelPeriodPriceScalarWhereInput
    data: XOR<HotelPeriodPriceUpdateManyMutationInput, HotelPeriodPriceUncheckedUpdateManyWithoutPeriodInput>
  }

  export type MitraPackageUpsertWithWhereUniqueWithoutPeriodInput = {
    where: MitraPackageWhereUniqueInput
    update: XOR<MitraPackageUpdateWithoutPeriodInput, MitraPackageUncheckedUpdateWithoutPeriodInput>
    create: XOR<MitraPackageCreateWithoutPeriodInput, MitraPackageUncheckedCreateWithoutPeriodInput>
  }

  export type MitraPackageUpdateWithWhereUniqueWithoutPeriodInput = {
    where: MitraPackageWhereUniqueInput
    data: XOR<MitraPackageUpdateWithoutPeriodInput, MitraPackageUncheckedUpdateWithoutPeriodInput>
  }

  export type MitraPackageUpdateManyWithWhereWithoutPeriodInput = {
    where: MitraPackageScalarWhereInput
    data: XOR<MitraPackageUpdateManyMutationInput, MitraPackageUncheckedUpdateManyWithoutPeriodInput>
  }

  export type HotelCreateWithoutHotelPeriodPricesInput = {
    id?: string
    name: string
    city: $Enums.City
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    Vendor: VendorCreateNestedOneWithoutHotelsInput
    MitraPackagesMekkah?: MitraPackageCreateNestedManyWithoutHotelMekkahInput
    MitraPackagesMadinah?: MitraPackageCreateNestedManyWithoutHotelMadinahInput
  }

  export type HotelUncheckedCreateWithoutHotelPeriodPricesInput = {
    id?: string
    vendor_id: string
    name: string
    city: $Enums.City
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackagesMekkah?: MitraPackageUncheckedCreateNestedManyWithoutHotelMekkahInput
    MitraPackagesMadinah?: MitraPackageUncheckedCreateNestedManyWithoutHotelMadinahInput
  }

  export type HotelCreateOrConnectWithoutHotelPeriodPricesInput = {
    where: HotelWhereUniqueInput
    create: XOR<HotelCreateWithoutHotelPeriodPricesInput, HotelUncheckedCreateWithoutHotelPeriodPricesInput>
  }

  export type PeriodCreateWithoutHotelPeriodPricesInput = {
    id?: string
    category?: $Enums.PeriodCategory
    start_date: Date | string
    end_date: Date | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackages?: MitraPackageCreateNestedManyWithoutPeriodInput
  }

  export type PeriodUncheckedCreateWithoutHotelPeriodPricesInput = {
    id?: string
    category?: $Enums.PeriodCategory
    start_date: Date | string
    end_date: Date | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackages?: MitraPackageUncheckedCreateNestedManyWithoutPeriodInput
  }

  export type PeriodCreateOrConnectWithoutHotelPeriodPricesInput = {
    where: PeriodWhereUniqueInput
    create: XOR<PeriodCreateWithoutHotelPeriodPricesInput, PeriodUncheckedCreateWithoutHotelPeriodPricesInput>
  }

  export type HotelUpsertWithoutHotelPeriodPricesInput = {
    update: XOR<HotelUpdateWithoutHotelPeriodPricesInput, HotelUncheckedUpdateWithoutHotelPeriodPricesInput>
    create: XOR<HotelCreateWithoutHotelPeriodPricesInput, HotelUncheckedCreateWithoutHotelPeriodPricesInput>
    where?: HotelWhereInput
  }

  export type HotelUpdateToOneWithWhereWithoutHotelPeriodPricesInput = {
    where?: HotelWhereInput
    data: XOR<HotelUpdateWithoutHotelPeriodPricesInput, HotelUncheckedUpdateWithoutHotelPeriodPricesInput>
  }

  export type HotelUpdateWithoutHotelPeriodPricesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    city?: EnumCityFieldUpdateOperationsInput | $Enums.City
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    Vendor?: VendorUpdateOneRequiredWithoutHotelsNestedInput
    MitraPackagesMekkah?: MitraPackageUpdateManyWithoutHotelMekkahNestedInput
    MitraPackagesMadinah?: MitraPackageUpdateManyWithoutHotelMadinahNestedInput
  }

  export type HotelUncheckedUpdateWithoutHotelPeriodPricesInput = {
    id?: StringFieldUpdateOperationsInput | string
    vendor_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    city?: EnumCityFieldUpdateOperationsInput | $Enums.City
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackagesMekkah?: MitraPackageUncheckedUpdateManyWithoutHotelMekkahNestedInput
    MitraPackagesMadinah?: MitraPackageUncheckedUpdateManyWithoutHotelMadinahNestedInput
  }

  export type PeriodUpsertWithoutHotelPeriodPricesInput = {
    update: XOR<PeriodUpdateWithoutHotelPeriodPricesInput, PeriodUncheckedUpdateWithoutHotelPeriodPricesInput>
    create: XOR<PeriodCreateWithoutHotelPeriodPricesInput, PeriodUncheckedCreateWithoutHotelPeriodPricesInput>
    where?: PeriodWhereInput
  }

  export type PeriodUpdateToOneWithWhereWithoutHotelPeriodPricesInput = {
    where?: PeriodWhereInput
    data: XOR<PeriodUpdateWithoutHotelPeriodPricesInput, PeriodUncheckedUpdateWithoutHotelPeriodPricesInput>
  }

  export type PeriodUpdateWithoutHotelPeriodPricesInput = {
    id?: StringFieldUpdateOperationsInput | string
    category?: EnumPeriodCategoryFieldUpdateOperationsInput | $Enums.PeriodCategory
    start_date?: DateTimeFieldUpdateOperationsInput | Date | string
    end_date?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackages?: MitraPackageUpdateManyWithoutPeriodNestedInput
  }

  export type PeriodUncheckedUpdateWithoutHotelPeriodPricesInput = {
    id?: StringFieldUpdateOperationsInput | string
    category?: EnumPeriodCategoryFieldUpdateOperationsInput | $Enums.PeriodCategory
    start_date?: DateTimeFieldUpdateOperationsInput | Date | string
    end_date?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackages?: MitraPackageUncheckedUpdateManyWithoutPeriodNestedInput
  }

  export type MitraPackageCreateWithoutAirlineInput = {
    id?: string
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderCreateNestedManyWithoutMitraPackageInput
    period?: PeriodCreateNestedOneWithoutMitraPackagesInput
    vendor?: VendorCreateNestedOneWithoutMitraPackagesInput
    hotelMekkah?: HotelCreateNestedOneWithoutMitraPackagesMekkahInput
    hotelMadinah?: HotelCreateNestedOneWithoutMitraPackagesMadinahInput
    visa?: VisaCreateNestedOneWithoutMitraPackagesInput
    transportation?: TransportationCreateNestedOneWithoutMitraPackageInput
    muthawif?: MuthawifCreateNestedOneWithoutMitraPackagesInput
    handlingSaudi?: HandlingSaudiCreateNestedOneWithoutMitraPackagesInput
    handlingDomestic?: HandlingDomesticCreateNestedOneWithoutMitraPackagesInput
    siskopatuh?: SiskopatuhCreateNestedOneWithoutMitraPackagesInput
    equipment?: EquipmentCreateNestedOneWithoutMitraPackagesInput
    tourPlus?: TourPlusCreateNestedOneWithoutMitraPackagesInput
    manasik?: ManasikCreateNestedOneWithoutMitraPackagesInput
  }

  export type MitraPackageUncheckedCreateWithoutAirlineInput = {
    id?: string
    period_id?: string | null
    vendor_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    visa_id?: string | null
    transportation_id?: string | null
    muthawif_id?: string | null
    handling_saudi_id?: string | null
    handling_domestic_id?: string | null
    siskopatuh_id?: string | null
    equipment_id?: string | null
    tour_plus_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedCreateNestedManyWithoutMitraPackageInput
  }

  export type MitraPackageCreateOrConnectWithoutAirlineInput = {
    where: MitraPackageWhereUniqueInput
    create: XOR<MitraPackageCreateWithoutAirlineInput, MitraPackageUncheckedCreateWithoutAirlineInput>
  }

  export type MitraPackageCreateManyAirlineInputEnvelope = {
    data: MitraPackageCreateManyAirlineInput | MitraPackageCreateManyAirlineInput[]
    skipDuplicates?: boolean
  }

  export type MitraPackageUpsertWithWhereUniqueWithoutAirlineInput = {
    where: MitraPackageWhereUniqueInput
    update: XOR<MitraPackageUpdateWithoutAirlineInput, MitraPackageUncheckedUpdateWithoutAirlineInput>
    create: XOR<MitraPackageCreateWithoutAirlineInput, MitraPackageUncheckedCreateWithoutAirlineInput>
  }

  export type MitraPackageUpdateWithWhereUniqueWithoutAirlineInput = {
    where: MitraPackageWhereUniqueInput
    data: XOR<MitraPackageUpdateWithoutAirlineInput, MitraPackageUncheckedUpdateWithoutAirlineInput>
  }

  export type MitraPackageUpdateManyWithWhereWithoutAirlineInput = {
    where: MitraPackageScalarWhereInput
    data: XOR<MitraPackageUpdateManyMutationInput, MitraPackageUncheckedUpdateManyWithoutAirlineInput>
  }

  export type MitraPackageCreateWithoutVisaInput = {
    id?: string
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderCreateNestedManyWithoutMitraPackageInput
    period?: PeriodCreateNestedOneWithoutMitraPackagesInput
    airline?: AirlineCreateNestedOneWithoutMitraPackagesInput
    vendor?: VendorCreateNestedOneWithoutMitraPackagesInput
    hotelMekkah?: HotelCreateNestedOneWithoutMitraPackagesMekkahInput
    hotelMadinah?: HotelCreateNestedOneWithoutMitraPackagesMadinahInput
    transportation?: TransportationCreateNestedOneWithoutMitraPackageInput
    muthawif?: MuthawifCreateNestedOneWithoutMitraPackagesInput
    handlingSaudi?: HandlingSaudiCreateNestedOneWithoutMitraPackagesInput
    handlingDomestic?: HandlingDomesticCreateNestedOneWithoutMitraPackagesInput
    siskopatuh?: SiskopatuhCreateNestedOneWithoutMitraPackagesInput
    equipment?: EquipmentCreateNestedOneWithoutMitraPackagesInput
    tourPlus?: TourPlusCreateNestedOneWithoutMitraPackagesInput
    manasik?: ManasikCreateNestedOneWithoutMitraPackagesInput
  }

  export type MitraPackageUncheckedCreateWithoutVisaInput = {
    id?: string
    period_id?: string | null
    airline_id?: string | null
    vendor_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    transportation_id?: string | null
    muthawif_id?: string | null
    handling_saudi_id?: string | null
    handling_domestic_id?: string | null
    siskopatuh_id?: string | null
    equipment_id?: string | null
    tour_plus_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedCreateNestedManyWithoutMitraPackageInput
  }

  export type MitraPackageCreateOrConnectWithoutVisaInput = {
    where: MitraPackageWhereUniqueInput
    create: XOR<MitraPackageCreateWithoutVisaInput, MitraPackageUncheckedCreateWithoutVisaInput>
  }

  export type MitraPackageCreateManyVisaInputEnvelope = {
    data: MitraPackageCreateManyVisaInput | MitraPackageCreateManyVisaInput[]
    skipDuplicates?: boolean
  }

  export type MitraPackageUpsertWithWhereUniqueWithoutVisaInput = {
    where: MitraPackageWhereUniqueInput
    update: XOR<MitraPackageUpdateWithoutVisaInput, MitraPackageUncheckedUpdateWithoutVisaInput>
    create: XOR<MitraPackageCreateWithoutVisaInput, MitraPackageUncheckedCreateWithoutVisaInput>
  }

  export type MitraPackageUpdateWithWhereUniqueWithoutVisaInput = {
    where: MitraPackageWhereUniqueInput
    data: XOR<MitraPackageUpdateWithoutVisaInput, MitraPackageUncheckedUpdateWithoutVisaInput>
  }

  export type MitraPackageUpdateManyWithWhereWithoutVisaInput = {
    where: MitraPackageScalarWhereInput
    data: XOR<MitraPackageUpdateManyMutationInput, MitraPackageUncheckedUpdateManyWithoutVisaInput>
  }

  export type MitraPackageCreateWithoutTransportationInput = {
    id?: string
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderCreateNestedManyWithoutMitraPackageInput
    period?: PeriodCreateNestedOneWithoutMitraPackagesInput
    airline?: AirlineCreateNestedOneWithoutMitraPackagesInput
    vendor?: VendorCreateNestedOneWithoutMitraPackagesInput
    hotelMekkah?: HotelCreateNestedOneWithoutMitraPackagesMekkahInput
    hotelMadinah?: HotelCreateNestedOneWithoutMitraPackagesMadinahInput
    visa?: VisaCreateNestedOneWithoutMitraPackagesInput
    muthawif?: MuthawifCreateNestedOneWithoutMitraPackagesInput
    handlingSaudi?: HandlingSaudiCreateNestedOneWithoutMitraPackagesInput
    handlingDomestic?: HandlingDomesticCreateNestedOneWithoutMitraPackagesInput
    siskopatuh?: SiskopatuhCreateNestedOneWithoutMitraPackagesInput
    equipment?: EquipmentCreateNestedOneWithoutMitraPackagesInput
    tourPlus?: TourPlusCreateNestedOneWithoutMitraPackagesInput
    manasik?: ManasikCreateNestedOneWithoutMitraPackagesInput
  }

  export type MitraPackageUncheckedCreateWithoutTransportationInput = {
    id?: string
    period_id?: string | null
    airline_id?: string | null
    vendor_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    visa_id?: string | null
    muthawif_id?: string | null
    handling_saudi_id?: string | null
    handling_domestic_id?: string | null
    siskopatuh_id?: string | null
    equipment_id?: string | null
    tour_plus_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedCreateNestedManyWithoutMitraPackageInput
  }

  export type MitraPackageCreateOrConnectWithoutTransportationInput = {
    where: MitraPackageWhereUniqueInput
    create: XOR<MitraPackageCreateWithoutTransportationInput, MitraPackageUncheckedCreateWithoutTransportationInput>
  }

  export type MitraPackageCreateManyTransportationInputEnvelope = {
    data: MitraPackageCreateManyTransportationInput | MitraPackageCreateManyTransportationInput[]
    skipDuplicates?: boolean
  }

  export type MitraPackageUpsertWithWhereUniqueWithoutTransportationInput = {
    where: MitraPackageWhereUniqueInput
    update: XOR<MitraPackageUpdateWithoutTransportationInput, MitraPackageUncheckedUpdateWithoutTransportationInput>
    create: XOR<MitraPackageCreateWithoutTransportationInput, MitraPackageUncheckedCreateWithoutTransportationInput>
  }

  export type MitraPackageUpdateWithWhereUniqueWithoutTransportationInput = {
    where: MitraPackageWhereUniqueInput
    data: XOR<MitraPackageUpdateWithoutTransportationInput, MitraPackageUncheckedUpdateWithoutTransportationInput>
  }

  export type MitraPackageUpdateManyWithWhereWithoutTransportationInput = {
    where: MitraPackageScalarWhereInput
    data: XOR<MitraPackageUpdateManyMutationInput, MitraPackageUncheckedUpdateManyWithoutTransportationInput>
  }

  export type MitraPackageCreateWithoutMuthawifInput = {
    id?: string
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderCreateNestedManyWithoutMitraPackageInput
    period?: PeriodCreateNestedOneWithoutMitraPackagesInput
    airline?: AirlineCreateNestedOneWithoutMitraPackagesInput
    vendor?: VendorCreateNestedOneWithoutMitraPackagesInput
    hotelMekkah?: HotelCreateNestedOneWithoutMitraPackagesMekkahInput
    hotelMadinah?: HotelCreateNestedOneWithoutMitraPackagesMadinahInput
    visa?: VisaCreateNestedOneWithoutMitraPackagesInput
    transportation?: TransportationCreateNestedOneWithoutMitraPackageInput
    handlingSaudi?: HandlingSaudiCreateNestedOneWithoutMitraPackagesInput
    handlingDomestic?: HandlingDomesticCreateNestedOneWithoutMitraPackagesInput
    siskopatuh?: SiskopatuhCreateNestedOneWithoutMitraPackagesInput
    equipment?: EquipmentCreateNestedOneWithoutMitraPackagesInput
    tourPlus?: TourPlusCreateNestedOneWithoutMitraPackagesInput
    manasik?: ManasikCreateNestedOneWithoutMitraPackagesInput
  }

  export type MitraPackageUncheckedCreateWithoutMuthawifInput = {
    id?: string
    period_id?: string | null
    airline_id?: string | null
    vendor_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    visa_id?: string | null
    transportation_id?: string | null
    handling_saudi_id?: string | null
    handling_domestic_id?: string | null
    siskopatuh_id?: string | null
    equipment_id?: string | null
    tour_plus_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedCreateNestedManyWithoutMitraPackageInput
  }

  export type MitraPackageCreateOrConnectWithoutMuthawifInput = {
    where: MitraPackageWhereUniqueInput
    create: XOR<MitraPackageCreateWithoutMuthawifInput, MitraPackageUncheckedCreateWithoutMuthawifInput>
  }

  export type MitraPackageCreateManyMuthawifInputEnvelope = {
    data: MitraPackageCreateManyMuthawifInput | MitraPackageCreateManyMuthawifInput[]
    skipDuplicates?: boolean
  }

  export type MitraPackageUpsertWithWhereUniqueWithoutMuthawifInput = {
    where: MitraPackageWhereUniqueInput
    update: XOR<MitraPackageUpdateWithoutMuthawifInput, MitraPackageUncheckedUpdateWithoutMuthawifInput>
    create: XOR<MitraPackageCreateWithoutMuthawifInput, MitraPackageUncheckedCreateWithoutMuthawifInput>
  }

  export type MitraPackageUpdateWithWhereUniqueWithoutMuthawifInput = {
    where: MitraPackageWhereUniqueInput
    data: XOR<MitraPackageUpdateWithoutMuthawifInput, MitraPackageUncheckedUpdateWithoutMuthawifInput>
  }

  export type MitraPackageUpdateManyWithWhereWithoutMuthawifInput = {
    where: MitraPackageScalarWhereInput
    data: XOR<MitraPackageUpdateManyMutationInput, MitraPackageUncheckedUpdateManyWithoutMuthawifInput>
  }

  export type MitraPackageCreateWithoutHandlingSaudiInput = {
    id?: string
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderCreateNestedManyWithoutMitraPackageInput
    period?: PeriodCreateNestedOneWithoutMitraPackagesInput
    airline?: AirlineCreateNestedOneWithoutMitraPackagesInput
    vendor?: VendorCreateNestedOneWithoutMitraPackagesInput
    hotelMekkah?: HotelCreateNestedOneWithoutMitraPackagesMekkahInput
    hotelMadinah?: HotelCreateNestedOneWithoutMitraPackagesMadinahInput
    visa?: VisaCreateNestedOneWithoutMitraPackagesInput
    transportation?: TransportationCreateNestedOneWithoutMitraPackageInput
    muthawif?: MuthawifCreateNestedOneWithoutMitraPackagesInput
    handlingDomestic?: HandlingDomesticCreateNestedOneWithoutMitraPackagesInput
    siskopatuh?: SiskopatuhCreateNestedOneWithoutMitraPackagesInput
    equipment?: EquipmentCreateNestedOneWithoutMitraPackagesInput
    tourPlus?: TourPlusCreateNestedOneWithoutMitraPackagesInput
    manasik?: ManasikCreateNestedOneWithoutMitraPackagesInput
  }

  export type MitraPackageUncheckedCreateWithoutHandlingSaudiInput = {
    id?: string
    period_id?: string | null
    airline_id?: string | null
    vendor_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    visa_id?: string | null
    transportation_id?: string | null
    muthawif_id?: string | null
    handling_domestic_id?: string | null
    siskopatuh_id?: string | null
    equipment_id?: string | null
    tour_plus_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedCreateNestedManyWithoutMitraPackageInput
  }

  export type MitraPackageCreateOrConnectWithoutHandlingSaudiInput = {
    where: MitraPackageWhereUniqueInput
    create: XOR<MitraPackageCreateWithoutHandlingSaudiInput, MitraPackageUncheckedCreateWithoutHandlingSaudiInput>
  }

  export type MitraPackageCreateManyHandlingSaudiInputEnvelope = {
    data: MitraPackageCreateManyHandlingSaudiInput | MitraPackageCreateManyHandlingSaudiInput[]
    skipDuplicates?: boolean
  }

  export type MitraPackageUpsertWithWhereUniqueWithoutHandlingSaudiInput = {
    where: MitraPackageWhereUniqueInput
    update: XOR<MitraPackageUpdateWithoutHandlingSaudiInput, MitraPackageUncheckedUpdateWithoutHandlingSaudiInput>
    create: XOR<MitraPackageCreateWithoutHandlingSaudiInput, MitraPackageUncheckedCreateWithoutHandlingSaudiInput>
  }

  export type MitraPackageUpdateWithWhereUniqueWithoutHandlingSaudiInput = {
    where: MitraPackageWhereUniqueInput
    data: XOR<MitraPackageUpdateWithoutHandlingSaudiInput, MitraPackageUncheckedUpdateWithoutHandlingSaudiInput>
  }

  export type MitraPackageUpdateManyWithWhereWithoutHandlingSaudiInput = {
    where: MitraPackageScalarWhereInput
    data: XOR<MitraPackageUpdateManyMutationInput, MitraPackageUncheckedUpdateManyWithoutHandlingSaudiInput>
  }

  export type MitraPackageCreateWithoutHandlingDomesticInput = {
    id?: string
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderCreateNestedManyWithoutMitraPackageInput
    period?: PeriodCreateNestedOneWithoutMitraPackagesInput
    airline?: AirlineCreateNestedOneWithoutMitraPackagesInput
    vendor?: VendorCreateNestedOneWithoutMitraPackagesInput
    hotelMekkah?: HotelCreateNestedOneWithoutMitraPackagesMekkahInput
    hotelMadinah?: HotelCreateNestedOneWithoutMitraPackagesMadinahInput
    visa?: VisaCreateNestedOneWithoutMitraPackagesInput
    transportation?: TransportationCreateNestedOneWithoutMitraPackageInput
    muthawif?: MuthawifCreateNestedOneWithoutMitraPackagesInput
    handlingSaudi?: HandlingSaudiCreateNestedOneWithoutMitraPackagesInput
    siskopatuh?: SiskopatuhCreateNestedOneWithoutMitraPackagesInput
    equipment?: EquipmentCreateNestedOneWithoutMitraPackagesInput
    tourPlus?: TourPlusCreateNestedOneWithoutMitraPackagesInput
    manasik?: ManasikCreateNestedOneWithoutMitraPackagesInput
  }

  export type MitraPackageUncheckedCreateWithoutHandlingDomesticInput = {
    id?: string
    period_id?: string | null
    airline_id?: string | null
    vendor_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    visa_id?: string | null
    transportation_id?: string | null
    muthawif_id?: string | null
    handling_saudi_id?: string | null
    siskopatuh_id?: string | null
    equipment_id?: string | null
    tour_plus_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedCreateNestedManyWithoutMitraPackageInput
  }

  export type MitraPackageCreateOrConnectWithoutHandlingDomesticInput = {
    where: MitraPackageWhereUniqueInput
    create: XOR<MitraPackageCreateWithoutHandlingDomesticInput, MitraPackageUncheckedCreateWithoutHandlingDomesticInput>
  }

  export type MitraPackageCreateManyHandlingDomesticInputEnvelope = {
    data: MitraPackageCreateManyHandlingDomesticInput | MitraPackageCreateManyHandlingDomesticInput[]
    skipDuplicates?: boolean
  }

  export type MitraPackageUpsertWithWhereUniqueWithoutHandlingDomesticInput = {
    where: MitraPackageWhereUniqueInput
    update: XOR<MitraPackageUpdateWithoutHandlingDomesticInput, MitraPackageUncheckedUpdateWithoutHandlingDomesticInput>
    create: XOR<MitraPackageCreateWithoutHandlingDomesticInput, MitraPackageUncheckedCreateWithoutHandlingDomesticInput>
  }

  export type MitraPackageUpdateWithWhereUniqueWithoutHandlingDomesticInput = {
    where: MitraPackageWhereUniqueInput
    data: XOR<MitraPackageUpdateWithoutHandlingDomesticInput, MitraPackageUncheckedUpdateWithoutHandlingDomesticInput>
  }

  export type MitraPackageUpdateManyWithWhereWithoutHandlingDomesticInput = {
    where: MitraPackageScalarWhereInput
    data: XOR<MitraPackageUpdateManyMutationInput, MitraPackageUncheckedUpdateManyWithoutHandlingDomesticInput>
  }

  export type MitraPackageCreateWithoutSiskopatuhInput = {
    id?: string
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderCreateNestedManyWithoutMitraPackageInput
    period?: PeriodCreateNestedOneWithoutMitraPackagesInput
    airline?: AirlineCreateNestedOneWithoutMitraPackagesInput
    vendor?: VendorCreateNestedOneWithoutMitraPackagesInput
    hotelMekkah?: HotelCreateNestedOneWithoutMitraPackagesMekkahInput
    hotelMadinah?: HotelCreateNestedOneWithoutMitraPackagesMadinahInput
    visa?: VisaCreateNestedOneWithoutMitraPackagesInput
    transportation?: TransportationCreateNestedOneWithoutMitraPackageInput
    muthawif?: MuthawifCreateNestedOneWithoutMitraPackagesInput
    handlingSaudi?: HandlingSaudiCreateNestedOneWithoutMitraPackagesInput
    handlingDomestic?: HandlingDomesticCreateNestedOneWithoutMitraPackagesInput
    equipment?: EquipmentCreateNestedOneWithoutMitraPackagesInput
    tourPlus?: TourPlusCreateNestedOneWithoutMitraPackagesInput
    manasik?: ManasikCreateNestedOneWithoutMitraPackagesInput
  }

  export type MitraPackageUncheckedCreateWithoutSiskopatuhInput = {
    id?: string
    period_id?: string | null
    airline_id?: string | null
    vendor_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    visa_id?: string | null
    transportation_id?: string | null
    muthawif_id?: string | null
    handling_saudi_id?: string | null
    handling_domestic_id?: string | null
    equipment_id?: string | null
    tour_plus_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedCreateNestedManyWithoutMitraPackageInput
  }

  export type MitraPackageCreateOrConnectWithoutSiskopatuhInput = {
    where: MitraPackageWhereUniqueInput
    create: XOR<MitraPackageCreateWithoutSiskopatuhInput, MitraPackageUncheckedCreateWithoutSiskopatuhInput>
  }

  export type MitraPackageCreateManySiskopatuhInputEnvelope = {
    data: MitraPackageCreateManySiskopatuhInput | MitraPackageCreateManySiskopatuhInput[]
    skipDuplicates?: boolean
  }

  export type MitraPackageUpsertWithWhereUniqueWithoutSiskopatuhInput = {
    where: MitraPackageWhereUniqueInput
    update: XOR<MitraPackageUpdateWithoutSiskopatuhInput, MitraPackageUncheckedUpdateWithoutSiskopatuhInput>
    create: XOR<MitraPackageCreateWithoutSiskopatuhInput, MitraPackageUncheckedCreateWithoutSiskopatuhInput>
  }

  export type MitraPackageUpdateWithWhereUniqueWithoutSiskopatuhInput = {
    where: MitraPackageWhereUniqueInput
    data: XOR<MitraPackageUpdateWithoutSiskopatuhInput, MitraPackageUncheckedUpdateWithoutSiskopatuhInput>
  }

  export type MitraPackageUpdateManyWithWhereWithoutSiskopatuhInput = {
    where: MitraPackageScalarWhereInput
    data: XOR<MitraPackageUpdateManyMutationInput, MitraPackageUncheckedUpdateManyWithoutSiskopatuhInput>
  }

  export type MitraPackageCreateWithoutEquipmentInput = {
    id?: string
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderCreateNestedManyWithoutMitraPackageInput
    period?: PeriodCreateNestedOneWithoutMitraPackagesInput
    airline?: AirlineCreateNestedOneWithoutMitraPackagesInput
    vendor?: VendorCreateNestedOneWithoutMitraPackagesInput
    hotelMekkah?: HotelCreateNestedOneWithoutMitraPackagesMekkahInput
    hotelMadinah?: HotelCreateNestedOneWithoutMitraPackagesMadinahInput
    visa?: VisaCreateNestedOneWithoutMitraPackagesInput
    transportation?: TransportationCreateNestedOneWithoutMitraPackageInput
    muthawif?: MuthawifCreateNestedOneWithoutMitraPackagesInput
    handlingSaudi?: HandlingSaudiCreateNestedOneWithoutMitraPackagesInput
    handlingDomestic?: HandlingDomesticCreateNestedOneWithoutMitraPackagesInput
    siskopatuh?: SiskopatuhCreateNestedOneWithoutMitraPackagesInput
    tourPlus?: TourPlusCreateNestedOneWithoutMitraPackagesInput
    manasik?: ManasikCreateNestedOneWithoutMitraPackagesInput
  }

  export type MitraPackageUncheckedCreateWithoutEquipmentInput = {
    id?: string
    period_id?: string | null
    airline_id?: string | null
    vendor_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    visa_id?: string | null
    transportation_id?: string | null
    muthawif_id?: string | null
    handling_saudi_id?: string | null
    handling_domestic_id?: string | null
    siskopatuh_id?: string | null
    tour_plus_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedCreateNestedManyWithoutMitraPackageInput
  }

  export type MitraPackageCreateOrConnectWithoutEquipmentInput = {
    where: MitraPackageWhereUniqueInput
    create: XOR<MitraPackageCreateWithoutEquipmentInput, MitraPackageUncheckedCreateWithoutEquipmentInput>
  }

  export type MitraPackageCreateManyEquipmentInputEnvelope = {
    data: MitraPackageCreateManyEquipmentInput | MitraPackageCreateManyEquipmentInput[]
    skipDuplicates?: boolean
  }

  export type MitraPackageUpsertWithWhereUniqueWithoutEquipmentInput = {
    where: MitraPackageWhereUniqueInput
    update: XOR<MitraPackageUpdateWithoutEquipmentInput, MitraPackageUncheckedUpdateWithoutEquipmentInput>
    create: XOR<MitraPackageCreateWithoutEquipmentInput, MitraPackageUncheckedCreateWithoutEquipmentInput>
  }

  export type MitraPackageUpdateWithWhereUniqueWithoutEquipmentInput = {
    where: MitraPackageWhereUniqueInput
    data: XOR<MitraPackageUpdateWithoutEquipmentInput, MitraPackageUncheckedUpdateWithoutEquipmentInput>
  }

  export type MitraPackageUpdateManyWithWhereWithoutEquipmentInput = {
    where: MitraPackageScalarWhereInput
    data: XOR<MitraPackageUpdateManyMutationInput, MitraPackageUncheckedUpdateManyWithoutEquipmentInput>
  }

  export type MitraPackageCreateWithoutTourPlusInput = {
    id?: string
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderCreateNestedManyWithoutMitraPackageInput
    period?: PeriodCreateNestedOneWithoutMitraPackagesInput
    airline?: AirlineCreateNestedOneWithoutMitraPackagesInput
    vendor?: VendorCreateNestedOneWithoutMitraPackagesInput
    hotelMekkah?: HotelCreateNestedOneWithoutMitraPackagesMekkahInput
    hotelMadinah?: HotelCreateNestedOneWithoutMitraPackagesMadinahInput
    visa?: VisaCreateNestedOneWithoutMitraPackagesInput
    transportation?: TransportationCreateNestedOneWithoutMitraPackageInput
    muthawif?: MuthawifCreateNestedOneWithoutMitraPackagesInput
    handlingSaudi?: HandlingSaudiCreateNestedOneWithoutMitraPackagesInput
    handlingDomestic?: HandlingDomesticCreateNestedOneWithoutMitraPackagesInput
    siskopatuh?: SiskopatuhCreateNestedOneWithoutMitraPackagesInput
    equipment?: EquipmentCreateNestedOneWithoutMitraPackagesInput
    manasik?: ManasikCreateNestedOneWithoutMitraPackagesInput
  }

  export type MitraPackageUncheckedCreateWithoutTourPlusInput = {
    id?: string
    period_id?: string | null
    airline_id?: string | null
    vendor_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    visa_id?: string | null
    transportation_id?: string | null
    muthawif_id?: string | null
    handling_saudi_id?: string | null
    handling_domestic_id?: string | null
    siskopatuh_id?: string | null
    equipment_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedCreateNestedManyWithoutMitraPackageInput
  }

  export type MitraPackageCreateOrConnectWithoutTourPlusInput = {
    where: MitraPackageWhereUniqueInput
    create: XOR<MitraPackageCreateWithoutTourPlusInput, MitraPackageUncheckedCreateWithoutTourPlusInput>
  }

  export type MitraPackageCreateManyTourPlusInputEnvelope = {
    data: MitraPackageCreateManyTourPlusInput | MitraPackageCreateManyTourPlusInput[]
    skipDuplicates?: boolean
  }

  export type MitraPackageUpsertWithWhereUniqueWithoutTourPlusInput = {
    where: MitraPackageWhereUniqueInput
    update: XOR<MitraPackageUpdateWithoutTourPlusInput, MitraPackageUncheckedUpdateWithoutTourPlusInput>
    create: XOR<MitraPackageCreateWithoutTourPlusInput, MitraPackageUncheckedCreateWithoutTourPlusInput>
  }

  export type MitraPackageUpdateWithWhereUniqueWithoutTourPlusInput = {
    where: MitraPackageWhereUniqueInput
    data: XOR<MitraPackageUpdateWithoutTourPlusInput, MitraPackageUncheckedUpdateWithoutTourPlusInput>
  }

  export type MitraPackageUpdateManyWithWhereWithoutTourPlusInput = {
    where: MitraPackageScalarWhereInput
    data: XOR<MitraPackageUpdateManyMutationInput, MitraPackageUncheckedUpdateManyWithoutTourPlusInput>
  }

  export type MitraPackageCreateWithoutManasikInput = {
    id?: string
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderCreateNestedManyWithoutMitraPackageInput
    period?: PeriodCreateNestedOneWithoutMitraPackagesInput
    airline?: AirlineCreateNestedOneWithoutMitraPackagesInput
    vendor?: VendorCreateNestedOneWithoutMitraPackagesInput
    hotelMekkah?: HotelCreateNestedOneWithoutMitraPackagesMekkahInput
    hotelMadinah?: HotelCreateNestedOneWithoutMitraPackagesMadinahInput
    visa?: VisaCreateNestedOneWithoutMitraPackagesInput
    transportation?: TransportationCreateNestedOneWithoutMitraPackageInput
    muthawif?: MuthawifCreateNestedOneWithoutMitraPackagesInput
    handlingSaudi?: HandlingSaudiCreateNestedOneWithoutMitraPackagesInput
    handlingDomestic?: HandlingDomesticCreateNestedOneWithoutMitraPackagesInput
    siskopatuh?: SiskopatuhCreateNestedOneWithoutMitraPackagesInput
    equipment?: EquipmentCreateNestedOneWithoutMitraPackagesInput
    tourPlus?: TourPlusCreateNestedOneWithoutMitraPackagesInput
  }

  export type MitraPackageUncheckedCreateWithoutManasikInput = {
    id?: string
    period_id?: string | null
    airline_id?: string | null
    vendor_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    visa_id?: string | null
    transportation_id?: string | null
    muthawif_id?: string | null
    handling_saudi_id?: string | null
    handling_domestic_id?: string | null
    siskopatuh_id?: string | null
    equipment_id?: string | null
    tour_plus_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedCreateNestedManyWithoutMitraPackageInput
  }

  export type MitraPackageCreateOrConnectWithoutManasikInput = {
    where: MitraPackageWhereUniqueInput
    create: XOR<MitraPackageCreateWithoutManasikInput, MitraPackageUncheckedCreateWithoutManasikInput>
  }

  export type MitraPackageCreateManyManasikInputEnvelope = {
    data: MitraPackageCreateManyManasikInput | MitraPackageCreateManyManasikInput[]
    skipDuplicates?: boolean
  }

  export type MitraPackageUpsertWithWhereUniqueWithoutManasikInput = {
    where: MitraPackageWhereUniqueInput
    update: XOR<MitraPackageUpdateWithoutManasikInput, MitraPackageUncheckedUpdateWithoutManasikInput>
    create: XOR<MitraPackageCreateWithoutManasikInput, MitraPackageUncheckedCreateWithoutManasikInput>
  }

  export type MitraPackageUpdateWithWhereUniqueWithoutManasikInput = {
    where: MitraPackageWhereUniqueInput
    data: XOR<MitraPackageUpdateWithoutManasikInput, MitraPackageUncheckedUpdateWithoutManasikInput>
  }

  export type MitraPackageUpdateManyWithWhereWithoutManasikInput = {
    where: MitraPackageScalarWhereInput
    data: XOR<MitraPackageUpdateManyMutationInput, MitraPackageUncheckedUpdateManyWithoutManasikInput>
  }

  export type MitraPackageOrderCreateWithoutMitraPackageInput = {
    id?: string
    created_at?: Date | string
    updated_at?: Date | string
    User: UserCreateNestedOneWithoutMitraPackageOrderInput
  }

  export type MitraPackageOrderUncheckedCreateWithoutMitraPackageInput = {
    id?: string
    user_id: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MitraPackageOrderCreateOrConnectWithoutMitraPackageInput = {
    where: MitraPackageOrderWhereUniqueInput
    create: XOR<MitraPackageOrderCreateWithoutMitraPackageInput, MitraPackageOrderUncheckedCreateWithoutMitraPackageInput>
  }

  export type MitraPackageOrderCreateManyMitraPackageInputEnvelope = {
    data: MitraPackageOrderCreateManyMitraPackageInput | MitraPackageOrderCreateManyMitraPackageInput[]
    skipDuplicates?: boolean
  }

  export type PeriodCreateWithoutMitraPackagesInput = {
    id?: string
    category?: $Enums.PeriodCategory
    start_date: Date | string
    end_date: Date | string
    created_at?: Date | string
    updated_at?: Date | string
    HotelPeriodPrices?: HotelPeriodPriceCreateNestedManyWithoutPeriodInput
  }

  export type PeriodUncheckedCreateWithoutMitraPackagesInput = {
    id?: string
    category?: $Enums.PeriodCategory
    start_date: Date | string
    end_date: Date | string
    created_at?: Date | string
    updated_at?: Date | string
    HotelPeriodPrices?: HotelPeriodPriceUncheckedCreateNestedManyWithoutPeriodInput
  }

  export type PeriodCreateOrConnectWithoutMitraPackagesInput = {
    where: PeriodWhereUniqueInput
    create: XOR<PeriodCreateWithoutMitraPackagesInput, PeriodUncheckedCreateWithoutMitraPackagesInput>
  }

  export type AirlineCreateWithoutMitraPackagesInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type AirlineUncheckedCreateWithoutMitraPackagesInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type AirlineCreateOrConnectWithoutMitraPackagesInput = {
    where: AirlineWhereUniqueInput
    create: XOR<AirlineCreateWithoutMitraPackagesInput, AirlineUncheckedCreateWithoutMitraPackagesInput>
  }

  export type VendorCreateWithoutMitraPackagesInput = {
    id?: string
    name: string
    created_at?: Date | string
    updated_at?: Date | string
    Hotels?: HotelCreateNestedManyWithoutVendorInput
  }

  export type VendorUncheckedCreateWithoutMitraPackagesInput = {
    id?: string
    name: string
    created_at?: Date | string
    updated_at?: Date | string
    Hotels?: HotelUncheckedCreateNestedManyWithoutVendorInput
  }

  export type VendorCreateOrConnectWithoutMitraPackagesInput = {
    where: VendorWhereUniqueInput
    create: XOR<VendorCreateWithoutMitraPackagesInput, VendorUncheckedCreateWithoutMitraPackagesInput>
  }

  export type HotelCreateWithoutMitraPackagesMekkahInput = {
    id?: string
    name: string
    city: $Enums.City
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    Vendor: VendorCreateNestedOneWithoutHotelsInput
    HotelPeriodPrices?: HotelPeriodPriceCreateNestedManyWithoutHotelInput
    MitraPackagesMadinah?: MitraPackageCreateNestedManyWithoutHotelMadinahInput
  }

  export type HotelUncheckedCreateWithoutMitraPackagesMekkahInput = {
    id?: string
    vendor_id: string
    name: string
    city: $Enums.City
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    HotelPeriodPrices?: HotelPeriodPriceUncheckedCreateNestedManyWithoutHotelInput
    MitraPackagesMadinah?: MitraPackageUncheckedCreateNestedManyWithoutHotelMadinahInput
  }

  export type HotelCreateOrConnectWithoutMitraPackagesMekkahInput = {
    where: HotelWhereUniqueInput
    create: XOR<HotelCreateWithoutMitraPackagesMekkahInput, HotelUncheckedCreateWithoutMitraPackagesMekkahInput>
  }

  export type HotelCreateWithoutMitraPackagesMadinahInput = {
    id?: string
    name: string
    city: $Enums.City
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    Vendor: VendorCreateNestedOneWithoutHotelsInput
    HotelPeriodPrices?: HotelPeriodPriceCreateNestedManyWithoutHotelInput
    MitraPackagesMekkah?: MitraPackageCreateNestedManyWithoutHotelMekkahInput
  }

  export type HotelUncheckedCreateWithoutMitraPackagesMadinahInput = {
    id?: string
    vendor_id: string
    name: string
    city: $Enums.City
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
    HotelPeriodPrices?: HotelPeriodPriceUncheckedCreateNestedManyWithoutHotelInput
    MitraPackagesMekkah?: MitraPackageUncheckedCreateNestedManyWithoutHotelMekkahInput
  }

  export type HotelCreateOrConnectWithoutMitraPackagesMadinahInput = {
    where: HotelWhereUniqueInput
    create: XOR<HotelCreateWithoutMitraPackagesMadinahInput, HotelUncheckedCreateWithoutMitraPackagesMadinahInput>
  }

  export type VisaCreateWithoutMitraPackagesInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type VisaUncheckedCreateWithoutMitraPackagesInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type VisaCreateOrConnectWithoutMitraPackagesInput = {
    where: VisaWhereUniqueInput
    create: XOR<VisaCreateWithoutMitraPackagesInput, VisaUncheckedCreateWithoutMitraPackagesInput>
  }

  export type TransportationCreateWithoutMitraPackageInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type TransportationUncheckedCreateWithoutMitraPackageInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type TransportationCreateOrConnectWithoutMitraPackageInput = {
    where: TransportationWhereUniqueInput
    create: XOR<TransportationCreateWithoutMitraPackageInput, TransportationUncheckedCreateWithoutMitraPackageInput>
  }

  export type MuthawifCreateWithoutMitraPackagesInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MuthawifUncheckedCreateWithoutMitraPackagesInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MuthawifCreateOrConnectWithoutMitraPackagesInput = {
    where: MuthawifWhereUniqueInput
    create: XOR<MuthawifCreateWithoutMitraPackagesInput, MuthawifUncheckedCreateWithoutMitraPackagesInput>
  }

  export type HandlingSaudiCreateWithoutMitraPackagesInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type HandlingSaudiUncheckedCreateWithoutMitraPackagesInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type HandlingSaudiCreateOrConnectWithoutMitraPackagesInput = {
    where: HandlingSaudiWhereUniqueInput
    create: XOR<HandlingSaudiCreateWithoutMitraPackagesInput, HandlingSaudiUncheckedCreateWithoutMitraPackagesInput>
  }

  export type HandlingDomesticCreateWithoutMitraPackagesInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type HandlingDomesticUncheckedCreateWithoutMitraPackagesInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type HandlingDomesticCreateOrConnectWithoutMitraPackagesInput = {
    where: HandlingDomesticWhereUniqueInput
    create: XOR<HandlingDomesticCreateWithoutMitraPackagesInput, HandlingDomesticUncheckedCreateWithoutMitraPackagesInput>
  }

  export type SiskopatuhCreateWithoutMitraPackagesInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type SiskopatuhUncheckedCreateWithoutMitraPackagesInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type SiskopatuhCreateOrConnectWithoutMitraPackagesInput = {
    where: SiskopatuhWhereUniqueInput
    create: XOR<SiskopatuhCreateWithoutMitraPackagesInput, SiskopatuhUncheckedCreateWithoutMitraPackagesInput>
  }

  export type EquipmentCreateWithoutMitraPackagesInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type EquipmentUncheckedCreateWithoutMitraPackagesInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type EquipmentCreateOrConnectWithoutMitraPackagesInput = {
    where: EquipmentWhereUniqueInput
    create: XOR<EquipmentCreateWithoutMitraPackagesInput, EquipmentUncheckedCreateWithoutMitraPackagesInput>
  }

  export type TourPlusCreateWithoutMitraPackagesInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type TourPlusUncheckedCreateWithoutMitraPackagesInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type TourPlusCreateOrConnectWithoutMitraPackagesInput = {
    where: TourPlusWhereUniqueInput
    create: XOR<TourPlusCreateWithoutMitraPackagesInput, TourPlusUncheckedCreateWithoutMitraPackagesInput>
  }

  export type ManasikCreateWithoutMitraPackagesInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type ManasikUncheckedCreateWithoutMitraPackagesInput = {
    id?: string
    name: string
    price_idr: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type ManasikCreateOrConnectWithoutMitraPackagesInput = {
    where: ManasikWhereUniqueInput
    create: XOR<ManasikCreateWithoutMitraPackagesInput, ManasikUncheckedCreateWithoutMitraPackagesInput>
  }

  export type MitraPackageOrderUpsertWithWhereUniqueWithoutMitraPackageInput = {
    where: MitraPackageOrderWhereUniqueInput
    update: XOR<MitraPackageOrderUpdateWithoutMitraPackageInput, MitraPackageOrderUncheckedUpdateWithoutMitraPackageInput>
    create: XOR<MitraPackageOrderCreateWithoutMitraPackageInput, MitraPackageOrderUncheckedCreateWithoutMitraPackageInput>
  }

  export type MitraPackageOrderUpdateWithWhereUniqueWithoutMitraPackageInput = {
    where: MitraPackageOrderWhereUniqueInput
    data: XOR<MitraPackageOrderUpdateWithoutMitraPackageInput, MitraPackageOrderUncheckedUpdateWithoutMitraPackageInput>
  }

  export type MitraPackageOrderUpdateManyWithWhereWithoutMitraPackageInput = {
    where: MitraPackageOrderScalarWhereInput
    data: XOR<MitraPackageOrderUpdateManyMutationInput, MitraPackageOrderUncheckedUpdateManyWithoutMitraPackageInput>
  }

  export type PeriodUpsertWithoutMitraPackagesInput = {
    update: XOR<PeriodUpdateWithoutMitraPackagesInput, PeriodUncheckedUpdateWithoutMitraPackagesInput>
    create: XOR<PeriodCreateWithoutMitraPackagesInput, PeriodUncheckedCreateWithoutMitraPackagesInput>
    where?: PeriodWhereInput
  }

  export type PeriodUpdateToOneWithWhereWithoutMitraPackagesInput = {
    where?: PeriodWhereInput
    data: XOR<PeriodUpdateWithoutMitraPackagesInput, PeriodUncheckedUpdateWithoutMitraPackagesInput>
  }

  export type PeriodUpdateWithoutMitraPackagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    category?: EnumPeriodCategoryFieldUpdateOperationsInput | $Enums.PeriodCategory
    start_date?: DateTimeFieldUpdateOperationsInput | Date | string
    end_date?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    HotelPeriodPrices?: HotelPeriodPriceUpdateManyWithoutPeriodNestedInput
  }

  export type PeriodUncheckedUpdateWithoutMitraPackagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    category?: EnumPeriodCategoryFieldUpdateOperationsInput | $Enums.PeriodCategory
    start_date?: DateTimeFieldUpdateOperationsInput | Date | string
    end_date?: DateTimeFieldUpdateOperationsInput | Date | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    HotelPeriodPrices?: HotelPeriodPriceUncheckedUpdateManyWithoutPeriodNestedInput
  }

  export type AirlineUpsertWithoutMitraPackagesInput = {
    update: XOR<AirlineUpdateWithoutMitraPackagesInput, AirlineUncheckedUpdateWithoutMitraPackagesInput>
    create: XOR<AirlineCreateWithoutMitraPackagesInput, AirlineUncheckedCreateWithoutMitraPackagesInput>
    where?: AirlineWhereInput
  }

  export type AirlineUpdateToOneWithWhereWithoutMitraPackagesInput = {
    where?: AirlineWhereInput
    data: XOR<AirlineUpdateWithoutMitraPackagesInput, AirlineUncheckedUpdateWithoutMitraPackagesInput>
  }

  export type AirlineUpdateWithoutMitraPackagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AirlineUncheckedUpdateWithoutMitraPackagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type VendorUpsertWithoutMitraPackagesInput = {
    update: XOR<VendorUpdateWithoutMitraPackagesInput, VendorUncheckedUpdateWithoutMitraPackagesInput>
    create: XOR<VendorCreateWithoutMitraPackagesInput, VendorUncheckedCreateWithoutMitraPackagesInput>
    where?: VendorWhereInput
  }

  export type VendorUpdateToOneWithWhereWithoutMitraPackagesInput = {
    where?: VendorWhereInput
    data: XOR<VendorUpdateWithoutMitraPackagesInput, VendorUncheckedUpdateWithoutMitraPackagesInput>
  }

  export type VendorUpdateWithoutMitraPackagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    Hotels?: HotelUpdateManyWithoutVendorNestedInput
  }

  export type VendorUncheckedUpdateWithoutMitraPackagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    Hotels?: HotelUncheckedUpdateManyWithoutVendorNestedInput
  }

  export type HotelUpsertWithoutMitraPackagesMekkahInput = {
    update: XOR<HotelUpdateWithoutMitraPackagesMekkahInput, HotelUncheckedUpdateWithoutMitraPackagesMekkahInput>
    create: XOR<HotelCreateWithoutMitraPackagesMekkahInput, HotelUncheckedCreateWithoutMitraPackagesMekkahInput>
    where?: HotelWhereInput
  }

  export type HotelUpdateToOneWithWhereWithoutMitraPackagesMekkahInput = {
    where?: HotelWhereInput
    data: XOR<HotelUpdateWithoutMitraPackagesMekkahInput, HotelUncheckedUpdateWithoutMitraPackagesMekkahInput>
  }

  export type HotelUpdateWithoutMitraPackagesMekkahInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    city?: EnumCityFieldUpdateOperationsInput | $Enums.City
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    Vendor?: VendorUpdateOneRequiredWithoutHotelsNestedInput
    HotelPeriodPrices?: HotelPeriodPriceUpdateManyWithoutHotelNestedInput
    MitraPackagesMadinah?: MitraPackageUpdateManyWithoutHotelMadinahNestedInput
  }

  export type HotelUncheckedUpdateWithoutMitraPackagesMekkahInput = {
    id?: StringFieldUpdateOperationsInput | string
    vendor_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    city?: EnumCityFieldUpdateOperationsInput | $Enums.City
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    HotelPeriodPrices?: HotelPeriodPriceUncheckedUpdateManyWithoutHotelNestedInput
    MitraPackagesMadinah?: MitraPackageUncheckedUpdateManyWithoutHotelMadinahNestedInput
  }

  export type HotelUpsertWithoutMitraPackagesMadinahInput = {
    update: XOR<HotelUpdateWithoutMitraPackagesMadinahInput, HotelUncheckedUpdateWithoutMitraPackagesMadinahInput>
    create: XOR<HotelCreateWithoutMitraPackagesMadinahInput, HotelUncheckedCreateWithoutMitraPackagesMadinahInput>
    where?: HotelWhereInput
  }

  export type HotelUpdateToOneWithWhereWithoutMitraPackagesMadinahInput = {
    where?: HotelWhereInput
    data: XOR<HotelUpdateWithoutMitraPackagesMadinahInput, HotelUncheckedUpdateWithoutMitraPackagesMadinahInput>
  }

  export type HotelUpdateWithoutMitraPackagesMadinahInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    city?: EnumCityFieldUpdateOperationsInput | $Enums.City
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    Vendor?: VendorUpdateOneRequiredWithoutHotelsNestedInput
    HotelPeriodPrices?: HotelPeriodPriceUpdateManyWithoutHotelNestedInput
    MitraPackagesMekkah?: MitraPackageUpdateManyWithoutHotelMekkahNestedInput
  }

  export type HotelUncheckedUpdateWithoutMitraPackagesMadinahInput = {
    id?: StringFieldUpdateOperationsInput | string
    vendor_id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    city?: EnumCityFieldUpdateOperationsInput | $Enums.City
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    HotelPeriodPrices?: HotelPeriodPriceUncheckedUpdateManyWithoutHotelNestedInput
    MitraPackagesMekkah?: MitraPackageUncheckedUpdateManyWithoutHotelMekkahNestedInput
  }

  export type VisaUpsertWithoutMitraPackagesInput = {
    update: XOR<VisaUpdateWithoutMitraPackagesInput, VisaUncheckedUpdateWithoutMitraPackagesInput>
    create: XOR<VisaCreateWithoutMitraPackagesInput, VisaUncheckedCreateWithoutMitraPackagesInput>
    where?: VisaWhereInput
  }

  export type VisaUpdateToOneWithWhereWithoutMitraPackagesInput = {
    where?: VisaWhereInput
    data: XOR<VisaUpdateWithoutMitraPackagesInput, VisaUncheckedUpdateWithoutMitraPackagesInput>
  }

  export type VisaUpdateWithoutMitraPackagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type VisaUncheckedUpdateWithoutMitraPackagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type TransportationUpsertWithoutMitraPackageInput = {
    update: XOR<TransportationUpdateWithoutMitraPackageInput, TransportationUncheckedUpdateWithoutMitraPackageInput>
    create: XOR<TransportationCreateWithoutMitraPackageInput, TransportationUncheckedCreateWithoutMitraPackageInput>
    where?: TransportationWhereInput
  }

  export type TransportationUpdateToOneWithWhereWithoutMitraPackageInput = {
    where?: TransportationWhereInput
    data: XOR<TransportationUpdateWithoutMitraPackageInput, TransportationUncheckedUpdateWithoutMitraPackageInput>
  }

  export type TransportationUpdateWithoutMitraPackageInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type TransportationUncheckedUpdateWithoutMitraPackageInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MuthawifUpsertWithoutMitraPackagesInput = {
    update: XOR<MuthawifUpdateWithoutMitraPackagesInput, MuthawifUncheckedUpdateWithoutMitraPackagesInput>
    create: XOR<MuthawifCreateWithoutMitraPackagesInput, MuthawifUncheckedCreateWithoutMitraPackagesInput>
    where?: MuthawifWhereInput
  }

  export type MuthawifUpdateToOneWithWhereWithoutMitraPackagesInput = {
    where?: MuthawifWhereInput
    data: XOR<MuthawifUpdateWithoutMitraPackagesInput, MuthawifUncheckedUpdateWithoutMitraPackagesInput>
  }

  export type MuthawifUpdateWithoutMitraPackagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MuthawifUncheckedUpdateWithoutMitraPackagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type HandlingSaudiUpsertWithoutMitraPackagesInput = {
    update: XOR<HandlingSaudiUpdateWithoutMitraPackagesInput, HandlingSaudiUncheckedUpdateWithoutMitraPackagesInput>
    create: XOR<HandlingSaudiCreateWithoutMitraPackagesInput, HandlingSaudiUncheckedCreateWithoutMitraPackagesInput>
    where?: HandlingSaudiWhereInput
  }

  export type HandlingSaudiUpdateToOneWithWhereWithoutMitraPackagesInput = {
    where?: HandlingSaudiWhereInput
    data: XOR<HandlingSaudiUpdateWithoutMitraPackagesInput, HandlingSaudiUncheckedUpdateWithoutMitraPackagesInput>
  }

  export type HandlingSaudiUpdateWithoutMitraPackagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type HandlingSaudiUncheckedUpdateWithoutMitraPackagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type HandlingDomesticUpsertWithoutMitraPackagesInput = {
    update: XOR<HandlingDomesticUpdateWithoutMitraPackagesInput, HandlingDomesticUncheckedUpdateWithoutMitraPackagesInput>
    create: XOR<HandlingDomesticCreateWithoutMitraPackagesInput, HandlingDomesticUncheckedCreateWithoutMitraPackagesInput>
    where?: HandlingDomesticWhereInput
  }

  export type HandlingDomesticUpdateToOneWithWhereWithoutMitraPackagesInput = {
    where?: HandlingDomesticWhereInput
    data: XOR<HandlingDomesticUpdateWithoutMitraPackagesInput, HandlingDomesticUncheckedUpdateWithoutMitraPackagesInput>
  }

  export type HandlingDomesticUpdateWithoutMitraPackagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type HandlingDomesticUncheckedUpdateWithoutMitraPackagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SiskopatuhUpsertWithoutMitraPackagesInput = {
    update: XOR<SiskopatuhUpdateWithoutMitraPackagesInput, SiskopatuhUncheckedUpdateWithoutMitraPackagesInput>
    create: XOR<SiskopatuhCreateWithoutMitraPackagesInput, SiskopatuhUncheckedCreateWithoutMitraPackagesInput>
    where?: SiskopatuhWhereInput
  }

  export type SiskopatuhUpdateToOneWithWhereWithoutMitraPackagesInput = {
    where?: SiskopatuhWhereInput
    data: XOR<SiskopatuhUpdateWithoutMitraPackagesInput, SiskopatuhUncheckedUpdateWithoutMitraPackagesInput>
  }

  export type SiskopatuhUpdateWithoutMitraPackagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SiskopatuhUncheckedUpdateWithoutMitraPackagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EquipmentUpsertWithoutMitraPackagesInput = {
    update: XOR<EquipmentUpdateWithoutMitraPackagesInput, EquipmentUncheckedUpdateWithoutMitraPackagesInput>
    create: XOR<EquipmentCreateWithoutMitraPackagesInput, EquipmentUncheckedCreateWithoutMitraPackagesInput>
    where?: EquipmentWhereInput
  }

  export type EquipmentUpdateToOneWithWhereWithoutMitraPackagesInput = {
    where?: EquipmentWhereInput
    data: XOR<EquipmentUpdateWithoutMitraPackagesInput, EquipmentUncheckedUpdateWithoutMitraPackagesInput>
  }

  export type EquipmentUpdateWithoutMitraPackagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type EquipmentUncheckedUpdateWithoutMitraPackagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type TourPlusUpsertWithoutMitraPackagesInput = {
    update: XOR<TourPlusUpdateWithoutMitraPackagesInput, TourPlusUncheckedUpdateWithoutMitraPackagesInput>
    create: XOR<TourPlusCreateWithoutMitraPackagesInput, TourPlusUncheckedCreateWithoutMitraPackagesInput>
    where?: TourPlusWhereInput
  }

  export type TourPlusUpdateToOneWithWhereWithoutMitraPackagesInput = {
    where?: TourPlusWhereInput
    data: XOR<TourPlusUpdateWithoutMitraPackagesInput, TourPlusUncheckedUpdateWithoutMitraPackagesInput>
  }

  export type TourPlusUpdateWithoutMitraPackagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type TourPlusUncheckedUpdateWithoutMitraPackagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ManasikUpsertWithoutMitraPackagesInput = {
    update: XOR<ManasikUpdateWithoutMitraPackagesInput, ManasikUncheckedUpdateWithoutMitraPackagesInput>
    create: XOR<ManasikCreateWithoutMitraPackagesInput, ManasikUncheckedCreateWithoutMitraPackagesInput>
    where?: ManasikWhereInput
  }

  export type ManasikUpdateToOneWithWhereWithoutMitraPackagesInput = {
    where?: ManasikWhereInput
    data: XOR<ManasikUpdateWithoutMitraPackagesInput, ManasikUncheckedUpdateWithoutMitraPackagesInput>
  }

  export type ManasikUpdateWithoutMitraPackagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ManasikUncheckedUpdateWithoutMitraPackagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price_idr?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraPackageCreateWithoutMitraPackageOrdersInput = {
    id?: string
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
    period?: PeriodCreateNestedOneWithoutMitraPackagesInput
    airline?: AirlineCreateNestedOneWithoutMitraPackagesInput
    vendor?: VendorCreateNestedOneWithoutMitraPackagesInput
    hotelMekkah?: HotelCreateNestedOneWithoutMitraPackagesMekkahInput
    hotelMadinah?: HotelCreateNestedOneWithoutMitraPackagesMadinahInput
    visa?: VisaCreateNestedOneWithoutMitraPackagesInput
    transportation?: TransportationCreateNestedOneWithoutMitraPackageInput
    muthawif?: MuthawifCreateNestedOneWithoutMitraPackagesInput
    handlingSaudi?: HandlingSaudiCreateNestedOneWithoutMitraPackagesInput
    handlingDomestic?: HandlingDomesticCreateNestedOneWithoutMitraPackagesInput
    siskopatuh?: SiskopatuhCreateNestedOneWithoutMitraPackagesInput
    equipment?: EquipmentCreateNestedOneWithoutMitraPackagesInput
    tourPlus?: TourPlusCreateNestedOneWithoutMitraPackagesInput
    manasik?: ManasikCreateNestedOneWithoutMitraPackagesInput
  }

  export type MitraPackageUncheckedCreateWithoutMitraPackageOrdersInput = {
    id?: string
    period_id?: string | null
    airline_id?: string | null
    vendor_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    visa_id?: string | null
    transportation_id?: string | null
    muthawif_id?: string | null
    handling_saudi_id?: string | null
    handling_domestic_id?: string | null
    siskopatuh_id?: string | null
    equipment_id?: string | null
    tour_plus_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MitraPackageCreateOrConnectWithoutMitraPackageOrdersInput = {
    where: MitraPackageWhereUniqueInput
    create: XOR<MitraPackageCreateWithoutMitraPackageOrdersInput, MitraPackageUncheckedCreateWithoutMitraPackageOrdersInput>
  }

  export type UserCreateWithoutMitraPackageOrderInput = {
    id?: string
    email: string
    full_name: string
    password: string
    whatsapp_number: string
    role?: $Enums.Role
    created_at?: Date | string
    updated_at?: Date | string
    ProductOrders?: ProductOrderCreateNestedManyWithoutUserInput
    MitraRequest?: MitraRequestCreateNestedManyWithoutUserInput
  }

  export type UserUncheckedCreateWithoutMitraPackageOrderInput = {
    id?: string
    email: string
    full_name: string
    password: string
    whatsapp_number: string
    role?: $Enums.Role
    created_at?: Date | string
    updated_at?: Date | string
    ProductOrders?: ProductOrderUncheckedCreateNestedManyWithoutUserInput
    MitraRequest?: MitraRequestUncheckedCreateNestedManyWithoutUserInput
  }

  export type UserCreateOrConnectWithoutMitraPackageOrderInput = {
    where: UserWhereUniqueInput
    create: XOR<UserCreateWithoutMitraPackageOrderInput, UserUncheckedCreateWithoutMitraPackageOrderInput>
  }

  export type MitraPackageUpsertWithoutMitraPackageOrdersInput = {
    update: XOR<MitraPackageUpdateWithoutMitraPackageOrdersInput, MitraPackageUncheckedUpdateWithoutMitraPackageOrdersInput>
    create: XOR<MitraPackageCreateWithoutMitraPackageOrdersInput, MitraPackageUncheckedCreateWithoutMitraPackageOrdersInput>
    where?: MitraPackageWhereInput
  }

  export type MitraPackageUpdateToOneWithWhereWithoutMitraPackageOrdersInput = {
    where?: MitraPackageWhereInput
    data: XOR<MitraPackageUpdateWithoutMitraPackageOrdersInput, MitraPackageUncheckedUpdateWithoutMitraPackageOrdersInput>
  }

  export type MitraPackageUpdateWithoutMitraPackageOrdersInput = {
    id?: StringFieldUpdateOperationsInput | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    period?: PeriodUpdateOneWithoutMitraPackagesNestedInput
    airline?: AirlineUpdateOneWithoutMitraPackagesNestedInput
    vendor?: VendorUpdateOneWithoutMitraPackagesNestedInput
    hotelMekkah?: HotelUpdateOneWithoutMitraPackagesMekkahNestedInput
    hotelMadinah?: HotelUpdateOneWithoutMitraPackagesMadinahNestedInput
    visa?: VisaUpdateOneWithoutMitraPackagesNestedInput
    transportation?: TransportationUpdateOneWithoutMitraPackageNestedInput
    muthawif?: MuthawifUpdateOneWithoutMitraPackagesNestedInput
    handlingSaudi?: HandlingSaudiUpdateOneWithoutMitraPackagesNestedInput
    handlingDomestic?: HandlingDomesticUpdateOneWithoutMitraPackagesNestedInput
    siskopatuh?: SiskopatuhUpdateOneWithoutMitraPackagesNestedInput
    equipment?: EquipmentUpdateOneWithoutMitraPackagesNestedInput
    tourPlus?: TourPlusUpdateOneWithoutMitraPackagesNestedInput
    manasik?: ManasikUpdateOneWithoutMitraPackagesNestedInput
  }

  export type MitraPackageUncheckedUpdateWithoutMitraPackageOrdersInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserUpsertWithoutMitraPackageOrderInput = {
    update: XOR<UserUpdateWithoutMitraPackageOrderInput, UserUncheckedUpdateWithoutMitraPackageOrderInput>
    create: XOR<UserCreateWithoutMitraPackageOrderInput, UserUncheckedCreateWithoutMitraPackageOrderInput>
    where?: UserWhereInput
  }

  export type UserUpdateToOneWithWhereWithoutMitraPackageOrderInput = {
    where?: UserWhereInput
    data: XOR<UserUpdateWithoutMitraPackageOrderInput, UserUncheckedUpdateWithoutMitraPackageOrderInput>
  }

  export type UserUpdateWithoutMitraPackageOrderInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    full_name?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    whatsapp_number?: StringFieldUpdateOperationsInput | string
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ProductOrders?: ProductOrderUpdateManyWithoutUserNestedInput
    MitraRequest?: MitraRequestUpdateManyWithoutUserNestedInput
  }

  export type UserUncheckedUpdateWithoutMitraPackageOrderInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    full_name?: StringFieldUpdateOperationsInput | string
    password?: StringFieldUpdateOperationsInput | string
    whatsapp_number?: StringFieldUpdateOperationsInput | string
    role?: EnumRoleFieldUpdateOperationsInput | $Enums.Role
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ProductOrders?: ProductOrderUncheckedUpdateManyWithoutUserNestedInput
    MitraRequest?: MitraRequestUncheckedUpdateManyWithoutUserNestedInput
  }

  export type FooterItemCreateWithoutFooterInput = {
    id?: string
    name: string
    url: string
    visible?: boolean
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type FooterItemUncheckedCreateWithoutFooterInput = {
    id?: string
    name: string
    url: string
    visible?: boolean
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type FooterItemCreateOrConnectWithoutFooterInput = {
    where: FooterItemWhereUniqueInput
    create: XOR<FooterItemCreateWithoutFooterInput, FooterItemUncheckedCreateWithoutFooterInput>
  }

  export type FooterItemCreateManyFooterInputEnvelope = {
    data: FooterItemCreateManyFooterInput | FooterItemCreateManyFooterInput[]
    skipDuplicates?: boolean
  }

  export type FooterItemUpsertWithWhereUniqueWithoutFooterInput = {
    where: FooterItemWhereUniqueInput
    update: XOR<FooterItemUpdateWithoutFooterInput, FooterItemUncheckedUpdateWithoutFooterInput>
    create: XOR<FooterItemCreateWithoutFooterInput, FooterItemUncheckedCreateWithoutFooterInput>
  }

  export type FooterItemUpdateWithWhereUniqueWithoutFooterInput = {
    where: FooterItemWhereUniqueInput
    data: XOR<FooterItemUpdateWithoutFooterInput, FooterItemUncheckedUpdateWithoutFooterInput>
  }

  export type FooterItemUpdateManyWithWhereWithoutFooterInput = {
    where: FooterItemScalarWhereInput
    data: XOR<FooterItemUpdateManyMutationInput, FooterItemUncheckedUpdateManyWithoutFooterInput>
  }

  export type FooterItemScalarWhereInput = {
    AND?: FooterItemScalarWhereInput | FooterItemScalarWhereInput[]
    OR?: FooterItemScalarWhereInput[]
    NOT?: FooterItemScalarWhereInput | FooterItemScalarWhereInput[]
    id?: StringFilter<"FooterItem"> | string
    footer_id?: StringFilter<"FooterItem"> | string
    name?: StringFilter<"FooterItem"> | string
    url?: StringFilter<"FooterItem"> | string
    visible?: BoolFilter<"FooterItem"> | boolean
    created_at?: DateTimeFilter<"FooterItem"> | Date | string
    updated_at?: DateTimeFilter<"FooterItem"> | Date | string
  }

  export type FooterCreateWithoutFooterItemInput = {
    id?: string
    name: string
    type: $Enums.FooterType
    visible?: boolean
    order?: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type FooterUncheckedCreateWithoutFooterItemInput = {
    id?: string
    name: string
    type: $Enums.FooterType
    visible?: boolean
    order?: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type FooterCreateOrConnectWithoutFooterItemInput = {
    where: FooterWhereUniqueInput
    create: XOR<FooterCreateWithoutFooterItemInput, FooterUncheckedCreateWithoutFooterItemInput>
  }

  export type FooterUpsertWithoutFooterItemInput = {
    update: XOR<FooterUpdateWithoutFooterItemInput, FooterUncheckedUpdateWithoutFooterItemInput>
    create: XOR<FooterCreateWithoutFooterItemInput, FooterUncheckedCreateWithoutFooterItemInput>
    where?: FooterWhereInput
  }

  export type FooterUpdateToOneWithWhereWithoutFooterItemInput = {
    where?: FooterWhereInput
    data: XOR<FooterUpdateWithoutFooterItemInput, FooterUncheckedUpdateWithoutFooterItemInput>
  }

  export type FooterUpdateWithoutFooterItemInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    type?: EnumFooterTypeFieldUpdateOperationsInput | $Enums.FooterType
    visible?: BoolFieldUpdateOperationsInput | boolean
    order?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FooterUncheckedUpdateWithoutFooterItemInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    type?: EnumFooterTypeFieldUpdateOperationsInput | $Enums.FooterType
    visible?: BoolFieldUpdateOperationsInput | boolean
    order?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProductOrderCreateManyUserInput = {
    id?: string
    product_id: string
    variation_id?: string | null
    departure: Date | string
    number_of_pax: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MitraPackageOrderCreateManyUserInput = {
    id?: string
    mitra_package_id: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MitraRequestCreateManyUserInput = {
    id?: string
    ktp: string
    upgrade_amount: Decimal | DecimalJsLike | number | string
    payment_proof: string
    status?: $Enums.RequestStatus
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type ProductOrderUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    departure?: DateTimeFieldUpdateOperationsInput | Date | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    Product?: ProductUpdateOneRequiredWithoutProductOrdersNestedInput
    ProductVariation?: ProductVariationUpdateOneWithoutProductOrdersNestedInput
  }

  export type ProductOrderUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    product_id?: StringFieldUpdateOperationsInput | string
    variation_id?: NullableStringFieldUpdateOperationsInput | string | null
    departure?: DateTimeFieldUpdateOperationsInput | Date | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProductOrderUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    product_id?: StringFieldUpdateOperationsInput | string
    variation_id?: NullableStringFieldUpdateOperationsInput | string | null
    departure?: DateTimeFieldUpdateOperationsInput | Date | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraPackageOrderUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackage?: MitraPackageUpdateOneRequiredWithoutMitraPackageOrdersNestedInput
  }

  export type MitraPackageOrderUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    mitra_package_id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraPackageOrderUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    mitra_package_id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraRequestUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    ktp?: StringFieldUpdateOperationsInput | string
    upgrade_amount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    payment_proof?: StringFieldUpdateOperationsInput | string
    status?: EnumRequestStatusFieldUpdateOperationsInput | $Enums.RequestStatus
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraRequestUncheckedUpdateWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    ktp?: StringFieldUpdateOperationsInput | string
    upgrade_amount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    payment_proof?: StringFieldUpdateOperationsInput | string
    status?: EnumRequestStatusFieldUpdateOperationsInput | $Enums.RequestStatus
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraRequestUncheckedUpdateManyWithoutUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    ktp?: StringFieldUpdateOperationsInput | string
    upgrade_amount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    payment_proof?: StringFieldUpdateOperationsInput | string
    status?: EnumRequestStatusFieldUpdateOperationsInput | $Enums.RequestStatus
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserPackageOrderCreateManyUserPackageInput = {
    id?: string
    full_name: string
    email: string
    whatsapp_number: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type UserPackageOrderUpdateWithoutUserPackageInput = {
    id?: StringFieldUpdateOperationsInput | string
    full_name?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    whatsapp_number?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserPackageOrderUncheckedUpdateWithoutUserPackageInput = {
    id?: StringFieldUpdateOperationsInput | string
    full_name?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    whatsapp_number?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserPackageOrderUncheckedUpdateManyWithoutUserPackageInput = {
    id?: StringFieldUpdateOperationsInput | string
    full_name?: StringFieldUpdateOperationsInput | string
    email?: StringFieldUpdateOperationsInput | string
    whatsapp_number?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserPackageOptionCreateManyPackageTypeInput = {
    id?: string
    name: string
    price: Decimal | DecimalJsLike | number | string
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type UserPackageOptionUpdateWithoutPackageTypeInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    transportations?: UserPackageUpdateManyWithoutTransportationNestedInput
    flights?: UserPackageUpdateManyWithoutFlightNestedInput
    hotelMekkahs?: UserPackageUpdateManyWithoutHotelMekkahNestedInput
    hotelMadinahs?: UserPackageUpdateManyWithoutHotelMadinahNestedInput
    muthawifs?: UserPackageUpdateManyWithoutMuthawifNestedInput
    handlings?: UserPackageUpdateManyWithoutHandlingNestedInput
  }

  export type UserPackageOptionUncheckedUpdateWithoutPackageTypeInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    transportations?: UserPackageUncheckedUpdateManyWithoutTransportationNestedInput
    flights?: UserPackageUncheckedUpdateManyWithoutFlightNestedInput
    hotelMekkahs?: UserPackageUncheckedUpdateManyWithoutHotelMekkahNestedInput
    hotelMadinahs?: UserPackageUncheckedUpdateManyWithoutHotelMadinahNestedInput
    muthawifs?: UserPackageUncheckedUpdateManyWithoutMuthawifNestedInput
    handlings?: UserPackageUncheckedUpdateManyWithoutHandlingNestedInput
  }

  export type UserPackageOptionUncheckedUpdateManyWithoutPackageTypeInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserPackageCreateManyTransportationInput = {
    id?: string
    flight_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    muthawif_id?: string | null
    handling_id?: string | null
    number_of_pax: number
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type UserPackageCreateManyFlightInput = {
    id?: string
    transportation_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    muthawif_id?: string | null
    handling_id?: string | null
    number_of_pax: number
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type UserPackageCreateManyHotelMekkahInput = {
    id?: string
    transportation_id?: string | null
    flight_id?: string | null
    hotel_madinah_id?: string | null
    muthawif_id?: string | null
    handling_id?: string | null
    number_of_pax: number
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type UserPackageCreateManyHotelMadinahInput = {
    id?: string
    transportation_id?: string | null
    flight_id?: string | null
    hotel_mekkah_id?: string | null
    muthawif_id?: string | null
    handling_id?: string | null
    number_of_pax: number
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type UserPackageCreateManyMuthawifInput = {
    id?: string
    transportation_id?: string | null
    flight_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    handling_id?: string | null
    number_of_pax: number
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type UserPackageCreateManyHandlingInput = {
    id?: string
    transportation_id?: string | null
    flight_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    muthawif_id?: string | null
    number_of_pax: number
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type UserPackageUpdateWithoutTransportationInput = {
    id?: StringFieldUpdateOperationsInput | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    UserPackageOrders?: UserPackageOrderUpdateManyWithoutUserPackageNestedInput
    flight?: UserPackageOptionUpdateOneWithoutFlightsNestedInput
    hotelMekkah?: UserPackageOptionUpdateOneWithoutHotelMekkahsNestedInput
    hotelMadinah?: UserPackageOptionUpdateOneWithoutHotelMadinahsNestedInput
    muthawif?: UserPackageOptionUpdateOneWithoutMuthawifsNestedInput
    handling?: UserPackageOptionUpdateOneWithoutHandlingsNestedInput
  }

  export type UserPackageUncheckedUpdateWithoutTransportationInput = {
    id?: StringFieldUpdateOperationsInput | string
    flight_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    UserPackageOrders?: UserPackageOrderUncheckedUpdateManyWithoutUserPackageNestedInput
  }

  export type UserPackageUncheckedUpdateManyWithoutTransportationInput = {
    id?: StringFieldUpdateOperationsInput | string
    flight_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserPackageUpdateWithoutFlightInput = {
    id?: StringFieldUpdateOperationsInput | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    UserPackageOrders?: UserPackageOrderUpdateManyWithoutUserPackageNestedInput
    transportation?: UserPackageOptionUpdateOneWithoutTransportationsNestedInput
    hotelMekkah?: UserPackageOptionUpdateOneWithoutHotelMekkahsNestedInput
    hotelMadinah?: UserPackageOptionUpdateOneWithoutHotelMadinahsNestedInput
    muthawif?: UserPackageOptionUpdateOneWithoutMuthawifsNestedInput
    handling?: UserPackageOptionUpdateOneWithoutHandlingsNestedInput
  }

  export type UserPackageUncheckedUpdateWithoutFlightInput = {
    id?: StringFieldUpdateOperationsInput | string
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    UserPackageOrders?: UserPackageOrderUncheckedUpdateManyWithoutUserPackageNestedInput
  }

  export type UserPackageUncheckedUpdateManyWithoutFlightInput = {
    id?: StringFieldUpdateOperationsInput | string
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserPackageUpdateWithoutHotelMekkahInput = {
    id?: StringFieldUpdateOperationsInput | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    UserPackageOrders?: UserPackageOrderUpdateManyWithoutUserPackageNestedInput
    transportation?: UserPackageOptionUpdateOneWithoutTransportationsNestedInput
    flight?: UserPackageOptionUpdateOneWithoutFlightsNestedInput
    hotelMadinah?: UserPackageOptionUpdateOneWithoutHotelMadinahsNestedInput
    muthawif?: UserPackageOptionUpdateOneWithoutMuthawifsNestedInput
    handling?: UserPackageOptionUpdateOneWithoutHandlingsNestedInput
  }

  export type UserPackageUncheckedUpdateWithoutHotelMekkahInput = {
    id?: StringFieldUpdateOperationsInput | string
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    flight_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    UserPackageOrders?: UserPackageOrderUncheckedUpdateManyWithoutUserPackageNestedInput
  }

  export type UserPackageUncheckedUpdateManyWithoutHotelMekkahInput = {
    id?: StringFieldUpdateOperationsInput | string
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    flight_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserPackageUpdateWithoutHotelMadinahInput = {
    id?: StringFieldUpdateOperationsInput | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    UserPackageOrders?: UserPackageOrderUpdateManyWithoutUserPackageNestedInput
    transportation?: UserPackageOptionUpdateOneWithoutTransportationsNestedInput
    flight?: UserPackageOptionUpdateOneWithoutFlightsNestedInput
    hotelMekkah?: UserPackageOptionUpdateOneWithoutHotelMekkahsNestedInput
    muthawif?: UserPackageOptionUpdateOneWithoutMuthawifsNestedInput
    handling?: UserPackageOptionUpdateOneWithoutHandlingsNestedInput
  }

  export type UserPackageUncheckedUpdateWithoutHotelMadinahInput = {
    id?: StringFieldUpdateOperationsInput | string
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    flight_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    UserPackageOrders?: UserPackageOrderUncheckedUpdateManyWithoutUserPackageNestedInput
  }

  export type UserPackageUncheckedUpdateManyWithoutHotelMadinahInput = {
    id?: StringFieldUpdateOperationsInput | string
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    flight_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserPackageUpdateWithoutMuthawifInput = {
    id?: StringFieldUpdateOperationsInput | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    UserPackageOrders?: UserPackageOrderUpdateManyWithoutUserPackageNestedInput
    transportation?: UserPackageOptionUpdateOneWithoutTransportationsNestedInput
    flight?: UserPackageOptionUpdateOneWithoutFlightsNestedInput
    hotelMekkah?: UserPackageOptionUpdateOneWithoutHotelMekkahsNestedInput
    hotelMadinah?: UserPackageOptionUpdateOneWithoutHotelMadinahsNestedInput
    handling?: UserPackageOptionUpdateOneWithoutHandlingsNestedInput
  }

  export type UserPackageUncheckedUpdateWithoutMuthawifInput = {
    id?: StringFieldUpdateOperationsInput | string
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    flight_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    UserPackageOrders?: UserPackageOrderUncheckedUpdateManyWithoutUserPackageNestedInput
  }

  export type UserPackageUncheckedUpdateManyWithoutMuthawifInput = {
    id?: StringFieldUpdateOperationsInput | string
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    flight_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserPackageUpdateWithoutHandlingInput = {
    id?: StringFieldUpdateOperationsInput | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    UserPackageOrders?: UserPackageOrderUpdateManyWithoutUserPackageNestedInput
    transportation?: UserPackageOptionUpdateOneWithoutTransportationsNestedInput
    flight?: UserPackageOptionUpdateOneWithoutFlightsNestedInput
    hotelMekkah?: UserPackageOptionUpdateOneWithoutHotelMekkahsNestedInput
    hotelMadinah?: UserPackageOptionUpdateOneWithoutHotelMadinahsNestedInput
    muthawif?: UserPackageOptionUpdateOneWithoutMuthawifsNestedInput
  }

  export type UserPackageUncheckedUpdateWithoutHandlingInput = {
    id?: StringFieldUpdateOperationsInput | string
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    flight_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    UserPackageOrders?: UserPackageOrderUncheckedUpdateManyWithoutUserPackageNestedInput
  }

  export type UserPackageUncheckedUpdateManyWithoutHandlingInput = {
    id?: StringFieldUpdateOperationsInput | string
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    flight_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProductCategoryCreateManyCategoryInput = {
    id?: string
    product_id: string
  }

  export type ProductCategoryUpdateWithoutCategoryInput = {
    id?: StringFieldUpdateOperationsInput | string
    Product?: ProductUpdateOneRequiredWithoutProductCategoriesNestedInput
  }

  export type ProductCategoryUncheckedUpdateWithoutCategoryInput = {
    id?: StringFieldUpdateOperationsInput | string
    product_id?: StringFieldUpdateOperationsInput | string
  }

  export type ProductCategoryUncheckedUpdateManyWithoutCategoryInput = {
    id?: StringFieldUpdateOperationsInput | string
    product_id?: StringFieldUpdateOperationsInput | string
  }

  export type ProductThumbnailCreateManyProductInput = {
    id?: string
    increment?: number
    image_url: string
  }

  export type ProductCategoryCreateManyProductInput = {
    id?: string
    category_id: string
  }

  export type ProductVariationCreateManyProductInput = {
    id?: string
    increment?: number
    name: string
    price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type ProductIncludeCreateManyProductInput = {
    id?: string
    increment?: number
    description: string
  }

  export type ProductExcludeCreateManyProductInput = {
    id?: string
    increment?: number
    description: string
  }

  export type ProductOrderCreateManyProductInput = {
    id?: string
    user_id: string
    variation_id?: string | null
    departure: Date | string
    number_of_pax: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type ProductThumbnailUpdateWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    image_url?: StringFieldUpdateOperationsInput | string
  }

  export type ProductThumbnailUncheckedUpdateWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    increment?: IntFieldUpdateOperationsInput | number
    image_url?: StringFieldUpdateOperationsInput | string
  }

  export type ProductThumbnailUncheckedUpdateManyWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    increment?: IntFieldUpdateOperationsInput | number
    image_url?: StringFieldUpdateOperationsInput | string
  }

  export type ProductCategoryUpdateWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    Category?: CategoryUpdateOneRequiredWithoutProductCategoriesNestedInput
  }

  export type ProductCategoryUncheckedUpdateWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    category_id?: StringFieldUpdateOperationsInput | string
  }

  export type ProductCategoryUncheckedUpdateManyWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    category_id?: StringFieldUpdateOperationsInput | string
  }

  export type ProductVariationUpdateWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ProductOrders?: ProductOrderUpdateManyWithoutProductVariationNestedInput
  }

  export type ProductVariationUncheckedUpdateWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    increment?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    ProductOrders?: ProductOrderUncheckedUpdateManyWithoutProductVariationNestedInput
  }

  export type ProductVariationUncheckedUpdateManyWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    increment?: IntFieldUpdateOperationsInput | number
    name?: StringFieldUpdateOperationsInput | string
    price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProductIncludeUpdateWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
  }

  export type ProductIncludeUncheckedUpdateWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    increment?: IntFieldUpdateOperationsInput | number
    description?: StringFieldUpdateOperationsInput | string
  }

  export type ProductIncludeUncheckedUpdateManyWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    increment?: IntFieldUpdateOperationsInput | number
    description?: StringFieldUpdateOperationsInput | string
  }

  export type ProductExcludeUpdateWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    description?: StringFieldUpdateOperationsInput | string
  }

  export type ProductExcludeUncheckedUpdateWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    increment?: IntFieldUpdateOperationsInput | number
    description?: StringFieldUpdateOperationsInput | string
  }

  export type ProductExcludeUncheckedUpdateManyWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    increment?: IntFieldUpdateOperationsInput | number
    description?: StringFieldUpdateOperationsInput | string
  }

  export type ProductOrderUpdateWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    departure?: DateTimeFieldUpdateOperationsInput | Date | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    User?: UserUpdateOneRequiredWithoutProductOrdersNestedInput
    ProductVariation?: ProductVariationUpdateOneWithoutProductOrdersNestedInput
  }

  export type ProductOrderUncheckedUpdateWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    variation_id?: NullableStringFieldUpdateOperationsInput | string | null
    departure?: DateTimeFieldUpdateOperationsInput | Date | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProductOrderUncheckedUpdateManyWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    variation_id?: NullableStringFieldUpdateOperationsInput | string | null
    departure?: DateTimeFieldUpdateOperationsInput | Date | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProductOrderCreateManyProductVariationInput = {
    id?: string
    user_id: string
    product_id: string
    departure: Date | string
    number_of_pax: number
    per_pax_price: Decimal | DecimalJsLike | number | string
    total_price: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type ProductOrderUpdateWithoutProductVariationInput = {
    id?: StringFieldUpdateOperationsInput | string
    departure?: DateTimeFieldUpdateOperationsInput | Date | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    User?: UserUpdateOneRequiredWithoutProductOrdersNestedInput
    Product?: ProductUpdateOneRequiredWithoutProductOrdersNestedInput
  }

  export type ProductOrderUncheckedUpdateWithoutProductVariationInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    product_id?: StringFieldUpdateOperationsInput | string
    departure?: DateTimeFieldUpdateOperationsInput | Date | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProductOrderUncheckedUpdateManyWithoutProductVariationInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    product_id?: StringFieldUpdateOperationsInput | string
    departure?: DateTimeFieldUpdateOperationsInput | Date | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    per_pax_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    total_price?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type HotelCreateManyVendorInput = {
    id?: string
    name: string
    city: $Enums.City
    order_number: number
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MitraPackageCreateManyVendorInput = {
    id?: string
    period_id?: string | null
    airline_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    visa_id?: string | null
    transportation_id?: string | null
    muthawif_id?: string | null
    handling_saudi_id?: string | null
    handling_domestic_id?: string | null
    siskopatuh_id?: string | null
    equipment_id?: string | null
    tour_plus_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type HotelUpdateWithoutVendorInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    city?: EnumCityFieldUpdateOperationsInput | $Enums.City
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    HotelPeriodPrices?: HotelPeriodPriceUpdateManyWithoutHotelNestedInput
    MitraPackagesMekkah?: MitraPackageUpdateManyWithoutHotelMekkahNestedInput
    MitraPackagesMadinah?: MitraPackageUpdateManyWithoutHotelMadinahNestedInput
  }

  export type HotelUncheckedUpdateWithoutVendorInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    city?: EnumCityFieldUpdateOperationsInput | $Enums.City
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    HotelPeriodPrices?: HotelPeriodPriceUncheckedUpdateManyWithoutHotelNestedInput
    MitraPackagesMekkah?: MitraPackageUncheckedUpdateManyWithoutHotelMekkahNestedInput
    MitraPackagesMadinah?: MitraPackageUncheckedUpdateManyWithoutHotelMadinahNestedInput
  }

  export type HotelUncheckedUpdateManyWithoutVendorInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    city?: EnumCityFieldUpdateOperationsInput | $Enums.City
    order_number?: IntFieldUpdateOperationsInput | number
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraPackageUpdateWithoutVendorInput = {
    id?: StringFieldUpdateOperationsInput | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUpdateManyWithoutMitraPackageNestedInput
    period?: PeriodUpdateOneWithoutMitraPackagesNestedInput
    airline?: AirlineUpdateOneWithoutMitraPackagesNestedInput
    hotelMekkah?: HotelUpdateOneWithoutMitraPackagesMekkahNestedInput
    hotelMadinah?: HotelUpdateOneWithoutMitraPackagesMadinahNestedInput
    visa?: VisaUpdateOneWithoutMitraPackagesNestedInput
    transportation?: TransportationUpdateOneWithoutMitraPackageNestedInput
    muthawif?: MuthawifUpdateOneWithoutMitraPackagesNestedInput
    handlingSaudi?: HandlingSaudiUpdateOneWithoutMitraPackagesNestedInput
    handlingDomestic?: HandlingDomesticUpdateOneWithoutMitraPackagesNestedInput
    siskopatuh?: SiskopatuhUpdateOneWithoutMitraPackagesNestedInput
    equipment?: EquipmentUpdateOneWithoutMitraPackagesNestedInput
    tourPlus?: TourPlusUpdateOneWithoutMitraPackagesNestedInput
    manasik?: ManasikUpdateOneWithoutMitraPackagesNestedInput
  }

  export type MitraPackageUncheckedUpdateWithoutVendorInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedUpdateManyWithoutMitraPackageNestedInput
  }

  export type MitraPackageUncheckedUpdateManyWithoutVendorInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type HotelPeriodPriceCreateManyHotelInput = {
    id?: string
    period_id: string
    price_double: Decimal | DecimalJsLike | number | string
    price_triple: Decimal | DecimalJsLike | number | string
    price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MitraPackageCreateManyHotelMekkahInput = {
    id?: string
    period_id?: string | null
    airline_id?: string | null
    vendor_id?: string | null
    hotel_madinah_id?: string | null
    visa_id?: string | null
    transportation_id?: string | null
    muthawif_id?: string | null
    handling_saudi_id?: string | null
    handling_domestic_id?: string | null
    siskopatuh_id?: string | null
    equipment_id?: string | null
    tour_plus_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MitraPackageCreateManyHotelMadinahInput = {
    id?: string
    period_id?: string | null
    airline_id?: string | null
    vendor_id?: string | null
    hotel_mekkah_id?: string | null
    visa_id?: string | null
    transportation_id?: string | null
    muthawif_id?: string | null
    handling_saudi_id?: string | null
    handling_domestic_id?: string | null
    siskopatuh_id?: string | null
    equipment_id?: string | null
    tour_plus_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type HotelPeriodPriceUpdateWithoutHotelInput = {
    id?: StringFieldUpdateOperationsInput | string
    price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    Period?: PeriodUpdateOneRequiredWithoutHotelPeriodPricesNestedInput
  }

  export type HotelPeriodPriceUncheckedUpdateWithoutHotelInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: StringFieldUpdateOperationsInput | string
    price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type HotelPeriodPriceUncheckedUpdateManyWithoutHotelInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: StringFieldUpdateOperationsInput | string
    price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraPackageUpdateWithoutHotelMekkahInput = {
    id?: StringFieldUpdateOperationsInput | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUpdateManyWithoutMitraPackageNestedInput
    period?: PeriodUpdateOneWithoutMitraPackagesNestedInput
    airline?: AirlineUpdateOneWithoutMitraPackagesNestedInput
    vendor?: VendorUpdateOneWithoutMitraPackagesNestedInput
    hotelMadinah?: HotelUpdateOneWithoutMitraPackagesMadinahNestedInput
    visa?: VisaUpdateOneWithoutMitraPackagesNestedInput
    transportation?: TransportationUpdateOneWithoutMitraPackageNestedInput
    muthawif?: MuthawifUpdateOneWithoutMitraPackagesNestedInput
    handlingSaudi?: HandlingSaudiUpdateOneWithoutMitraPackagesNestedInput
    handlingDomestic?: HandlingDomesticUpdateOneWithoutMitraPackagesNestedInput
    siskopatuh?: SiskopatuhUpdateOneWithoutMitraPackagesNestedInput
    equipment?: EquipmentUpdateOneWithoutMitraPackagesNestedInput
    tourPlus?: TourPlusUpdateOneWithoutMitraPackagesNestedInput
    manasik?: ManasikUpdateOneWithoutMitraPackagesNestedInput
  }

  export type MitraPackageUncheckedUpdateWithoutHotelMekkahInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedUpdateManyWithoutMitraPackageNestedInput
  }

  export type MitraPackageUncheckedUpdateManyWithoutHotelMekkahInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraPackageUpdateWithoutHotelMadinahInput = {
    id?: StringFieldUpdateOperationsInput | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUpdateManyWithoutMitraPackageNestedInput
    period?: PeriodUpdateOneWithoutMitraPackagesNestedInput
    airline?: AirlineUpdateOneWithoutMitraPackagesNestedInput
    vendor?: VendorUpdateOneWithoutMitraPackagesNestedInput
    hotelMekkah?: HotelUpdateOneWithoutMitraPackagesMekkahNestedInput
    visa?: VisaUpdateOneWithoutMitraPackagesNestedInput
    transportation?: TransportationUpdateOneWithoutMitraPackageNestedInput
    muthawif?: MuthawifUpdateOneWithoutMitraPackagesNestedInput
    handlingSaudi?: HandlingSaudiUpdateOneWithoutMitraPackagesNestedInput
    handlingDomestic?: HandlingDomesticUpdateOneWithoutMitraPackagesNestedInput
    siskopatuh?: SiskopatuhUpdateOneWithoutMitraPackagesNestedInput
    equipment?: EquipmentUpdateOneWithoutMitraPackagesNestedInput
    tourPlus?: TourPlusUpdateOneWithoutMitraPackagesNestedInput
    manasik?: ManasikUpdateOneWithoutMitraPackagesNestedInput
  }

  export type MitraPackageUncheckedUpdateWithoutHotelMadinahInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedUpdateManyWithoutMitraPackageNestedInput
  }

  export type MitraPackageUncheckedUpdateManyWithoutHotelMadinahInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type HotelPeriodPriceCreateManyPeriodInput = {
    id?: string
    hotel_id: string
    price_double: Decimal | DecimalJsLike | number | string
    price_triple: Decimal | DecimalJsLike | number | string
    price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MitraPackageCreateManyPeriodInput = {
    id?: string
    airline_id?: string | null
    vendor_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    visa_id?: string | null
    transportation_id?: string | null
    muthawif_id?: string | null
    handling_saudi_id?: string | null
    handling_domestic_id?: string | null
    siskopatuh_id?: string | null
    equipment_id?: string | null
    tour_plus_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type HotelPeriodPriceUpdateWithoutPeriodInput = {
    id?: StringFieldUpdateOperationsInput | string
    price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    Hotel?: HotelUpdateOneRequiredWithoutHotelPeriodPricesNestedInput
  }

  export type HotelPeriodPriceUncheckedUpdateWithoutPeriodInput = {
    id?: StringFieldUpdateOperationsInput | string
    hotel_id?: StringFieldUpdateOperationsInput | string
    price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type HotelPeriodPriceUncheckedUpdateManyWithoutPeriodInput = {
    id?: StringFieldUpdateOperationsInput | string
    hotel_id?: StringFieldUpdateOperationsInput | string
    price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraPackageUpdateWithoutPeriodInput = {
    id?: StringFieldUpdateOperationsInput | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUpdateManyWithoutMitraPackageNestedInput
    airline?: AirlineUpdateOneWithoutMitraPackagesNestedInput
    vendor?: VendorUpdateOneWithoutMitraPackagesNestedInput
    hotelMekkah?: HotelUpdateOneWithoutMitraPackagesMekkahNestedInput
    hotelMadinah?: HotelUpdateOneWithoutMitraPackagesMadinahNestedInput
    visa?: VisaUpdateOneWithoutMitraPackagesNestedInput
    transportation?: TransportationUpdateOneWithoutMitraPackageNestedInput
    muthawif?: MuthawifUpdateOneWithoutMitraPackagesNestedInput
    handlingSaudi?: HandlingSaudiUpdateOneWithoutMitraPackagesNestedInput
    handlingDomestic?: HandlingDomesticUpdateOneWithoutMitraPackagesNestedInput
    siskopatuh?: SiskopatuhUpdateOneWithoutMitraPackagesNestedInput
    equipment?: EquipmentUpdateOneWithoutMitraPackagesNestedInput
    tourPlus?: TourPlusUpdateOneWithoutMitraPackagesNestedInput
    manasik?: ManasikUpdateOneWithoutMitraPackagesNestedInput
  }

  export type MitraPackageUncheckedUpdateWithoutPeriodInput = {
    id?: StringFieldUpdateOperationsInput | string
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedUpdateManyWithoutMitraPackageNestedInput
  }

  export type MitraPackageUncheckedUpdateManyWithoutPeriodInput = {
    id?: StringFieldUpdateOperationsInput | string
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraPackageCreateManyAirlineInput = {
    id?: string
    period_id?: string | null
    vendor_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    visa_id?: string | null
    transportation_id?: string | null
    muthawif_id?: string | null
    handling_saudi_id?: string | null
    handling_domestic_id?: string | null
    siskopatuh_id?: string | null
    equipment_id?: string | null
    tour_plus_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MitraPackageUpdateWithoutAirlineInput = {
    id?: StringFieldUpdateOperationsInput | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUpdateManyWithoutMitraPackageNestedInput
    period?: PeriodUpdateOneWithoutMitraPackagesNestedInput
    vendor?: VendorUpdateOneWithoutMitraPackagesNestedInput
    hotelMekkah?: HotelUpdateOneWithoutMitraPackagesMekkahNestedInput
    hotelMadinah?: HotelUpdateOneWithoutMitraPackagesMadinahNestedInput
    visa?: VisaUpdateOneWithoutMitraPackagesNestedInput
    transportation?: TransportationUpdateOneWithoutMitraPackageNestedInput
    muthawif?: MuthawifUpdateOneWithoutMitraPackagesNestedInput
    handlingSaudi?: HandlingSaudiUpdateOneWithoutMitraPackagesNestedInput
    handlingDomestic?: HandlingDomesticUpdateOneWithoutMitraPackagesNestedInput
    siskopatuh?: SiskopatuhUpdateOneWithoutMitraPackagesNestedInput
    equipment?: EquipmentUpdateOneWithoutMitraPackagesNestedInput
    tourPlus?: TourPlusUpdateOneWithoutMitraPackagesNestedInput
    manasik?: ManasikUpdateOneWithoutMitraPackagesNestedInput
  }

  export type MitraPackageUncheckedUpdateWithoutAirlineInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedUpdateManyWithoutMitraPackageNestedInput
  }

  export type MitraPackageUncheckedUpdateManyWithoutAirlineInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraPackageCreateManyVisaInput = {
    id?: string
    period_id?: string | null
    airline_id?: string | null
    vendor_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    transportation_id?: string | null
    muthawif_id?: string | null
    handling_saudi_id?: string | null
    handling_domestic_id?: string | null
    siskopatuh_id?: string | null
    equipment_id?: string | null
    tour_plus_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MitraPackageUpdateWithoutVisaInput = {
    id?: StringFieldUpdateOperationsInput | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUpdateManyWithoutMitraPackageNestedInput
    period?: PeriodUpdateOneWithoutMitraPackagesNestedInput
    airline?: AirlineUpdateOneWithoutMitraPackagesNestedInput
    vendor?: VendorUpdateOneWithoutMitraPackagesNestedInput
    hotelMekkah?: HotelUpdateOneWithoutMitraPackagesMekkahNestedInput
    hotelMadinah?: HotelUpdateOneWithoutMitraPackagesMadinahNestedInput
    transportation?: TransportationUpdateOneWithoutMitraPackageNestedInput
    muthawif?: MuthawifUpdateOneWithoutMitraPackagesNestedInput
    handlingSaudi?: HandlingSaudiUpdateOneWithoutMitraPackagesNestedInput
    handlingDomestic?: HandlingDomesticUpdateOneWithoutMitraPackagesNestedInput
    siskopatuh?: SiskopatuhUpdateOneWithoutMitraPackagesNestedInput
    equipment?: EquipmentUpdateOneWithoutMitraPackagesNestedInput
    tourPlus?: TourPlusUpdateOneWithoutMitraPackagesNestedInput
    manasik?: ManasikUpdateOneWithoutMitraPackagesNestedInput
  }

  export type MitraPackageUncheckedUpdateWithoutVisaInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedUpdateManyWithoutMitraPackageNestedInput
  }

  export type MitraPackageUncheckedUpdateManyWithoutVisaInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraPackageCreateManyTransportationInput = {
    id?: string
    period_id?: string | null
    airline_id?: string | null
    vendor_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    visa_id?: string | null
    muthawif_id?: string | null
    handling_saudi_id?: string | null
    handling_domestic_id?: string | null
    siskopatuh_id?: string | null
    equipment_id?: string | null
    tour_plus_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MitraPackageUpdateWithoutTransportationInput = {
    id?: StringFieldUpdateOperationsInput | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUpdateManyWithoutMitraPackageNestedInput
    period?: PeriodUpdateOneWithoutMitraPackagesNestedInput
    airline?: AirlineUpdateOneWithoutMitraPackagesNestedInput
    vendor?: VendorUpdateOneWithoutMitraPackagesNestedInput
    hotelMekkah?: HotelUpdateOneWithoutMitraPackagesMekkahNestedInput
    hotelMadinah?: HotelUpdateOneWithoutMitraPackagesMadinahNestedInput
    visa?: VisaUpdateOneWithoutMitraPackagesNestedInput
    muthawif?: MuthawifUpdateOneWithoutMitraPackagesNestedInput
    handlingSaudi?: HandlingSaudiUpdateOneWithoutMitraPackagesNestedInput
    handlingDomestic?: HandlingDomesticUpdateOneWithoutMitraPackagesNestedInput
    siskopatuh?: SiskopatuhUpdateOneWithoutMitraPackagesNestedInput
    equipment?: EquipmentUpdateOneWithoutMitraPackagesNestedInput
    tourPlus?: TourPlusUpdateOneWithoutMitraPackagesNestedInput
    manasik?: ManasikUpdateOneWithoutMitraPackagesNestedInput
  }

  export type MitraPackageUncheckedUpdateWithoutTransportationInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedUpdateManyWithoutMitraPackageNestedInput
  }

  export type MitraPackageUncheckedUpdateManyWithoutTransportationInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraPackageCreateManyMuthawifInput = {
    id?: string
    period_id?: string | null
    airline_id?: string | null
    vendor_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    visa_id?: string | null
    transportation_id?: string | null
    handling_saudi_id?: string | null
    handling_domestic_id?: string | null
    siskopatuh_id?: string | null
    equipment_id?: string | null
    tour_plus_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MitraPackageUpdateWithoutMuthawifInput = {
    id?: StringFieldUpdateOperationsInput | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUpdateManyWithoutMitraPackageNestedInput
    period?: PeriodUpdateOneWithoutMitraPackagesNestedInput
    airline?: AirlineUpdateOneWithoutMitraPackagesNestedInput
    vendor?: VendorUpdateOneWithoutMitraPackagesNestedInput
    hotelMekkah?: HotelUpdateOneWithoutMitraPackagesMekkahNestedInput
    hotelMadinah?: HotelUpdateOneWithoutMitraPackagesMadinahNestedInput
    visa?: VisaUpdateOneWithoutMitraPackagesNestedInput
    transportation?: TransportationUpdateOneWithoutMitraPackageNestedInput
    handlingSaudi?: HandlingSaudiUpdateOneWithoutMitraPackagesNestedInput
    handlingDomestic?: HandlingDomesticUpdateOneWithoutMitraPackagesNestedInput
    siskopatuh?: SiskopatuhUpdateOneWithoutMitraPackagesNestedInput
    equipment?: EquipmentUpdateOneWithoutMitraPackagesNestedInput
    tourPlus?: TourPlusUpdateOneWithoutMitraPackagesNestedInput
    manasik?: ManasikUpdateOneWithoutMitraPackagesNestedInput
  }

  export type MitraPackageUncheckedUpdateWithoutMuthawifInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedUpdateManyWithoutMitraPackageNestedInput
  }

  export type MitraPackageUncheckedUpdateManyWithoutMuthawifInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraPackageCreateManyHandlingSaudiInput = {
    id?: string
    period_id?: string | null
    airline_id?: string | null
    vendor_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    visa_id?: string | null
    transportation_id?: string | null
    muthawif_id?: string | null
    handling_domestic_id?: string | null
    siskopatuh_id?: string | null
    equipment_id?: string | null
    tour_plus_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MitraPackageUpdateWithoutHandlingSaudiInput = {
    id?: StringFieldUpdateOperationsInput | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUpdateManyWithoutMitraPackageNestedInput
    period?: PeriodUpdateOneWithoutMitraPackagesNestedInput
    airline?: AirlineUpdateOneWithoutMitraPackagesNestedInput
    vendor?: VendorUpdateOneWithoutMitraPackagesNestedInput
    hotelMekkah?: HotelUpdateOneWithoutMitraPackagesMekkahNestedInput
    hotelMadinah?: HotelUpdateOneWithoutMitraPackagesMadinahNestedInput
    visa?: VisaUpdateOneWithoutMitraPackagesNestedInput
    transportation?: TransportationUpdateOneWithoutMitraPackageNestedInput
    muthawif?: MuthawifUpdateOneWithoutMitraPackagesNestedInput
    handlingDomestic?: HandlingDomesticUpdateOneWithoutMitraPackagesNestedInput
    siskopatuh?: SiskopatuhUpdateOneWithoutMitraPackagesNestedInput
    equipment?: EquipmentUpdateOneWithoutMitraPackagesNestedInput
    tourPlus?: TourPlusUpdateOneWithoutMitraPackagesNestedInput
    manasik?: ManasikUpdateOneWithoutMitraPackagesNestedInput
  }

  export type MitraPackageUncheckedUpdateWithoutHandlingSaudiInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedUpdateManyWithoutMitraPackageNestedInput
  }

  export type MitraPackageUncheckedUpdateManyWithoutHandlingSaudiInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraPackageCreateManyHandlingDomesticInput = {
    id?: string
    period_id?: string | null
    airline_id?: string | null
    vendor_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    visa_id?: string | null
    transportation_id?: string | null
    muthawif_id?: string | null
    handling_saudi_id?: string | null
    siskopatuh_id?: string | null
    equipment_id?: string | null
    tour_plus_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MitraPackageUpdateWithoutHandlingDomesticInput = {
    id?: StringFieldUpdateOperationsInput | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUpdateManyWithoutMitraPackageNestedInput
    period?: PeriodUpdateOneWithoutMitraPackagesNestedInput
    airline?: AirlineUpdateOneWithoutMitraPackagesNestedInput
    vendor?: VendorUpdateOneWithoutMitraPackagesNestedInput
    hotelMekkah?: HotelUpdateOneWithoutMitraPackagesMekkahNestedInput
    hotelMadinah?: HotelUpdateOneWithoutMitraPackagesMadinahNestedInput
    visa?: VisaUpdateOneWithoutMitraPackagesNestedInput
    transportation?: TransportationUpdateOneWithoutMitraPackageNestedInput
    muthawif?: MuthawifUpdateOneWithoutMitraPackagesNestedInput
    handlingSaudi?: HandlingSaudiUpdateOneWithoutMitraPackagesNestedInput
    siskopatuh?: SiskopatuhUpdateOneWithoutMitraPackagesNestedInput
    equipment?: EquipmentUpdateOneWithoutMitraPackagesNestedInput
    tourPlus?: TourPlusUpdateOneWithoutMitraPackagesNestedInput
    manasik?: ManasikUpdateOneWithoutMitraPackagesNestedInput
  }

  export type MitraPackageUncheckedUpdateWithoutHandlingDomesticInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedUpdateManyWithoutMitraPackageNestedInput
  }

  export type MitraPackageUncheckedUpdateManyWithoutHandlingDomesticInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraPackageCreateManySiskopatuhInput = {
    id?: string
    period_id?: string | null
    airline_id?: string | null
    vendor_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    visa_id?: string | null
    transportation_id?: string | null
    muthawif_id?: string | null
    handling_saudi_id?: string | null
    handling_domestic_id?: string | null
    equipment_id?: string | null
    tour_plus_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MitraPackageUpdateWithoutSiskopatuhInput = {
    id?: StringFieldUpdateOperationsInput | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUpdateManyWithoutMitraPackageNestedInput
    period?: PeriodUpdateOneWithoutMitraPackagesNestedInput
    airline?: AirlineUpdateOneWithoutMitraPackagesNestedInput
    vendor?: VendorUpdateOneWithoutMitraPackagesNestedInput
    hotelMekkah?: HotelUpdateOneWithoutMitraPackagesMekkahNestedInput
    hotelMadinah?: HotelUpdateOneWithoutMitraPackagesMadinahNestedInput
    visa?: VisaUpdateOneWithoutMitraPackagesNestedInput
    transportation?: TransportationUpdateOneWithoutMitraPackageNestedInput
    muthawif?: MuthawifUpdateOneWithoutMitraPackagesNestedInput
    handlingSaudi?: HandlingSaudiUpdateOneWithoutMitraPackagesNestedInput
    handlingDomestic?: HandlingDomesticUpdateOneWithoutMitraPackagesNestedInput
    equipment?: EquipmentUpdateOneWithoutMitraPackagesNestedInput
    tourPlus?: TourPlusUpdateOneWithoutMitraPackagesNestedInput
    manasik?: ManasikUpdateOneWithoutMitraPackagesNestedInput
  }

  export type MitraPackageUncheckedUpdateWithoutSiskopatuhInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedUpdateManyWithoutMitraPackageNestedInput
  }

  export type MitraPackageUncheckedUpdateManyWithoutSiskopatuhInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraPackageCreateManyEquipmentInput = {
    id?: string
    period_id?: string | null
    airline_id?: string | null
    vendor_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    visa_id?: string | null
    transportation_id?: string | null
    muthawif_id?: string | null
    handling_saudi_id?: string | null
    handling_domestic_id?: string | null
    siskopatuh_id?: string | null
    tour_plus_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MitraPackageUpdateWithoutEquipmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUpdateManyWithoutMitraPackageNestedInput
    period?: PeriodUpdateOneWithoutMitraPackagesNestedInput
    airline?: AirlineUpdateOneWithoutMitraPackagesNestedInput
    vendor?: VendorUpdateOneWithoutMitraPackagesNestedInput
    hotelMekkah?: HotelUpdateOneWithoutMitraPackagesMekkahNestedInput
    hotelMadinah?: HotelUpdateOneWithoutMitraPackagesMadinahNestedInput
    visa?: VisaUpdateOneWithoutMitraPackagesNestedInput
    transportation?: TransportationUpdateOneWithoutMitraPackageNestedInput
    muthawif?: MuthawifUpdateOneWithoutMitraPackagesNestedInput
    handlingSaudi?: HandlingSaudiUpdateOneWithoutMitraPackagesNestedInput
    handlingDomestic?: HandlingDomesticUpdateOneWithoutMitraPackagesNestedInput
    siskopatuh?: SiskopatuhUpdateOneWithoutMitraPackagesNestedInput
    tourPlus?: TourPlusUpdateOneWithoutMitraPackagesNestedInput
    manasik?: ManasikUpdateOneWithoutMitraPackagesNestedInput
  }

  export type MitraPackageUncheckedUpdateWithoutEquipmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedUpdateManyWithoutMitraPackageNestedInput
  }

  export type MitraPackageUncheckedUpdateManyWithoutEquipmentInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraPackageCreateManyTourPlusInput = {
    id?: string
    period_id?: string | null
    airline_id?: string | null
    vendor_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    visa_id?: string | null
    transportation_id?: string | null
    muthawif_id?: string | null
    handling_saudi_id?: string | null
    handling_domestic_id?: string | null
    siskopatuh_id?: string | null
    equipment_id?: string | null
    manasik_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MitraPackageUpdateWithoutTourPlusInput = {
    id?: StringFieldUpdateOperationsInput | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUpdateManyWithoutMitraPackageNestedInput
    period?: PeriodUpdateOneWithoutMitraPackagesNestedInput
    airline?: AirlineUpdateOneWithoutMitraPackagesNestedInput
    vendor?: VendorUpdateOneWithoutMitraPackagesNestedInput
    hotelMekkah?: HotelUpdateOneWithoutMitraPackagesMekkahNestedInput
    hotelMadinah?: HotelUpdateOneWithoutMitraPackagesMadinahNestedInput
    visa?: VisaUpdateOneWithoutMitraPackagesNestedInput
    transportation?: TransportationUpdateOneWithoutMitraPackageNestedInput
    muthawif?: MuthawifUpdateOneWithoutMitraPackagesNestedInput
    handlingSaudi?: HandlingSaudiUpdateOneWithoutMitraPackagesNestedInput
    handlingDomestic?: HandlingDomesticUpdateOneWithoutMitraPackagesNestedInput
    siskopatuh?: SiskopatuhUpdateOneWithoutMitraPackagesNestedInput
    equipment?: EquipmentUpdateOneWithoutMitraPackagesNestedInput
    manasik?: ManasikUpdateOneWithoutMitraPackagesNestedInput
  }

  export type MitraPackageUncheckedUpdateWithoutTourPlusInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedUpdateManyWithoutMitraPackageNestedInput
  }

  export type MitraPackageUncheckedUpdateManyWithoutTourPlusInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    manasik_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraPackageCreateManyManasikInput = {
    id?: string
    period_id?: string | null
    airline_id?: string | null
    vendor_id?: string | null
    hotel_mekkah_id?: string | null
    hotel_madinah_id?: string | null
    visa_id?: string | null
    transportation_id?: string | null
    muthawif_id?: string | null
    handling_saudi_id?: string | null
    handling_domestic_id?: string | null
    siskopatuh_id?: string | null
    equipment_id?: string | null
    tour_plus_id?: string | null
    number_of_pax: number
    departure_date: Date | string
    travel_duration: number
    mekkah_duration: number
    madinah_duration: number
    tour_leader: number
    margin: Decimal | DecimalJsLike | number | string
    per_pax_price_double: Decimal | DecimalJsLike | number | string
    per_pax_price_triple: Decimal | DecimalJsLike | number | string
    per_pax_price_quad: Decimal | DecimalJsLike | number | string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MitraPackageUpdateWithoutManasikInput = {
    id?: StringFieldUpdateOperationsInput | string
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUpdateManyWithoutMitraPackageNestedInput
    period?: PeriodUpdateOneWithoutMitraPackagesNestedInput
    airline?: AirlineUpdateOneWithoutMitraPackagesNestedInput
    vendor?: VendorUpdateOneWithoutMitraPackagesNestedInput
    hotelMekkah?: HotelUpdateOneWithoutMitraPackagesMekkahNestedInput
    hotelMadinah?: HotelUpdateOneWithoutMitraPackagesMadinahNestedInput
    visa?: VisaUpdateOneWithoutMitraPackagesNestedInput
    transportation?: TransportationUpdateOneWithoutMitraPackageNestedInput
    muthawif?: MuthawifUpdateOneWithoutMitraPackagesNestedInput
    handlingSaudi?: HandlingSaudiUpdateOneWithoutMitraPackagesNestedInput
    handlingDomestic?: HandlingDomesticUpdateOneWithoutMitraPackagesNestedInput
    siskopatuh?: SiskopatuhUpdateOneWithoutMitraPackagesNestedInput
    equipment?: EquipmentUpdateOneWithoutMitraPackagesNestedInput
    tourPlus?: TourPlusUpdateOneWithoutMitraPackagesNestedInput
  }

  export type MitraPackageUncheckedUpdateWithoutManasikInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    MitraPackageOrders?: MitraPackageOrderUncheckedUpdateManyWithoutMitraPackageNestedInput
  }

  export type MitraPackageUncheckedUpdateManyWithoutManasikInput = {
    id?: StringFieldUpdateOperationsInput | string
    period_id?: NullableStringFieldUpdateOperationsInput | string | null
    airline_id?: NullableStringFieldUpdateOperationsInput | string | null
    vendor_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_mekkah_id?: NullableStringFieldUpdateOperationsInput | string | null
    hotel_madinah_id?: NullableStringFieldUpdateOperationsInput | string | null
    visa_id?: NullableStringFieldUpdateOperationsInput | string | null
    transportation_id?: NullableStringFieldUpdateOperationsInput | string | null
    muthawif_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_saudi_id?: NullableStringFieldUpdateOperationsInput | string | null
    handling_domestic_id?: NullableStringFieldUpdateOperationsInput | string | null
    siskopatuh_id?: NullableStringFieldUpdateOperationsInput | string | null
    equipment_id?: NullableStringFieldUpdateOperationsInput | string | null
    tour_plus_id?: NullableStringFieldUpdateOperationsInput | string | null
    number_of_pax?: IntFieldUpdateOperationsInput | number
    departure_date?: DateTimeFieldUpdateOperationsInput | Date | string
    travel_duration?: IntFieldUpdateOperationsInput | number
    mekkah_duration?: IntFieldUpdateOperationsInput | number
    madinah_duration?: IntFieldUpdateOperationsInput | number
    tour_leader?: IntFieldUpdateOperationsInput | number
    margin?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_double?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_triple?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    per_pax_price_quad?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraPackageOrderCreateManyMitraPackageInput = {
    id?: string
    user_id: string
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type MitraPackageOrderUpdateWithoutMitraPackageInput = {
    id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
    User?: UserUpdateOneRequiredWithoutMitraPackageOrderNestedInput
  }

  export type MitraPackageOrderUncheckedUpdateWithoutMitraPackageInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type MitraPackageOrderUncheckedUpdateManyWithoutMitraPackageInput = {
    id?: StringFieldUpdateOperationsInput | string
    user_id?: StringFieldUpdateOperationsInput | string
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FooterItemCreateManyFooterInput = {
    id?: string
    name: string
    url: string
    visible?: boolean
    created_at?: Date | string
    updated_at?: Date | string
  }

  export type FooterItemUpdateWithoutFooterInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    visible?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FooterItemUncheckedUpdateWithoutFooterInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    visible?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type FooterItemUncheckedUpdateManyWithoutFooterInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    visible?: BoolFieldUpdateOperationsInput | boolean
    created_at?: DateTimeFieldUpdateOperationsInput | Date | string
    updated_at?: DateTimeFieldUpdateOperationsInput | Date | string
  }



  /**
   * Aliases for legacy arg types
   */
    /**
     * @deprecated Use UserCountOutputTypeDefaultArgs instead
     */
    export type UserCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UserCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use UserPackageCountOutputTypeDefaultArgs instead
     */
    export type UserPackageCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UserPackageCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use PackageTypeCountOutputTypeDefaultArgs instead
     */
    export type PackageTypeCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = PackageTypeCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use UserPackageOptionCountOutputTypeDefaultArgs instead
     */
    export type UserPackageOptionCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UserPackageOptionCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CategoryCountOutputTypeDefaultArgs instead
     */
    export type CategoryCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CategoryCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ProductCountOutputTypeDefaultArgs instead
     */
    export type ProductCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ProductCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ProductVariationCountOutputTypeDefaultArgs instead
     */
    export type ProductVariationCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ProductVariationCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use VendorCountOutputTypeDefaultArgs instead
     */
    export type VendorCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = VendorCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use HotelCountOutputTypeDefaultArgs instead
     */
    export type HotelCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = HotelCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use PeriodCountOutputTypeDefaultArgs instead
     */
    export type PeriodCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = PeriodCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use AirlineCountOutputTypeDefaultArgs instead
     */
    export type AirlineCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = AirlineCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use VisaCountOutputTypeDefaultArgs instead
     */
    export type VisaCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = VisaCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use TransportationCountOutputTypeDefaultArgs instead
     */
    export type TransportationCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = TransportationCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use MuthawifCountOutputTypeDefaultArgs instead
     */
    export type MuthawifCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = MuthawifCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use HandlingSaudiCountOutputTypeDefaultArgs instead
     */
    export type HandlingSaudiCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = HandlingSaudiCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use HandlingDomesticCountOutputTypeDefaultArgs instead
     */
    export type HandlingDomesticCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = HandlingDomesticCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use SiskopatuhCountOutputTypeDefaultArgs instead
     */
    export type SiskopatuhCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = SiskopatuhCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use EquipmentCountOutputTypeDefaultArgs instead
     */
    export type EquipmentCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = EquipmentCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use TourPlusCountOutputTypeDefaultArgs instead
     */
    export type TourPlusCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = TourPlusCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ManasikCountOutputTypeDefaultArgs instead
     */
    export type ManasikCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ManasikCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use MitraPackageCountOutputTypeDefaultArgs instead
     */
    export type MitraPackageCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = MitraPackageCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use FooterCountOutputTypeDefaultArgs instead
     */
    export type FooterCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = FooterCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use UserDefaultArgs instead
     */
    export type UserArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UserDefaultArgs<ExtArgs>
    /**
     * @deprecated Use MitraRequestDefaultArgs instead
     */
    export type MitraRequestArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = MitraRequestDefaultArgs<ExtArgs>
    /**
     * @deprecated Use UserPackageDefaultArgs instead
     */
    export type UserPackageArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UserPackageDefaultArgs<ExtArgs>
    /**
     * @deprecated Use PackageTypeDefaultArgs instead
     */
    export type PackageTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = PackageTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use UserPackageOptionDefaultArgs instead
     */
    export type UserPackageOptionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UserPackageOptionDefaultArgs<ExtArgs>
    /**
     * @deprecated Use UserPackageOrderDefaultArgs instead
     */
    export type UserPackageOrderArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UserPackageOrderDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CategoryDefaultArgs instead
     */
    export type CategoryArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CategoryDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ProductDefaultArgs instead
     */
    export type ProductArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ProductDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ProductThumbnailDefaultArgs instead
     */
    export type ProductThumbnailArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ProductThumbnailDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ProductCategoryDefaultArgs instead
     */
    export type ProductCategoryArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ProductCategoryDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ProductVariationDefaultArgs instead
     */
    export type ProductVariationArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ProductVariationDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ProductIncludeDefaultArgs instead
     */
    export type ProductIncludeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ProductIncludeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ProductExcludeDefaultArgs instead
     */
    export type ProductExcludeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ProductExcludeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ProductOrderDefaultArgs instead
     */
    export type ProductOrderArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ProductOrderDefaultArgs<ExtArgs>
    /**
     * @deprecated Use VendorDefaultArgs instead
     */
    export type VendorArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = VendorDefaultArgs<ExtArgs>
    /**
     * @deprecated Use HotelDefaultArgs instead
     */
    export type HotelArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = HotelDefaultArgs<ExtArgs>
    /**
     * @deprecated Use PeriodDefaultArgs instead
     */
    export type PeriodArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = PeriodDefaultArgs<ExtArgs>
    /**
     * @deprecated Use HotelPeriodPriceDefaultArgs instead
     */
    export type HotelPeriodPriceArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = HotelPeriodPriceDefaultArgs<ExtArgs>
    /**
     * @deprecated Use AirlineDefaultArgs instead
     */
    export type AirlineArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = AirlineDefaultArgs<ExtArgs>
    /**
     * @deprecated Use VisaDefaultArgs instead
     */
    export type VisaArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = VisaDefaultArgs<ExtArgs>
    /**
     * @deprecated Use TransportationDefaultArgs instead
     */
    export type TransportationArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = TransportationDefaultArgs<ExtArgs>
    /**
     * @deprecated Use MuthawifDefaultArgs instead
     */
    export type MuthawifArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = MuthawifDefaultArgs<ExtArgs>
    /**
     * @deprecated Use HandlingSaudiDefaultArgs instead
     */
    export type HandlingSaudiArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = HandlingSaudiDefaultArgs<ExtArgs>
    /**
     * @deprecated Use HandlingDomesticDefaultArgs instead
     */
    export type HandlingDomesticArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = HandlingDomesticDefaultArgs<ExtArgs>
    /**
     * @deprecated Use SiskopatuhDefaultArgs instead
     */
    export type SiskopatuhArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = SiskopatuhDefaultArgs<ExtArgs>
    /**
     * @deprecated Use EquipmentDefaultArgs instead
     */
    export type EquipmentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = EquipmentDefaultArgs<ExtArgs>
    /**
     * @deprecated Use TourPlusDefaultArgs instead
     */
    export type TourPlusArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = TourPlusDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ManasikDefaultArgs instead
     */
    export type ManasikArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ManasikDefaultArgs<ExtArgs>
    /**
     * @deprecated Use MitraPackageDefaultArgs instead
     */
    export type MitraPackageArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = MitraPackageDefaultArgs<ExtArgs>
    /**
     * @deprecated Use MitraPackageOrderDefaultArgs instead
     */
    export type MitraPackageOrderArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = MitraPackageOrderDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ExchangeRateDefaultArgs instead
     */
    export type ExchangeRateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ExchangeRateDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ContactDefaultArgs instead
     */
    export type ContactArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ContactDefaultArgs<ExtArgs>
    /**
     * @deprecated Use FaqDefaultArgs instead
     */
    export type FaqArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = FaqDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ContentDefaultArgs instead
     */
    export type ContentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ContentDefaultArgs<ExtArgs>
    /**
     * @deprecated Use MenuItemDefaultArgs instead
     */
    export type MenuItemArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = MenuItemDefaultArgs<ExtArgs>
    /**
     * @deprecated Use FooterDefaultArgs instead
     */
    export type FooterArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = FooterDefaultArgs<ExtArgs>
    /**
     * @deprecated Use FooterItemDefaultArgs instead
     */
    export type FooterItemArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = FooterItemDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ColorDefaultArgs instead
     */
    export type ColorArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ColorDefaultArgs<ExtArgs>

  /**
   * Batch Payload for updateMany & deleteMany & createMany
   */

  export type BatchPayload = {
    count: number
  }

  /**
   * DMMF
   */
  export const dmmf: runtime.BaseDMMF
}