/**
 * 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 City
 * 
 */
export type City = $Result.DefaultSelection<Prisma.$CityPayload>
/**
 * Model AdminUser
 * 
 */
export type AdminUser = $Result.DefaultSelection<Prisma.$AdminUserPayload>
/**
 * Model AppSession
 * An issued APP token (customer app / sales-expert app), so it can be revoked
 * before it expires — the counterpart of AdminSession for the other token family.
 * 
 * WHY A SEPARATE TABLE AND NO FOREIGN KEY
 * ---------------------------------------
 * An app token's `sub` is a Customer id for a customer and an **AdminUser id**
 * for a sales expert (D21). One FK cannot point at two tables, so the subject is
 * stored as a plain id plus its type. The rows are short-lived operational data,
 * not part of the accounting model, so the missing FK costs nothing here.
 */
export type AppSession = $Result.DefaultSelection<Prisma.$AppSessionPayload>
/**
 * Model AdminSession
 * An issued admin-panel JWT, so it can be revoked before it expires.
 * 
 * WHY THIS EXISTS
 * ---------------
 * The admin token is self-contained and valid for 12h, which means nothing —
 * not disabling the account, not a central "sign out everywhere" — could cut a
 * session short: the token kept working until it expired. With the central IAM
 * in the loop that gap became visible (an IAM session revocation had no effect
 * here), so every issued token now carries a `jti` recorded on this table and
 * JwtStrategy refuses a token whose row is revoked.
 * 
 * Rows are written ONLY while tracking is enabled, and JwtStrategy only
 * enforces them while it is enabled, so a deployment that does not want the
 * extra lookup behaves exactly as before.
 */
export type AdminSession = $Result.DefaultSelection<Prisma.$AdminSessionPayload>
/**
 * Model SalesExpertProfile
 * The sales-expert fields legacy kept on the `customers` row (type=1) and that
 * were lost when a sales expert became an AdminUser (D17).
 * 
 * A separate table rather than columns on AdminUser: these are meaningful only
 * for role = SALES_EXPERT and would be permanently null for every other admin.
 * A row is created for every SALES_EXPERT by the migration, and upserted by the
 * service whenever one is created or a user's role becomes SALES_EXPERT — but
 * readers still left-join, so a missing profile degrades to nulls rather than
 * dropping the agent from the grid.
 * 
 * `reagent_id` is deliberately NOT here — see D17: in the reference it was a
 * side effect of the shared customers form, and filling it removed that expert
 * from the selectable-agent list (queryReagent, AdminController.php:420).
 */
export type SalesExpertProfile = $Result.DefaultSelection<Prisma.$SalesExpertProfilePayload>
/**
 * Model Customer
 * 
 */
export type Customer = $Result.DefaultSelection<Prisma.$CustomerPayload>
/**
 * Model CustomerAddress
 * 
 */
export type CustomerAddress = $Result.DefaultSelection<Prisma.$CustomerAddressPayload>
/**
 * Model Branch
 * 
 */
export type Branch = $Result.DefaultSelection<Prisma.$BranchPayload>
/**
 * Model Workshop
 * 
 */
export type Workshop = $Result.DefaultSelection<Prisma.$WorkshopPayload>
/**
 * Model Category
 * 
 */
export type Category = $Result.DefaultSelection<Prisma.$CategoryPayload>
/**
 * Model Brand
 * 
 */
export type Brand = $Result.DefaultSelection<Prisma.$BrandPayload>
/**
 * Model Collection
 * Curated product groupings — replaces legacy "Ciny/CinyProduct" (a tagging
 * feature, NOT a gold-price snapshot mechanism, despite the misleading legacy name).
 */
export type Collection = $Result.DefaultSelection<Prisma.$CollectionPayload>
/**
 * Model CollectionProduct
 * 
 */
export type CollectionProduct = $Result.DefaultSelection<Prisma.$CollectionProductPayload>
/**
 * Model Product
 * 
 */
export type Product = $Result.DefaultSelection<Prisma.$ProductPayload>
/**
 * Model ProductImage
 * 
 */
export type ProductImage = $Result.DefaultSelection<Prisma.$ProductImagePayload>
/**
 * Model ProductVariant
 * 
 */
export type ProductVariant = $Result.DefaultSelection<Prisma.$ProductVariantPayload>
/**
 * Model Order
 * 
 */
export type Order = $Result.DefaultSelection<Prisma.$OrderPayload>
/**
 * Model OrderItem
 * 
 */
export type OrderItem = $Result.DefaultSelection<Prisma.$OrderItemPayload>
/**
 * Model OrderStatusEvent
 * 
 */
export type OrderStatusEvent = $Result.DefaultSelection<Prisma.$OrderStatusEventPayload>
/**
 * Model PreOrder
 * 
 */
export type PreOrder = $Result.DefaultSelection<Prisma.$PreOrderPayload>
/**
 * Model PreOrderStatusEvent
 * 
 */
export type PreOrderStatusEvent = $Result.DefaultSelection<Prisma.$PreOrderStatusEventPayload>
/**
 * Model LedgerEntry
 * 
 */
export type LedgerEntry = $Result.DefaultSelection<Prisma.$LedgerEntryPayload>
/**
 * Model GoldPriceQuote
 * Replaces legacy WebServiceGold / ConfigStatic.gold_price — timestamped price feed.
 */
export type GoldPriceQuote = $Result.DefaultSelection<Prisma.$GoldPriceQuotePayload>
/**
 * Model WalletBonus
 * Time-limited gold cashback bonus — replaces the legacy Rooyesh\Wallet gold credit.
 */
export type WalletBonus = $Result.DefaultSelection<Prisma.$WalletBonusPayload>
/**
 * Model UserType
 * 
 */
export type UserType = $Result.DefaultSelection<Prisma.$UserTypePayload>
/**
 * Model Permission
 * 
 */
export type Permission = $Result.DefaultSelection<Prisma.$PermissionPayload>
/**
 * Model Comment
 * 
 */
export type Comment = $Result.DefaultSelection<Prisma.$CommentPayload>
/**
 * Model Setting
 * 
 */
export type Setting = $Result.DefaultSelection<Prisma.$SettingPayload>
/**
 * Model Promotion
 * 
 */
export type Promotion = $Result.DefaultSelection<Prisma.$PromotionPayload>
/**
 * Model PromotionExclusion
 * Legacy "ignore" table (views/offersIgnore) — specific products, categories,
 * customers or brands excluded from the automatic discount engine.
 * Legacy posts { type, item_id[] }: "type" reuses the promotion scope codes
 * (1 محصولات | 2 دسته بندی | 3 مشتری | 4 برند) and "itemId" is the excluded row.
 */
export type PromotionExclusion = $Result.DefaultSelection<Prisma.$PromotionExclusionPayload>
/**
 * Model BranchAllocation
 * 
 */
export type BranchAllocation = $Result.DefaultSelection<Prisma.$BranchAllocationPayload>
/**
 * Model BranchAllocationItem
 * 
 */
export type BranchAllocationItem = $Result.DefaultSelection<Prisma.$BranchAllocationItemPayload>
/**
 * Model SmsMessage
 * 
 */
export type SmsMessage = $Result.DefaultSelection<Prisma.$SmsMessagePayload>
/**
 * Model Notification
 * 
 */
export type Notification = $Result.DefaultSelection<Prisma.$NotificationPayload>
/**
 * Model NotificationRecipient
 * Per-customer delivery + read state — legacy `GET notify/read/{id}`.
 */
export type NotificationRecipient = $Result.DefaultSelection<Prisma.$NotificationRecipientPayload>
/**
 * Model NewsletterSubscriber
 * Legacy views/newsletters — the mailing-list signups collected by the site.
 */
export type NewsletterSubscriber = $Result.DefaultSelection<Prisma.$NewsletterSubscriberPayload>
/**
 * Model CustomerActivityLog
 * Legacy views/statics — the customer activity log the "آمار" screen reads
 * (`log/list/customer`, `log/ago/{customerId}`).
 */
export type CustomerActivityLog = $Result.DefaultSelection<Prisma.$CustomerActivityLogPayload>
/**
 * Model UploadedFile
 * 
 */
export type UploadedFile = $Result.DefaultSelection<Prisma.$UploadedFilePayload>
/**
 * Model CustomerOtp
 * One OTP login challenge for a customer.
 * 
 * Ports henza_server's flow (ApiMobileController.php:39-78), where userAuth
 * generated rand(1000,9999), stored it on the customer row as `send_password`
 * and sent it by SMS, and userVerfiy compared the submitted code against it
 * (mismatch -> HTTP 422).
 * 
 * Three deliberate improvements over the reference, approved by the user
 * (docs/parity/DECISIONS.md D6 and T1):
 * 1. the code is stored as a bcrypt hash, never in plain text — the
 * reference kept it readable in a customer column;
 * 2. it expires (`expiresAt`) — the reference's code stayed valid forever;
 * 3. attempts are counted and the challenge locks out — the reference had
 * no limit at all.
 * The parity behaviour itself is the code comparison and the rejection.
 */
export type CustomerOtp = $Result.DefaultSelection<Prisma.$CustomerOtpPayload>

/**
 * Enums
 */
export namespace $Enums {
  export const AdminRole: {
  SUPER_ADMIN: 'SUPER_ADMIN',
  SYSTEM_APPROVER: 'SYSTEM_APPROVER',
  SALES_EXPERT: 'SALES_EXPERT',
  WORKSHOP_SUPERVISOR: 'WORKSHOP_SUPERVISOR',
  ACCOUNTANT: 'ACCOUNTANT'
};

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


export const CustomerKind: {
  SALES_AGENT: 'SALES_AGENT',
  APP_SHOPKEEPER: 'APP_SHOPKEEPER',
  WALK_IN_SHOPKEEPER: 'WALK_IN_SHOPKEEPER',
  BANKER: 'BANKER',
  WORKSHOP_SUPERVISOR: 'WORKSHOP_SUPERVISOR',
  RETAIL: 'RETAIL'
};

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


export const VerificationStep: {
  UNVERIFIED: 'UNVERIFIED',
  STEP_ONE_SUBMITTED: 'STEP_ONE_SUBMITTED',
  STEP_TWO_SUBMITTED: 'STEP_TWO_SUBMITTED',
  VERIFIED: 'VERIFIED'
};

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


export const ProductImageRole: {
  FEATURED: 'FEATURED',
  FEATURED_MOBILE: 'FEATURED_MOBILE',
  GALLERY: 'GALLERY',
  GALLERY_MOBILE: 'GALLERY_MOBILE'
};

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


export const OrderChannel: {
  RETAIL: 'RETAIL',
  WHOLESALE: 'WHOLESALE'
};

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


export const OrderStatus: {
  SUSPENDED: 'SUSPENDED',
  PLACED: 'PLACED',
  ADMIN_APPROVED: 'ADMIN_APPROVED',
  SOURCING: 'SOURCING',
  PREPARING: 'PREPARING',
  DELIVERED_TO_AGENT: 'DELIVERED_TO_AGENT',
  DELIVERED_TO_CUSTOMER: 'DELIVERED_TO_CUSTOMER',
  CANCELLED: 'CANCELLED'
};

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


export const PreOrderStatus: {
  PLACED: 'PLACED',
  ADMIN_APPROVED: 'ADMIN_APPROVED',
  WORKSHOP_APPROVED: 'WORKSHOP_APPROVED',
  READY_TO_SHIP: 'READY_TO_SHIP',
  DELIVERED: 'DELIVERED',
  CANCELLED: 'CANCELLED'
};

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


export const LedgerCurrency: {
  GOLD_GRAM: 'GOLD_GRAM',
  RIAL: 'RIAL'
};

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


export const LedgerDirection: {
  DEBIT: 'DEBIT',
  CREDIT: 'CREDIT'
};

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


export const LedgerSourceType: {
  ORDER_STOCK: 'ORDER_STOCK',
  ORDER_PRE_ORDER: 'ORDER_PRE_ORDER',
  REPAYMENT_MELTED_GOLD: 'REPAYMENT_MELTED_GOLD',
  REPAYMENT_TRANSFER: 'REPAYMENT_TRANSFER',
  REPAYMENT_CHEQUE: 'REPAYMENT_CHEQUE',
  REPAYMENT_CASH: 'REPAYMENT_CASH',
  WALLET_BONUS: 'WALLET_BONUS',
  ADJUSTMENT: 'ADJUSTMENT'
};

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


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

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


export const PromotionScope: {
  PRODUCT: 'PRODUCT',
  CATEGORY: 'CATEGORY',
  CUSTOMER: 'CUSTOMER',
  BRAND: 'BRAND'
};

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


export const PromotionUsage: {
  ONCE: 'ONCE',
  UNTIL_END_DATE: 'UNTIL_END_DATE'
};

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


export const MessageAudience: {
  SINGLE_NUMBER: 'SINGLE_NUMBER',
  MULTIPLE_NUMBERS: 'MULTIPLE_NUMBERS',
  ALL_CUSTOMERS: 'ALL_CUSTOMERS',
  WHOLESALE_CUSTOMERS: 'WHOLESALE_CUSTOMERS',
  RETAIL_CUSTOMERS: 'RETAIL_CUSTOMERS',
  SALES_AGENTS: 'SALES_AGENTS'
};

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

}

export type AdminRole = $Enums.AdminRole

export const AdminRole: typeof $Enums.AdminRole

export type CustomerKind = $Enums.CustomerKind

export const CustomerKind: typeof $Enums.CustomerKind

export type VerificationStep = $Enums.VerificationStep

export const VerificationStep: typeof $Enums.VerificationStep

export type ProductImageRole = $Enums.ProductImageRole

export const ProductImageRole: typeof $Enums.ProductImageRole

export type OrderChannel = $Enums.OrderChannel

export const OrderChannel: typeof $Enums.OrderChannel

export type OrderStatus = $Enums.OrderStatus

export const OrderStatus: typeof $Enums.OrderStatus

export type PreOrderStatus = $Enums.PreOrderStatus

export const PreOrderStatus: typeof $Enums.PreOrderStatus

export type LedgerCurrency = $Enums.LedgerCurrency

export const LedgerCurrency: typeof $Enums.LedgerCurrency

export type LedgerDirection = $Enums.LedgerDirection

export const LedgerDirection: typeof $Enums.LedgerDirection

export type LedgerSourceType = $Enums.LedgerSourceType

export const LedgerSourceType: typeof $Enums.LedgerSourceType

export type CommentStatus = $Enums.CommentStatus

export const CommentStatus: typeof $Enums.CommentStatus

export type PromotionScope = $Enums.PromotionScope

export const PromotionScope: typeof $Enums.PromotionScope

export type PromotionUsage = $Enums.PromotionUsage

export const PromotionUsage: typeof $Enums.PromotionUsage

export type MessageAudience = $Enums.MessageAudience

export const MessageAudience: typeof $Enums.MessageAudience

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

  /**
   * `prisma.adminUser`: Exposes CRUD operations for the **AdminUser** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more AdminUsers
    * const adminUsers = await prisma.adminUser.findMany()
    * ```
    */
  get adminUser(): Prisma.AdminUserDelegate<ExtArgs>;

  /**
   * `prisma.appSession`: Exposes CRUD operations for the **AppSession** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more AppSessions
    * const appSessions = await prisma.appSession.findMany()
    * ```
    */
  get appSession(): Prisma.AppSessionDelegate<ExtArgs>;

  /**
   * `prisma.adminSession`: Exposes CRUD operations for the **AdminSession** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more AdminSessions
    * const adminSessions = await prisma.adminSession.findMany()
    * ```
    */
  get adminSession(): Prisma.AdminSessionDelegate<ExtArgs>;

  /**
   * `prisma.salesExpertProfile`: Exposes CRUD operations for the **SalesExpertProfile** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more SalesExpertProfiles
    * const salesExpertProfiles = await prisma.salesExpertProfile.findMany()
    * ```
    */
  get salesExpertProfile(): Prisma.SalesExpertProfileDelegate<ExtArgs>;

  /**
   * `prisma.customer`: Exposes CRUD operations for the **Customer** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Customers
    * const customers = await prisma.customer.findMany()
    * ```
    */
  get customer(): Prisma.CustomerDelegate<ExtArgs>;

  /**
   * `prisma.customerAddress`: Exposes CRUD operations for the **CustomerAddress** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more CustomerAddresses
    * const customerAddresses = await prisma.customerAddress.findMany()
    * ```
    */
  get customerAddress(): Prisma.CustomerAddressDelegate<ExtArgs>;

  /**
   * `prisma.branch`: Exposes CRUD operations for the **Branch** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Branches
    * const branches = await prisma.branch.findMany()
    * ```
    */
  get branch(): Prisma.BranchDelegate<ExtArgs>;

  /**
   * `prisma.workshop`: Exposes CRUD operations for the **Workshop** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Workshops
    * const workshops = await prisma.workshop.findMany()
    * ```
    */
  get workshop(): Prisma.WorkshopDelegate<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.brand`: Exposes CRUD operations for the **Brand** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Brands
    * const brands = await prisma.brand.findMany()
    * ```
    */
  get brand(): Prisma.BrandDelegate<ExtArgs>;

  /**
   * `prisma.collection`: Exposes CRUD operations for the **Collection** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Collections
    * const collections = await prisma.collection.findMany()
    * ```
    */
  get collection(): Prisma.CollectionDelegate<ExtArgs>;

  /**
   * `prisma.collectionProduct`: Exposes CRUD operations for the **CollectionProduct** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more CollectionProducts
    * const collectionProducts = await prisma.collectionProduct.findMany()
    * ```
    */
  get collectionProduct(): Prisma.CollectionProductDelegate<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.productImage`: Exposes CRUD operations for the **ProductImage** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ProductImages
    * const productImages = await prisma.productImage.findMany()
    * ```
    */
  get productImage(): Prisma.ProductImageDelegate<ExtArgs>;

  /**
   * `prisma.productVariant`: Exposes CRUD operations for the **ProductVariant** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more ProductVariants
    * const productVariants = await prisma.productVariant.findMany()
    * ```
    */
  get productVariant(): Prisma.ProductVariantDelegate<ExtArgs>;

  /**
   * `prisma.order`: Exposes CRUD operations for the **Order** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Orders
    * const orders = await prisma.order.findMany()
    * ```
    */
  get order(): Prisma.OrderDelegate<ExtArgs>;

  /**
   * `prisma.orderItem`: Exposes CRUD operations for the **OrderItem** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more OrderItems
    * const orderItems = await prisma.orderItem.findMany()
    * ```
    */
  get orderItem(): Prisma.OrderItemDelegate<ExtArgs>;

  /**
   * `prisma.orderStatusEvent`: Exposes CRUD operations for the **OrderStatusEvent** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more OrderStatusEvents
    * const orderStatusEvents = await prisma.orderStatusEvent.findMany()
    * ```
    */
  get orderStatusEvent(): Prisma.OrderStatusEventDelegate<ExtArgs>;

  /**
   * `prisma.preOrder`: Exposes CRUD operations for the **PreOrder** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more PreOrders
    * const preOrders = await prisma.preOrder.findMany()
    * ```
    */
  get preOrder(): Prisma.PreOrderDelegate<ExtArgs>;

  /**
   * `prisma.preOrderStatusEvent`: Exposes CRUD operations for the **PreOrderStatusEvent** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more PreOrderStatusEvents
    * const preOrderStatusEvents = await prisma.preOrderStatusEvent.findMany()
    * ```
    */
  get preOrderStatusEvent(): Prisma.PreOrderStatusEventDelegate<ExtArgs>;

  /**
   * `prisma.ledgerEntry`: Exposes CRUD operations for the **LedgerEntry** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more LedgerEntries
    * const ledgerEntries = await prisma.ledgerEntry.findMany()
    * ```
    */
  get ledgerEntry(): Prisma.LedgerEntryDelegate<ExtArgs>;

  /**
   * `prisma.goldPriceQuote`: Exposes CRUD operations for the **GoldPriceQuote** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more GoldPriceQuotes
    * const goldPriceQuotes = await prisma.goldPriceQuote.findMany()
    * ```
    */
  get goldPriceQuote(): Prisma.GoldPriceQuoteDelegate<ExtArgs>;

  /**
   * `prisma.walletBonus`: Exposes CRUD operations for the **WalletBonus** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more WalletBonuses
    * const walletBonuses = await prisma.walletBonus.findMany()
    * ```
    */
  get walletBonus(): Prisma.WalletBonusDelegate<ExtArgs>;

  /**
   * `prisma.userType`: Exposes CRUD operations for the **UserType** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more UserTypes
    * const userTypes = await prisma.userType.findMany()
    * ```
    */
  get userType(): Prisma.UserTypeDelegate<ExtArgs>;

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

  /**
   * `prisma.comment`: Exposes CRUD operations for the **Comment** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Comments
    * const comments = await prisma.comment.findMany()
    * ```
    */
  get comment(): Prisma.CommentDelegate<ExtArgs>;

  /**
   * `prisma.setting`: Exposes CRUD operations for the **Setting** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Settings
    * const settings = await prisma.setting.findMany()
    * ```
    */
  get setting(): Prisma.SettingDelegate<ExtArgs>;

  /**
   * `prisma.promotion`: Exposes CRUD operations for the **Promotion** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Promotions
    * const promotions = await prisma.promotion.findMany()
    * ```
    */
  get promotion(): Prisma.PromotionDelegate<ExtArgs>;

  /**
   * `prisma.promotionExclusion`: Exposes CRUD operations for the **PromotionExclusion** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more PromotionExclusions
    * const promotionExclusions = await prisma.promotionExclusion.findMany()
    * ```
    */
  get promotionExclusion(): Prisma.PromotionExclusionDelegate<ExtArgs>;

  /**
   * `prisma.branchAllocation`: Exposes CRUD operations for the **BranchAllocation** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more BranchAllocations
    * const branchAllocations = await prisma.branchAllocation.findMany()
    * ```
    */
  get branchAllocation(): Prisma.BranchAllocationDelegate<ExtArgs>;

  /**
   * `prisma.branchAllocationItem`: Exposes CRUD operations for the **BranchAllocationItem** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more BranchAllocationItems
    * const branchAllocationItems = await prisma.branchAllocationItem.findMany()
    * ```
    */
  get branchAllocationItem(): Prisma.BranchAllocationItemDelegate<ExtArgs>;

  /**
   * `prisma.smsMessage`: Exposes CRUD operations for the **SmsMessage** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more SmsMessages
    * const smsMessages = await prisma.smsMessage.findMany()
    * ```
    */
  get smsMessage(): Prisma.SmsMessageDelegate<ExtArgs>;

  /**
   * `prisma.notification`: Exposes CRUD operations for the **Notification** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more Notifications
    * const notifications = await prisma.notification.findMany()
    * ```
    */
  get notification(): Prisma.NotificationDelegate<ExtArgs>;

  /**
   * `prisma.notificationRecipient`: Exposes CRUD operations for the **NotificationRecipient** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more NotificationRecipients
    * const notificationRecipients = await prisma.notificationRecipient.findMany()
    * ```
    */
  get notificationRecipient(): Prisma.NotificationRecipientDelegate<ExtArgs>;

  /**
   * `prisma.newsletterSubscriber`: Exposes CRUD operations for the **NewsletterSubscriber** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more NewsletterSubscribers
    * const newsletterSubscribers = await prisma.newsletterSubscriber.findMany()
    * ```
    */
  get newsletterSubscriber(): Prisma.NewsletterSubscriberDelegate<ExtArgs>;

  /**
   * `prisma.customerActivityLog`: Exposes CRUD operations for the **CustomerActivityLog** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more CustomerActivityLogs
    * const customerActivityLogs = await prisma.customerActivityLog.findMany()
    * ```
    */
  get customerActivityLog(): Prisma.CustomerActivityLogDelegate<ExtArgs>;

  /**
   * `prisma.uploadedFile`: Exposes CRUD operations for the **UploadedFile** model.
    * Example usage:
    * ```ts
    * // Fetch zero or more UploadedFiles
    * const uploadedFiles = await prisma.uploadedFile.findMany()
    * ```
    */
  get uploadedFile(): Prisma.UploadedFileDelegate<ExtArgs>;

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

export namespace Prisma {
  export import DMMF = runtime.DMMF

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

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

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

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



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

  export type DecimalJsLike = runtime.DecimalJsLike

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

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

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

  export const prismaVersion: PrismaVersion 

  /**
   * Utility Types
   */


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

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

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

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

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

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

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

  type SelectAndInclude = {
    select: any
    include: any
  }

  type SelectAndOmit = {
    select: any
    omit: any
  }

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

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

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


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

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

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

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

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

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

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

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

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


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


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

  /**
   * From ts-toolbelt
   */

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

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

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

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

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

  export type Union = any

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /**
  0
  */
  export type False = 0

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

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

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

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

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

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

  export const type: unique symbol;



  /**
   * Used by group by
   */

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

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

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

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

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

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


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

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


  export const ModelName: {
    City: 'City',
    AdminUser: 'AdminUser',
    AppSession: 'AppSession',
    AdminSession: 'AdminSession',
    SalesExpertProfile: 'SalesExpertProfile',
    Customer: 'Customer',
    CustomerAddress: 'CustomerAddress',
    Branch: 'Branch',
    Workshop: 'Workshop',
    Category: 'Category',
    Brand: 'Brand',
    Collection: 'Collection',
    CollectionProduct: 'CollectionProduct',
    Product: 'Product',
    ProductImage: 'ProductImage',
    ProductVariant: 'ProductVariant',
    Order: 'Order',
    OrderItem: 'OrderItem',
    OrderStatusEvent: 'OrderStatusEvent',
    PreOrder: 'PreOrder',
    PreOrderStatusEvent: 'PreOrderStatusEvent',
    LedgerEntry: 'LedgerEntry',
    GoldPriceQuote: 'GoldPriceQuote',
    WalletBonus: 'WalletBonus',
    UserType: 'UserType',
    Permission: 'Permission',
    Comment: 'Comment',
    Setting: 'Setting',
    Promotion: 'Promotion',
    PromotionExclusion: 'PromotionExclusion',
    BranchAllocation: 'BranchAllocation',
    BranchAllocationItem: 'BranchAllocationItem',
    SmsMessage: 'SmsMessage',
    Notification: 'Notification',
    NotificationRecipient: 'NotificationRecipient',
    NewsletterSubscriber: 'NewsletterSubscriber',
    CustomerActivityLog: 'CustomerActivityLog',
    UploadedFile: 'UploadedFile',
    CustomerOtp: 'CustomerOtp'
  };

  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: "city" | "adminUser" | "appSession" | "adminSession" | "salesExpertProfile" | "customer" | "customerAddress" | "branch" | "workshop" | "category" | "brand" | "collection" | "collectionProduct" | "product" | "productImage" | "productVariant" | "order" | "orderItem" | "orderStatusEvent" | "preOrder" | "preOrderStatusEvent" | "ledgerEntry" | "goldPriceQuote" | "walletBonus" | "userType" | "permission" | "comment" | "setting" | "promotion" | "promotionExclusion" | "branchAllocation" | "branchAllocationItem" | "smsMessage" | "notification" | "notificationRecipient" | "newsletterSubscriber" | "customerActivityLog" | "uploadedFile" | "customerOtp"
      txIsolationLevel: Prisma.TransactionIsolationLevel
    }
    model: {
      City: {
        payload: Prisma.$CityPayload<ExtArgs>
        fields: Prisma.CityFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CityFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CityPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CityFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CityPayload>
          }
          findFirst: {
            args: Prisma.CityFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CityPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CityFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CityPayload>
          }
          findMany: {
            args: Prisma.CityFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CityPayload>[]
          }
          create: {
            args: Prisma.CityCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CityPayload>
          }
          createMany: {
            args: Prisma.CityCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.CityCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CityPayload>[]
          }
          delete: {
            args: Prisma.CityDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CityPayload>
          }
          update: {
            args: Prisma.CityUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CityPayload>
          }
          deleteMany: {
            args: Prisma.CityDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.CityUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.CityUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CityPayload>
          }
          aggregate: {
            args: Prisma.CityAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCity>
          }
          groupBy: {
            args: Prisma.CityGroupByArgs<ExtArgs>
            result: $Utils.Optional<CityGroupByOutputType>[]
          }
          count: {
            args: Prisma.CityCountArgs<ExtArgs>
            result: $Utils.Optional<CityCountAggregateOutputType> | number
          }
        }
      }
      AdminUser: {
        payload: Prisma.$AdminUserPayload<ExtArgs>
        fields: Prisma.AdminUserFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AdminUserFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AdminUserPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AdminUserFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AdminUserPayload>
          }
          findFirst: {
            args: Prisma.AdminUserFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AdminUserPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AdminUserFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AdminUserPayload>
          }
          findMany: {
            args: Prisma.AdminUserFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AdminUserPayload>[]
          }
          create: {
            args: Prisma.AdminUserCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AdminUserPayload>
          }
          createMany: {
            args: Prisma.AdminUserCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.AdminUserCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AdminUserPayload>[]
          }
          delete: {
            args: Prisma.AdminUserDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AdminUserPayload>
          }
          update: {
            args: Prisma.AdminUserUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AdminUserPayload>
          }
          deleteMany: {
            args: Prisma.AdminUserDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.AdminUserUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.AdminUserUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AdminUserPayload>
          }
          aggregate: {
            args: Prisma.AdminUserAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAdminUser>
          }
          groupBy: {
            args: Prisma.AdminUserGroupByArgs<ExtArgs>
            result: $Utils.Optional<AdminUserGroupByOutputType>[]
          }
          count: {
            args: Prisma.AdminUserCountArgs<ExtArgs>
            result: $Utils.Optional<AdminUserCountAggregateOutputType> | number
          }
        }
      }
      AppSession: {
        payload: Prisma.$AppSessionPayload<ExtArgs>
        fields: Prisma.AppSessionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AppSessionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppSessionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AppSessionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppSessionPayload>
          }
          findFirst: {
            args: Prisma.AppSessionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppSessionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AppSessionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppSessionPayload>
          }
          findMany: {
            args: Prisma.AppSessionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppSessionPayload>[]
          }
          create: {
            args: Prisma.AppSessionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppSessionPayload>
          }
          createMany: {
            args: Prisma.AppSessionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.AppSessionCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppSessionPayload>[]
          }
          delete: {
            args: Prisma.AppSessionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppSessionPayload>
          }
          update: {
            args: Prisma.AppSessionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppSessionPayload>
          }
          deleteMany: {
            args: Prisma.AppSessionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.AppSessionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.AppSessionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AppSessionPayload>
          }
          aggregate: {
            args: Prisma.AppSessionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAppSession>
          }
          groupBy: {
            args: Prisma.AppSessionGroupByArgs<ExtArgs>
            result: $Utils.Optional<AppSessionGroupByOutputType>[]
          }
          count: {
            args: Prisma.AppSessionCountArgs<ExtArgs>
            result: $Utils.Optional<AppSessionCountAggregateOutputType> | number
          }
        }
      }
      AdminSession: {
        payload: Prisma.$AdminSessionPayload<ExtArgs>
        fields: Prisma.AdminSessionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.AdminSessionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AdminSessionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.AdminSessionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AdminSessionPayload>
          }
          findFirst: {
            args: Prisma.AdminSessionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AdminSessionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.AdminSessionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AdminSessionPayload>
          }
          findMany: {
            args: Prisma.AdminSessionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AdminSessionPayload>[]
          }
          create: {
            args: Prisma.AdminSessionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AdminSessionPayload>
          }
          createMany: {
            args: Prisma.AdminSessionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.AdminSessionCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AdminSessionPayload>[]
          }
          delete: {
            args: Prisma.AdminSessionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AdminSessionPayload>
          }
          update: {
            args: Prisma.AdminSessionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AdminSessionPayload>
          }
          deleteMany: {
            args: Prisma.AdminSessionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.AdminSessionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.AdminSessionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$AdminSessionPayload>
          }
          aggregate: {
            args: Prisma.AdminSessionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateAdminSession>
          }
          groupBy: {
            args: Prisma.AdminSessionGroupByArgs<ExtArgs>
            result: $Utils.Optional<AdminSessionGroupByOutputType>[]
          }
          count: {
            args: Prisma.AdminSessionCountArgs<ExtArgs>
            result: $Utils.Optional<AdminSessionCountAggregateOutputType> | number
          }
        }
      }
      SalesExpertProfile: {
        payload: Prisma.$SalesExpertProfilePayload<ExtArgs>
        fields: Prisma.SalesExpertProfileFieldRefs
        operations: {
          findUnique: {
            args: Prisma.SalesExpertProfileFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SalesExpertProfilePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.SalesExpertProfileFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SalesExpertProfilePayload>
          }
          findFirst: {
            args: Prisma.SalesExpertProfileFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SalesExpertProfilePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.SalesExpertProfileFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SalesExpertProfilePayload>
          }
          findMany: {
            args: Prisma.SalesExpertProfileFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SalesExpertProfilePayload>[]
          }
          create: {
            args: Prisma.SalesExpertProfileCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SalesExpertProfilePayload>
          }
          createMany: {
            args: Prisma.SalesExpertProfileCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.SalesExpertProfileCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SalesExpertProfilePayload>[]
          }
          delete: {
            args: Prisma.SalesExpertProfileDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SalesExpertProfilePayload>
          }
          update: {
            args: Prisma.SalesExpertProfileUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SalesExpertProfilePayload>
          }
          deleteMany: {
            args: Prisma.SalesExpertProfileDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.SalesExpertProfileUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.SalesExpertProfileUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SalesExpertProfilePayload>
          }
          aggregate: {
            args: Prisma.SalesExpertProfileAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateSalesExpertProfile>
          }
          groupBy: {
            args: Prisma.SalesExpertProfileGroupByArgs<ExtArgs>
            result: $Utils.Optional<SalesExpertProfileGroupByOutputType>[]
          }
          count: {
            args: Prisma.SalesExpertProfileCountArgs<ExtArgs>
            result: $Utils.Optional<SalesExpertProfileCountAggregateOutputType> | number
          }
        }
      }
      Customer: {
        payload: Prisma.$CustomerPayload<ExtArgs>
        fields: Prisma.CustomerFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CustomerFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CustomerFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerPayload>
          }
          findFirst: {
            args: Prisma.CustomerFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CustomerFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerPayload>
          }
          findMany: {
            args: Prisma.CustomerFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerPayload>[]
          }
          create: {
            args: Prisma.CustomerCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerPayload>
          }
          createMany: {
            args: Prisma.CustomerCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.CustomerCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerPayload>[]
          }
          delete: {
            args: Prisma.CustomerDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerPayload>
          }
          update: {
            args: Prisma.CustomerUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerPayload>
          }
          deleteMany: {
            args: Prisma.CustomerDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.CustomerUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.CustomerUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerPayload>
          }
          aggregate: {
            args: Prisma.CustomerAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCustomer>
          }
          groupBy: {
            args: Prisma.CustomerGroupByArgs<ExtArgs>
            result: $Utils.Optional<CustomerGroupByOutputType>[]
          }
          count: {
            args: Prisma.CustomerCountArgs<ExtArgs>
            result: $Utils.Optional<CustomerCountAggregateOutputType> | number
          }
        }
      }
      CustomerAddress: {
        payload: Prisma.$CustomerAddressPayload<ExtArgs>
        fields: Prisma.CustomerAddressFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CustomerAddressFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerAddressPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CustomerAddressFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerAddressPayload>
          }
          findFirst: {
            args: Prisma.CustomerAddressFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerAddressPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CustomerAddressFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerAddressPayload>
          }
          findMany: {
            args: Prisma.CustomerAddressFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerAddressPayload>[]
          }
          create: {
            args: Prisma.CustomerAddressCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerAddressPayload>
          }
          createMany: {
            args: Prisma.CustomerAddressCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.CustomerAddressCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerAddressPayload>[]
          }
          delete: {
            args: Prisma.CustomerAddressDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerAddressPayload>
          }
          update: {
            args: Prisma.CustomerAddressUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerAddressPayload>
          }
          deleteMany: {
            args: Prisma.CustomerAddressDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.CustomerAddressUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.CustomerAddressUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerAddressPayload>
          }
          aggregate: {
            args: Prisma.CustomerAddressAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCustomerAddress>
          }
          groupBy: {
            args: Prisma.CustomerAddressGroupByArgs<ExtArgs>
            result: $Utils.Optional<CustomerAddressGroupByOutputType>[]
          }
          count: {
            args: Prisma.CustomerAddressCountArgs<ExtArgs>
            result: $Utils.Optional<CustomerAddressCountAggregateOutputType> | number
          }
        }
      }
      Branch: {
        payload: Prisma.$BranchPayload<ExtArgs>
        fields: Prisma.BranchFieldRefs
        operations: {
          findUnique: {
            args: Prisma.BranchFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.BranchFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchPayload>
          }
          findFirst: {
            args: Prisma.BranchFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.BranchFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchPayload>
          }
          findMany: {
            args: Prisma.BranchFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchPayload>[]
          }
          create: {
            args: Prisma.BranchCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchPayload>
          }
          createMany: {
            args: Prisma.BranchCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.BranchCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchPayload>[]
          }
          delete: {
            args: Prisma.BranchDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchPayload>
          }
          update: {
            args: Prisma.BranchUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchPayload>
          }
          deleteMany: {
            args: Prisma.BranchDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.BranchUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.BranchUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchPayload>
          }
          aggregate: {
            args: Prisma.BranchAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateBranch>
          }
          groupBy: {
            args: Prisma.BranchGroupByArgs<ExtArgs>
            result: $Utils.Optional<BranchGroupByOutputType>[]
          }
          count: {
            args: Prisma.BranchCountArgs<ExtArgs>
            result: $Utils.Optional<BranchCountAggregateOutputType> | number
          }
        }
      }
      Workshop: {
        payload: Prisma.$WorkshopPayload<ExtArgs>
        fields: Prisma.WorkshopFieldRefs
        operations: {
          findUnique: {
            args: Prisma.WorkshopFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkshopPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.WorkshopFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkshopPayload>
          }
          findFirst: {
            args: Prisma.WorkshopFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkshopPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.WorkshopFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkshopPayload>
          }
          findMany: {
            args: Prisma.WorkshopFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkshopPayload>[]
          }
          create: {
            args: Prisma.WorkshopCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkshopPayload>
          }
          createMany: {
            args: Prisma.WorkshopCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.WorkshopCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkshopPayload>[]
          }
          delete: {
            args: Prisma.WorkshopDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkshopPayload>
          }
          update: {
            args: Prisma.WorkshopUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkshopPayload>
          }
          deleteMany: {
            args: Prisma.WorkshopDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.WorkshopUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.WorkshopUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WorkshopPayload>
          }
          aggregate: {
            args: Prisma.WorkshopAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateWorkshop>
          }
          groupBy: {
            args: Prisma.WorkshopGroupByArgs<ExtArgs>
            result: $Utils.Optional<WorkshopGroupByOutputType>[]
          }
          count: {
            args: Prisma.WorkshopCountArgs<ExtArgs>
            result: $Utils.Optional<WorkshopCountAggregateOutputType> | 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
          }
          createManyAndReturn: {
            args: Prisma.CategoryCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CategoryPayload>[]
          }
          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
          }
        }
      }
      Brand: {
        payload: Prisma.$BrandPayload<ExtArgs>
        fields: Prisma.BrandFieldRefs
        operations: {
          findUnique: {
            args: Prisma.BrandFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BrandPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.BrandFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BrandPayload>
          }
          findFirst: {
            args: Prisma.BrandFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BrandPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.BrandFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BrandPayload>
          }
          findMany: {
            args: Prisma.BrandFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BrandPayload>[]
          }
          create: {
            args: Prisma.BrandCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BrandPayload>
          }
          createMany: {
            args: Prisma.BrandCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.BrandCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BrandPayload>[]
          }
          delete: {
            args: Prisma.BrandDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BrandPayload>
          }
          update: {
            args: Prisma.BrandUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BrandPayload>
          }
          deleteMany: {
            args: Prisma.BrandDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.BrandUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.BrandUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BrandPayload>
          }
          aggregate: {
            args: Prisma.BrandAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateBrand>
          }
          groupBy: {
            args: Prisma.BrandGroupByArgs<ExtArgs>
            result: $Utils.Optional<BrandGroupByOutputType>[]
          }
          count: {
            args: Prisma.BrandCountArgs<ExtArgs>
            result: $Utils.Optional<BrandCountAggregateOutputType> | number
          }
        }
      }
      Collection: {
        payload: Prisma.$CollectionPayload<ExtArgs>
        fields: Prisma.CollectionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CollectionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CollectionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CollectionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CollectionPayload>
          }
          findFirst: {
            args: Prisma.CollectionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CollectionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CollectionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CollectionPayload>
          }
          findMany: {
            args: Prisma.CollectionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CollectionPayload>[]
          }
          create: {
            args: Prisma.CollectionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CollectionPayload>
          }
          createMany: {
            args: Prisma.CollectionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.CollectionCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CollectionPayload>[]
          }
          delete: {
            args: Prisma.CollectionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CollectionPayload>
          }
          update: {
            args: Prisma.CollectionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CollectionPayload>
          }
          deleteMany: {
            args: Prisma.CollectionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.CollectionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.CollectionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CollectionPayload>
          }
          aggregate: {
            args: Prisma.CollectionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCollection>
          }
          groupBy: {
            args: Prisma.CollectionGroupByArgs<ExtArgs>
            result: $Utils.Optional<CollectionGroupByOutputType>[]
          }
          count: {
            args: Prisma.CollectionCountArgs<ExtArgs>
            result: $Utils.Optional<CollectionCountAggregateOutputType> | number
          }
        }
      }
      CollectionProduct: {
        payload: Prisma.$CollectionProductPayload<ExtArgs>
        fields: Prisma.CollectionProductFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CollectionProductFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CollectionProductPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CollectionProductFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CollectionProductPayload>
          }
          findFirst: {
            args: Prisma.CollectionProductFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CollectionProductPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CollectionProductFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CollectionProductPayload>
          }
          findMany: {
            args: Prisma.CollectionProductFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CollectionProductPayload>[]
          }
          create: {
            args: Prisma.CollectionProductCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CollectionProductPayload>
          }
          createMany: {
            args: Prisma.CollectionProductCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.CollectionProductCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CollectionProductPayload>[]
          }
          delete: {
            args: Prisma.CollectionProductDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CollectionProductPayload>
          }
          update: {
            args: Prisma.CollectionProductUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CollectionProductPayload>
          }
          deleteMany: {
            args: Prisma.CollectionProductDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.CollectionProductUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.CollectionProductUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CollectionProductPayload>
          }
          aggregate: {
            args: Prisma.CollectionProductAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCollectionProduct>
          }
          groupBy: {
            args: Prisma.CollectionProductGroupByArgs<ExtArgs>
            result: $Utils.Optional<CollectionProductGroupByOutputType>[]
          }
          count: {
            args: Prisma.CollectionProductCountArgs<ExtArgs>
            result: $Utils.Optional<CollectionProductCountAggregateOutputType> | 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
          }
          createManyAndReturn: {
            args: Prisma.ProductCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductPayload>[]
          }
          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
          }
        }
      }
      ProductImage: {
        payload: Prisma.$ProductImagePayload<ExtArgs>
        fields: Prisma.ProductImageFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ProductImageFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductImagePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ProductImageFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductImagePayload>
          }
          findFirst: {
            args: Prisma.ProductImageFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductImagePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ProductImageFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductImagePayload>
          }
          findMany: {
            args: Prisma.ProductImageFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductImagePayload>[]
          }
          create: {
            args: Prisma.ProductImageCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductImagePayload>
          }
          createMany: {
            args: Prisma.ProductImageCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.ProductImageCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductImagePayload>[]
          }
          delete: {
            args: Prisma.ProductImageDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductImagePayload>
          }
          update: {
            args: Prisma.ProductImageUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductImagePayload>
          }
          deleteMany: {
            args: Prisma.ProductImageDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ProductImageUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ProductImageUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductImagePayload>
          }
          aggregate: {
            args: Prisma.ProductImageAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateProductImage>
          }
          groupBy: {
            args: Prisma.ProductImageGroupByArgs<ExtArgs>
            result: $Utils.Optional<ProductImageGroupByOutputType>[]
          }
          count: {
            args: Prisma.ProductImageCountArgs<ExtArgs>
            result: $Utils.Optional<ProductImageCountAggregateOutputType> | number
          }
        }
      }
      ProductVariant: {
        payload: Prisma.$ProductVariantPayload<ExtArgs>
        fields: Prisma.ProductVariantFieldRefs
        operations: {
          findUnique: {
            args: Prisma.ProductVariantFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductVariantPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.ProductVariantFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductVariantPayload>
          }
          findFirst: {
            args: Prisma.ProductVariantFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductVariantPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.ProductVariantFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductVariantPayload>
          }
          findMany: {
            args: Prisma.ProductVariantFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductVariantPayload>[]
          }
          create: {
            args: Prisma.ProductVariantCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductVariantPayload>
          }
          createMany: {
            args: Prisma.ProductVariantCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.ProductVariantCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductVariantPayload>[]
          }
          delete: {
            args: Prisma.ProductVariantDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductVariantPayload>
          }
          update: {
            args: Prisma.ProductVariantUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductVariantPayload>
          }
          deleteMany: {
            args: Prisma.ProductVariantDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.ProductVariantUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.ProductVariantUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$ProductVariantPayload>
          }
          aggregate: {
            args: Prisma.ProductVariantAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateProductVariant>
          }
          groupBy: {
            args: Prisma.ProductVariantGroupByArgs<ExtArgs>
            result: $Utils.Optional<ProductVariantGroupByOutputType>[]
          }
          count: {
            args: Prisma.ProductVariantCountArgs<ExtArgs>
            result: $Utils.Optional<ProductVariantCountAggregateOutputType> | number
          }
        }
      }
      Order: {
        payload: Prisma.$OrderPayload<ExtArgs>
        fields: Prisma.OrderFieldRefs
        operations: {
          findUnique: {
            args: Prisma.OrderFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.OrderFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderPayload>
          }
          findFirst: {
            args: Prisma.OrderFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.OrderFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderPayload>
          }
          findMany: {
            args: Prisma.OrderFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderPayload>[]
          }
          create: {
            args: Prisma.OrderCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderPayload>
          }
          createMany: {
            args: Prisma.OrderCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.OrderCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderPayload>[]
          }
          delete: {
            args: Prisma.OrderDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderPayload>
          }
          update: {
            args: Prisma.OrderUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderPayload>
          }
          deleteMany: {
            args: Prisma.OrderDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.OrderUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.OrderUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderPayload>
          }
          aggregate: {
            args: Prisma.OrderAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateOrder>
          }
          groupBy: {
            args: Prisma.OrderGroupByArgs<ExtArgs>
            result: $Utils.Optional<OrderGroupByOutputType>[]
          }
          count: {
            args: Prisma.OrderCountArgs<ExtArgs>
            result: $Utils.Optional<OrderCountAggregateOutputType> | number
          }
        }
      }
      OrderItem: {
        payload: Prisma.$OrderItemPayload<ExtArgs>
        fields: Prisma.OrderItemFieldRefs
        operations: {
          findUnique: {
            args: Prisma.OrderItemFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderItemPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.OrderItemFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderItemPayload>
          }
          findFirst: {
            args: Prisma.OrderItemFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderItemPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.OrderItemFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderItemPayload>
          }
          findMany: {
            args: Prisma.OrderItemFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderItemPayload>[]
          }
          create: {
            args: Prisma.OrderItemCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderItemPayload>
          }
          createMany: {
            args: Prisma.OrderItemCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.OrderItemCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderItemPayload>[]
          }
          delete: {
            args: Prisma.OrderItemDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderItemPayload>
          }
          update: {
            args: Prisma.OrderItemUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderItemPayload>
          }
          deleteMany: {
            args: Prisma.OrderItemDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.OrderItemUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.OrderItemUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderItemPayload>
          }
          aggregate: {
            args: Prisma.OrderItemAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateOrderItem>
          }
          groupBy: {
            args: Prisma.OrderItemGroupByArgs<ExtArgs>
            result: $Utils.Optional<OrderItemGroupByOutputType>[]
          }
          count: {
            args: Prisma.OrderItemCountArgs<ExtArgs>
            result: $Utils.Optional<OrderItemCountAggregateOutputType> | number
          }
        }
      }
      OrderStatusEvent: {
        payload: Prisma.$OrderStatusEventPayload<ExtArgs>
        fields: Prisma.OrderStatusEventFieldRefs
        operations: {
          findUnique: {
            args: Prisma.OrderStatusEventFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderStatusEventPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.OrderStatusEventFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderStatusEventPayload>
          }
          findFirst: {
            args: Prisma.OrderStatusEventFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderStatusEventPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.OrderStatusEventFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderStatusEventPayload>
          }
          findMany: {
            args: Prisma.OrderStatusEventFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderStatusEventPayload>[]
          }
          create: {
            args: Prisma.OrderStatusEventCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderStatusEventPayload>
          }
          createMany: {
            args: Prisma.OrderStatusEventCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.OrderStatusEventCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderStatusEventPayload>[]
          }
          delete: {
            args: Prisma.OrderStatusEventDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderStatusEventPayload>
          }
          update: {
            args: Prisma.OrderStatusEventUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderStatusEventPayload>
          }
          deleteMany: {
            args: Prisma.OrderStatusEventDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.OrderStatusEventUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.OrderStatusEventUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$OrderStatusEventPayload>
          }
          aggregate: {
            args: Prisma.OrderStatusEventAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateOrderStatusEvent>
          }
          groupBy: {
            args: Prisma.OrderStatusEventGroupByArgs<ExtArgs>
            result: $Utils.Optional<OrderStatusEventGroupByOutputType>[]
          }
          count: {
            args: Prisma.OrderStatusEventCountArgs<ExtArgs>
            result: $Utils.Optional<OrderStatusEventCountAggregateOutputType> | number
          }
        }
      }
      PreOrder: {
        payload: Prisma.$PreOrderPayload<ExtArgs>
        fields: Prisma.PreOrderFieldRefs
        operations: {
          findUnique: {
            args: Prisma.PreOrderFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PreOrderPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.PreOrderFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PreOrderPayload>
          }
          findFirst: {
            args: Prisma.PreOrderFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PreOrderPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.PreOrderFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PreOrderPayload>
          }
          findMany: {
            args: Prisma.PreOrderFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PreOrderPayload>[]
          }
          create: {
            args: Prisma.PreOrderCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PreOrderPayload>
          }
          createMany: {
            args: Prisma.PreOrderCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.PreOrderCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PreOrderPayload>[]
          }
          delete: {
            args: Prisma.PreOrderDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PreOrderPayload>
          }
          update: {
            args: Prisma.PreOrderUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PreOrderPayload>
          }
          deleteMany: {
            args: Prisma.PreOrderDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.PreOrderUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.PreOrderUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PreOrderPayload>
          }
          aggregate: {
            args: Prisma.PreOrderAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregatePreOrder>
          }
          groupBy: {
            args: Prisma.PreOrderGroupByArgs<ExtArgs>
            result: $Utils.Optional<PreOrderGroupByOutputType>[]
          }
          count: {
            args: Prisma.PreOrderCountArgs<ExtArgs>
            result: $Utils.Optional<PreOrderCountAggregateOutputType> | number
          }
        }
      }
      PreOrderStatusEvent: {
        payload: Prisma.$PreOrderStatusEventPayload<ExtArgs>
        fields: Prisma.PreOrderStatusEventFieldRefs
        operations: {
          findUnique: {
            args: Prisma.PreOrderStatusEventFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PreOrderStatusEventPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.PreOrderStatusEventFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PreOrderStatusEventPayload>
          }
          findFirst: {
            args: Prisma.PreOrderStatusEventFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PreOrderStatusEventPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.PreOrderStatusEventFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PreOrderStatusEventPayload>
          }
          findMany: {
            args: Prisma.PreOrderStatusEventFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PreOrderStatusEventPayload>[]
          }
          create: {
            args: Prisma.PreOrderStatusEventCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PreOrderStatusEventPayload>
          }
          createMany: {
            args: Prisma.PreOrderStatusEventCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.PreOrderStatusEventCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PreOrderStatusEventPayload>[]
          }
          delete: {
            args: Prisma.PreOrderStatusEventDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PreOrderStatusEventPayload>
          }
          update: {
            args: Prisma.PreOrderStatusEventUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PreOrderStatusEventPayload>
          }
          deleteMany: {
            args: Prisma.PreOrderStatusEventDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.PreOrderStatusEventUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.PreOrderStatusEventUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PreOrderStatusEventPayload>
          }
          aggregate: {
            args: Prisma.PreOrderStatusEventAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregatePreOrderStatusEvent>
          }
          groupBy: {
            args: Prisma.PreOrderStatusEventGroupByArgs<ExtArgs>
            result: $Utils.Optional<PreOrderStatusEventGroupByOutputType>[]
          }
          count: {
            args: Prisma.PreOrderStatusEventCountArgs<ExtArgs>
            result: $Utils.Optional<PreOrderStatusEventCountAggregateOutputType> | number
          }
        }
      }
      LedgerEntry: {
        payload: Prisma.$LedgerEntryPayload<ExtArgs>
        fields: Prisma.LedgerEntryFieldRefs
        operations: {
          findUnique: {
            args: Prisma.LedgerEntryFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LedgerEntryPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.LedgerEntryFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LedgerEntryPayload>
          }
          findFirst: {
            args: Prisma.LedgerEntryFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LedgerEntryPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.LedgerEntryFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LedgerEntryPayload>
          }
          findMany: {
            args: Prisma.LedgerEntryFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LedgerEntryPayload>[]
          }
          create: {
            args: Prisma.LedgerEntryCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LedgerEntryPayload>
          }
          createMany: {
            args: Prisma.LedgerEntryCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.LedgerEntryCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LedgerEntryPayload>[]
          }
          delete: {
            args: Prisma.LedgerEntryDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LedgerEntryPayload>
          }
          update: {
            args: Prisma.LedgerEntryUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LedgerEntryPayload>
          }
          deleteMany: {
            args: Prisma.LedgerEntryDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.LedgerEntryUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.LedgerEntryUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$LedgerEntryPayload>
          }
          aggregate: {
            args: Prisma.LedgerEntryAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateLedgerEntry>
          }
          groupBy: {
            args: Prisma.LedgerEntryGroupByArgs<ExtArgs>
            result: $Utils.Optional<LedgerEntryGroupByOutputType>[]
          }
          count: {
            args: Prisma.LedgerEntryCountArgs<ExtArgs>
            result: $Utils.Optional<LedgerEntryCountAggregateOutputType> | number
          }
        }
      }
      GoldPriceQuote: {
        payload: Prisma.$GoldPriceQuotePayload<ExtArgs>
        fields: Prisma.GoldPriceQuoteFieldRefs
        operations: {
          findUnique: {
            args: Prisma.GoldPriceQuoteFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GoldPriceQuotePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.GoldPriceQuoteFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GoldPriceQuotePayload>
          }
          findFirst: {
            args: Prisma.GoldPriceQuoteFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GoldPriceQuotePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.GoldPriceQuoteFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GoldPriceQuotePayload>
          }
          findMany: {
            args: Prisma.GoldPriceQuoteFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GoldPriceQuotePayload>[]
          }
          create: {
            args: Prisma.GoldPriceQuoteCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GoldPriceQuotePayload>
          }
          createMany: {
            args: Prisma.GoldPriceQuoteCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.GoldPriceQuoteCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GoldPriceQuotePayload>[]
          }
          delete: {
            args: Prisma.GoldPriceQuoteDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GoldPriceQuotePayload>
          }
          update: {
            args: Prisma.GoldPriceQuoteUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GoldPriceQuotePayload>
          }
          deleteMany: {
            args: Prisma.GoldPriceQuoteDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.GoldPriceQuoteUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.GoldPriceQuoteUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$GoldPriceQuotePayload>
          }
          aggregate: {
            args: Prisma.GoldPriceQuoteAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateGoldPriceQuote>
          }
          groupBy: {
            args: Prisma.GoldPriceQuoteGroupByArgs<ExtArgs>
            result: $Utils.Optional<GoldPriceQuoteGroupByOutputType>[]
          }
          count: {
            args: Prisma.GoldPriceQuoteCountArgs<ExtArgs>
            result: $Utils.Optional<GoldPriceQuoteCountAggregateOutputType> | number
          }
        }
      }
      WalletBonus: {
        payload: Prisma.$WalletBonusPayload<ExtArgs>
        fields: Prisma.WalletBonusFieldRefs
        operations: {
          findUnique: {
            args: Prisma.WalletBonusFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WalletBonusPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.WalletBonusFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WalletBonusPayload>
          }
          findFirst: {
            args: Prisma.WalletBonusFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WalletBonusPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.WalletBonusFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WalletBonusPayload>
          }
          findMany: {
            args: Prisma.WalletBonusFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WalletBonusPayload>[]
          }
          create: {
            args: Prisma.WalletBonusCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WalletBonusPayload>
          }
          createMany: {
            args: Prisma.WalletBonusCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.WalletBonusCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WalletBonusPayload>[]
          }
          delete: {
            args: Prisma.WalletBonusDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WalletBonusPayload>
          }
          update: {
            args: Prisma.WalletBonusUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WalletBonusPayload>
          }
          deleteMany: {
            args: Prisma.WalletBonusDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.WalletBonusUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.WalletBonusUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$WalletBonusPayload>
          }
          aggregate: {
            args: Prisma.WalletBonusAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateWalletBonus>
          }
          groupBy: {
            args: Prisma.WalletBonusGroupByArgs<ExtArgs>
            result: $Utils.Optional<WalletBonusGroupByOutputType>[]
          }
          count: {
            args: Prisma.WalletBonusCountArgs<ExtArgs>
            result: $Utils.Optional<WalletBonusCountAggregateOutputType> | number
          }
        }
      }
      UserType: {
        payload: Prisma.$UserTypePayload<ExtArgs>
        fields: Prisma.UserTypeFieldRefs
        operations: {
          findUnique: {
            args: Prisma.UserTypeFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserTypePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.UserTypeFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserTypePayload>
          }
          findFirst: {
            args: Prisma.UserTypeFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserTypePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.UserTypeFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserTypePayload>
          }
          findMany: {
            args: Prisma.UserTypeFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserTypePayload>[]
          }
          create: {
            args: Prisma.UserTypeCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserTypePayload>
          }
          createMany: {
            args: Prisma.UserTypeCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.UserTypeCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserTypePayload>[]
          }
          delete: {
            args: Prisma.UserTypeDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserTypePayload>
          }
          update: {
            args: Prisma.UserTypeUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserTypePayload>
          }
          deleteMany: {
            args: Prisma.UserTypeDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.UserTypeUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.UserTypeUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UserTypePayload>
          }
          aggregate: {
            args: Prisma.UserTypeAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateUserType>
          }
          groupBy: {
            args: Prisma.UserTypeGroupByArgs<ExtArgs>
            result: $Utils.Optional<UserTypeGroupByOutputType>[]
          }
          count: {
            args: Prisma.UserTypeCountArgs<ExtArgs>
            result: $Utils.Optional<UserTypeCountAggregateOutputType> | number
          }
        }
      }
      Permission: {
        payload: Prisma.$PermissionPayload<ExtArgs>
        fields: Prisma.PermissionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.PermissionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PermissionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.PermissionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PermissionPayload>
          }
          findFirst: {
            args: Prisma.PermissionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PermissionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.PermissionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PermissionPayload>
          }
          findMany: {
            args: Prisma.PermissionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PermissionPayload>[]
          }
          create: {
            args: Prisma.PermissionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PermissionPayload>
          }
          createMany: {
            args: Prisma.PermissionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.PermissionCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PermissionPayload>[]
          }
          delete: {
            args: Prisma.PermissionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PermissionPayload>
          }
          update: {
            args: Prisma.PermissionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PermissionPayload>
          }
          deleteMany: {
            args: Prisma.PermissionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.PermissionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.PermissionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PermissionPayload>
          }
          aggregate: {
            args: Prisma.PermissionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregatePermission>
          }
          groupBy: {
            args: Prisma.PermissionGroupByArgs<ExtArgs>
            result: $Utils.Optional<PermissionGroupByOutputType>[]
          }
          count: {
            args: Prisma.PermissionCountArgs<ExtArgs>
            result: $Utils.Optional<PermissionCountAggregateOutputType> | number
          }
        }
      }
      Comment: {
        payload: Prisma.$CommentPayload<ExtArgs>
        fields: Prisma.CommentFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CommentFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommentPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CommentFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommentPayload>
          }
          findFirst: {
            args: Prisma.CommentFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommentPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CommentFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommentPayload>
          }
          findMany: {
            args: Prisma.CommentFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommentPayload>[]
          }
          create: {
            args: Prisma.CommentCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommentPayload>
          }
          createMany: {
            args: Prisma.CommentCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.CommentCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommentPayload>[]
          }
          delete: {
            args: Prisma.CommentDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommentPayload>
          }
          update: {
            args: Prisma.CommentUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommentPayload>
          }
          deleteMany: {
            args: Prisma.CommentDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.CommentUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.CommentUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CommentPayload>
          }
          aggregate: {
            args: Prisma.CommentAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateComment>
          }
          groupBy: {
            args: Prisma.CommentGroupByArgs<ExtArgs>
            result: $Utils.Optional<CommentGroupByOutputType>[]
          }
          count: {
            args: Prisma.CommentCountArgs<ExtArgs>
            result: $Utils.Optional<CommentCountAggregateOutputType> | number
          }
        }
      }
      Setting: {
        payload: Prisma.$SettingPayload<ExtArgs>
        fields: Prisma.SettingFieldRefs
        operations: {
          findUnique: {
            args: Prisma.SettingFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SettingPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.SettingFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SettingPayload>
          }
          findFirst: {
            args: Prisma.SettingFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SettingPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.SettingFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SettingPayload>
          }
          findMany: {
            args: Prisma.SettingFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SettingPayload>[]
          }
          create: {
            args: Prisma.SettingCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SettingPayload>
          }
          createMany: {
            args: Prisma.SettingCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.SettingCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SettingPayload>[]
          }
          delete: {
            args: Prisma.SettingDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SettingPayload>
          }
          update: {
            args: Prisma.SettingUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SettingPayload>
          }
          deleteMany: {
            args: Prisma.SettingDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.SettingUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.SettingUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SettingPayload>
          }
          aggregate: {
            args: Prisma.SettingAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateSetting>
          }
          groupBy: {
            args: Prisma.SettingGroupByArgs<ExtArgs>
            result: $Utils.Optional<SettingGroupByOutputType>[]
          }
          count: {
            args: Prisma.SettingCountArgs<ExtArgs>
            result: $Utils.Optional<SettingCountAggregateOutputType> | number
          }
        }
      }
      Promotion: {
        payload: Prisma.$PromotionPayload<ExtArgs>
        fields: Prisma.PromotionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.PromotionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PromotionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.PromotionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PromotionPayload>
          }
          findFirst: {
            args: Prisma.PromotionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PromotionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.PromotionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PromotionPayload>
          }
          findMany: {
            args: Prisma.PromotionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PromotionPayload>[]
          }
          create: {
            args: Prisma.PromotionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PromotionPayload>
          }
          createMany: {
            args: Prisma.PromotionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.PromotionCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PromotionPayload>[]
          }
          delete: {
            args: Prisma.PromotionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PromotionPayload>
          }
          update: {
            args: Prisma.PromotionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PromotionPayload>
          }
          deleteMany: {
            args: Prisma.PromotionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.PromotionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.PromotionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PromotionPayload>
          }
          aggregate: {
            args: Prisma.PromotionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregatePromotion>
          }
          groupBy: {
            args: Prisma.PromotionGroupByArgs<ExtArgs>
            result: $Utils.Optional<PromotionGroupByOutputType>[]
          }
          count: {
            args: Prisma.PromotionCountArgs<ExtArgs>
            result: $Utils.Optional<PromotionCountAggregateOutputType> | number
          }
        }
      }
      PromotionExclusion: {
        payload: Prisma.$PromotionExclusionPayload<ExtArgs>
        fields: Prisma.PromotionExclusionFieldRefs
        operations: {
          findUnique: {
            args: Prisma.PromotionExclusionFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PromotionExclusionPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.PromotionExclusionFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PromotionExclusionPayload>
          }
          findFirst: {
            args: Prisma.PromotionExclusionFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PromotionExclusionPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.PromotionExclusionFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PromotionExclusionPayload>
          }
          findMany: {
            args: Prisma.PromotionExclusionFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PromotionExclusionPayload>[]
          }
          create: {
            args: Prisma.PromotionExclusionCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PromotionExclusionPayload>
          }
          createMany: {
            args: Prisma.PromotionExclusionCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.PromotionExclusionCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PromotionExclusionPayload>[]
          }
          delete: {
            args: Prisma.PromotionExclusionDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PromotionExclusionPayload>
          }
          update: {
            args: Prisma.PromotionExclusionUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PromotionExclusionPayload>
          }
          deleteMany: {
            args: Prisma.PromotionExclusionDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.PromotionExclusionUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.PromotionExclusionUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$PromotionExclusionPayload>
          }
          aggregate: {
            args: Prisma.PromotionExclusionAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregatePromotionExclusion>
          }
          groupBy: {
            args: Prisma.PromotionExclusionGroupByArgs<ExtArgs>
            result: $Utils.Optional<PromotionExclusionGroupByOutputType>[]
          }
          count: {
            args: Prisma.PromotionExclusionCountArgs<ExtArgs>
            result: $Utils.Optional<PromotionExclusionCountAggregateOutputType> | number
          }
        }
      }
      BranchAllocation: {
        payload: Prisma.$BranchAllocationPayload<ExtArgs>
        fields: Prisma.BranchAllocationFieldRefs
        operations: {
          findUnique: {
            args: Prisma.BranchAllocationFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchAllocationPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.BranchAllocationFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchAllocationPayload>
          }
          findFirst: {
            args: Prisma.BranchAllocationFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchAllocationPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.BranchAllocationFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchAllocationPayload>
          }
          findMany: {
            args: Prisma.BranchAllocationFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchAllocationPayload>[]
          }
          create: {
            args: Prisma.BranchAllocationCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchAllocationPayload>
          }
          createMany: {
            args: Prisma.BranchAllocationCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.BranchAllocationCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchAllocationPayload>[]
          }
          delete: {
            args: Prisma.BranchAllocationDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchAllocationPayload>
          }
          update: {
            args: Prisma.BranchAllocationUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchAllocationPayload>
          }
          deleteMany: {
            args: Prisma.BranchAllocationDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.BranchAllocationUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.BranchAllocationUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchAllocationPayload>
          }
          aggregate: {
            args: Prisma.BranchAllocationAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateBranchAllocation>
          }
          groupBy: {
            args: Prisma.BranchAllocationGroupByArgs<ExtArgs>
            result: $Utils.Optional<BranchAllocationGroupByOutputType>[]
          }
          count: {
            args: Prisma.BranchAllocationCountArgs<ExtArgs>
            result: $Utils.Optional<BranchAllocationCountAggregateOutputType> | number
          }
        }
      }
      BranchAllocationItem: {
        payload: Prisma.$BranchAllocationItemPayload<ExtArgs>
        fields: Prisma.BranchAllocationItemFieldRefs
        operations: {
          findUnique: {
            args: Prisma.BranchAllocationItemFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchAllocationItemPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.BranchAllocationItemFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchAllocationItemPayload>
          }
          findFirst: {
            args: Prisma.BranchAllocationItemFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchAllocationItemPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.BranchAllocationItemFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchAllocationItemPayload>
          }
          findMany: {
            args: Prisma.BranchAllocationItemFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchAllocationItemPayload>[]
          }
          create: {
            args: Prisma.BranchAllocationItemCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchAllocationItemPayload>
          }
          createMany: {
            args: Prisma.BranchAllocationItemCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.BranchAllocationItemCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchAllocationItemPayload>[]
          }
          delete: {
            args: Prisma.BranchAllocationItemDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchAllocationItemPayload>
          }
          update: {
            args: Prisma.BranchAllocationItemUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchAllocationItemPayload>
          }
          deleteMany: {
            args: Prisma.BranchAllocationItemDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.BranchAllocationItemUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.BranchAllocationItemUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$BranchAllocationItemPayload>
          }
          aggregate: {
            args: Prisma.BranchAllocationItemAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateBranchAllocationItem>
          }
          groupBy: {
            args: Prisma.BranchAllocationItemGroupByArgs<ExtArgs>
            result: $Utils.Optional<BranchAllocationItemGroupByOutputType>[]
          }
          count: {
            args: Prisma.BranchAllocationItemCountArgs<ExtArgs>
            result: $Utils.Optional<BranchAllocationItemCountAggregateOutputType> | number
          }
        }
      }
      SmsMessage: {
        payload: Prisma.$SmsMessagePayload<ExtArgs>
        fields: Prisma.SmsMessageFieldRefs
        operations: {
          findUnique: {
            args: Prisma.SmsMessageFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SmsMessagePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.SmsMessageFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SmsMessagePayload>
          }
          findFirst: {
            args: Prisma.SmsMessageFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SmsMessagePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.SmsMessageFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SmsMessagePayload>
          }
          findMany: {
            args: Prisma.SmsMessageFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SmsMessagePayload>[]
          }
          create: {
            args: Prisma.SmsMessageCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SmsMessagePayload>
          }
          createMany: {
            args: Prisma.SmsMessageCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.SmsMessageCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SmsMessagePayload>[]
          }
          delete: {
            args: Prisma.SmsMessageDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SmsMessagePayload>
          }
          update: {
            args: Prisma.SmsMessageUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SmsMessagePayload>
          }
          deleteMany: {
            args: Prisma.SmsMessageDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.SmsMessageUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.SmsMessageUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$SmsMessagePayload>
          }
          aggregate: {
            args: Prisma.SmsMessageAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateSmsMessage>
          }
          groupBy: {
            args: Prisma.SmsMessageGroupByArgs<ExtArgs>
            result: $Utils.Optional<SmsMessageGroupByOutputType>[]
          }
          count: {
            args: Prisma.SmsMessageCountArgs<ExtArgs>
            result: $Utils.Optional<SmsMessageCountAggregateOutputType> | number
          }
        }
      }
      Notification: {
        payload: Prisma.$NotificationPayload<ExtArgs>
        fields: Prisma.NotificationFieldRefs
        operations: {
          findUnique: {
            args: Prisma.NotificationFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.NotificationFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>
          }
          findFirst: {
            args: Prisma.NotificationFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.NotificationFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>
          }
          findMany: {
            args: Prisma.NotificationFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>[]
          }
          create: {
            args: Prisma.NotificationCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>
          }
          createMany: {
            args: Prisma.NotificationCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.NotificationCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>[]
          }
          delete: {
            args: Prisma.NotificationDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>
          }
          update: {
            args: Prisma.NotificationUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>
          }
          deleteMany: {
            args: Prisma.NotificationDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.NotificationUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.NotificationUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationPayload>
          }
          aggregate: {
            args: Prisma.NotificationAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateNotification>
          }
          groupBy: {
            args: Prisma.NotificationGroupByArgs<ExtArgs>
            result: $Utils.Optional<NotificationGroupByOutputType>[]
          }
          count: {
            args: Prisma.NotificationCountArgs<ExtArgs>
            result: $Utils.Optional<NotificationCountAggregateOutputType> | number
          }
        }
      }
      NotificationRecipient: {
        payload: Prisma.$NotificationRecipientPayload<ExtArgs>
        fields: Prisma.NotificationRecipientFieldRefs
        operations: {
          findUnique: {
            args: Prisma.NotificationRecipientFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationRecipientPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.NotificationRecipientFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationRecipientPayload>
          }
          findFirst: {
            args: Prisma.NotificationRecipientFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationRecipientPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.NotificationRecipientFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationRecipientPayload>
          }
          findMany: {
            args: Prisma.NotificationRecipientFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationRecipientPayload>[]
          }
          create: {
            args: Prisma.NotificationRecipientCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationRecipientPayload>
          }
          createMany: {
            args: Prisma.NotificationRecipientCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.NotificationRecipientCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationRecipientPayload>[]
          }
          delete: {
            args: Prisma.NotificationRecipientDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationRecipientPayload>
          }
          update: {
            args: Prisma.NotificationRecipientUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationRecipientPayload>
          }
          deleteMany: {
            args: Prisma.NotificationRecipientDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.NotificationRecipientUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.NotificationRecipientUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NotificationRecipientPayload>
          }
          aggregate: {
            args: Prisma.NotificationRecipientAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateNotificationRecipient>
          }
          groupBy: {
            args: Prisma.NotificationRecipientGroupByArgs<ExtArgs>
            result: $Utils.Optional<NotificationRecipientGroupByOutputType>[]
          }
          count: {
            args: Prisma.NotificationRecipientCountArgs<ExtArgs>
            result: $Utils.Optional<NotificationRecipientCountAggregateOutputType> | number
          }
        }
      }
      NewsletterSubscriber: {
        payload: Prisma.$NewsletterSubscriberPayload<ExtArgs>
        fields: Prisma.NewsletterSubscriberFieldRefs
        operations: {
          findUnique: {
            args: Prisma.NewsletterSubscriberFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NewsletterSubscriberPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.NewsletterSubscriberFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NewsletterSubscriberPayload>
          }
          findFirst: {
            args: Prisma.NewsletterSubscriberFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NewsletterSubscriberPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.NewsletterSubscriberFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NewsletterSubscriberPayload>
          }
          findMany: {
            args: Prisma.NewsletterSubscriberFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NewsletterSubscriberPayload>[]
          }
          create: {
            args: Prisma.NewsletterSubscriberCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NewsletterSubscriberPayload>
          }
          createMany: {
            args: Prisma.NewsletterSubscriberCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.NewsletterSubscriberCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NewsletterSubscriberPayload>[]
          }
          delete: {
            args: Prisma.NewsletterSubscriberDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NewsletterSubscriberPayload>
          }
          update: {
            args: Prisma.NewsletterSubscriberUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NewsletterSubscriberPayload>
          }
          deleteMany: {
            args: Prisma.NewsletterSubscriberDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.NewsletterSubscriberUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.NewsletterSubscriberUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$NewsletterSubscriberPayload>
          }
          aggregate: {
            args: Prisma.NewsletterSubscriberAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateNewsletterSubscriber>
          }
          groupBy: {
            args: Prisma.NewsletterSubscriberGroupByArgs<ExtArgs>
            result: $Utils.Optional<NewsletterSubscriberGroupByOutputType>[]
          }
          count: {
            args: Prisma.NewsletterSubscriberCountArgs<ExtArgs>
            result: $Utils.Optional<NewsletterSubscriberCountAggregateOutputType> | number
          }
        }
      }
      CustomerActivityLog: {
        payload: Prisma.$CustomerActivityLogPayload<ExtArgs>
        fields: Prisma.CustomerActivityLogFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CustomerActivityLogFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerActivityLogPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CustomerActivityLogFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerActivityLogPayload>
          }
          findFirst: {
            args: Prisma.CustomerActivityLogFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerActivityLogPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CustomerActivityLogFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerActivityLogPayload>
          }
          findMany: {
            args: Prisma.CustomerActivityLogFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerActivityLogPayload>[]
          }
          create: {
            args: Prisma.CustomerActivityLogCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerActivityLogPayload>
          }
          createMany: {
            args: Prisma.CustomerActivityLogCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.CustomerActivityLogCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerActivityLogPayload>[]
          }
          delete: {
            args: Prisma.CustomerActivityLogDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerActivityLogPayload>
          }
          update: {
            args: Prisma.CustomerActivityLogUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerActivityLogPayload>
          }
          deleteMany: {
            args: Prisma.CustomerActivityLogDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.CustomerActivityLogUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.CustomerActivityLogUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerActivityLogPayload>
          }
          aggregate: {
            args: Prisma.CustomerActivityLogAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCustomerActivityLog>
          }
          groupBy: {
            args: Prisma.CustomerActivityLogGroupByArgs<ExtArgs>
            result: $Utils.Optional<CustomerActivityLogGroupByOutputType>[]
          }
          count: {
            args: Prisma.CustomerActivityLogCountArgs<ExtArgs>
            result: $Utils.Optional<CustomerActivityLogCountAggregateOutputType> | number
          }
        }
      }
      UploadedFile: {
        payload: Prisma.$UploadedFilePayload<ExtArgs>
        fields: Prisma.UploadedFileFieldRefs
        operations: {
          findUnique: {
            args: Prisma.UploadedFileFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UploadedFilePayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.UploadedFileFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UploadedFilePayload>
          }
          findFirst: {
            args: Prisma.UploadedFileFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UploadedFilePayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.UploadedFileFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UploadedFilePayload>
          }
          findMany: {
            args: Prisma.UploadedFileFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UploadedFilePayload>[]
          }
          create: {
            args: Prisma.UploadedFileCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UploadedFilePayload>
          }
          createMany: {
            args: Prisma.UploadedFileCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.UploadedFileCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UploadedFilePayload>[]
          }
          delete: {
            args: Prisma.UploadedFileDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UploadedFilePayload>
          }
          update: {
            args: Prisma.UploadedFileUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UploadedFilePayload>
          }
          deleteMany: {
            args: Prisma.UploadedFileDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.UploadedFileUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.UploadedFileUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$UploadedFilePayload>
          }
          aggregate: {
            args: Prisma.UploadedFileAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateUploadedFile>
          }
          groupBy: {
            args: Prisma.UploadedFileGroupByArgs<ExtArgs>
            result: $Utils.Optional<UploadedFileGroupByOutputType>[]
          }
          count: {
            args: Prisma.UploadedFileCountArgs<ExtArgs>
            result: $Utils.Optional<UploadedFileCountAggregateOutputType> | number
          }
        }
      }
      CustomerOtp: {
        payload: Prisma.$CustomerOtpPayload<ExtArgs>
        fields: Prisma.CustomerOtpFieldRefs
        operations: {
          findUnique: {
            args: Prisma.CustomerOtpFindUniqueArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerOtpPayload> | null
          }
          findUniqueOrThrow: {
            args: Prisma.CustomerOtpFindUniqueOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerOtpPayload>
          }
          findFirst: {
            args: Prisma.CustomerOtpFindFirstArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerOtpPayload> | null
          }
          findFirstOrThrow: {
            args: Prisma.CustomerOtpFindFirstOrThrowArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerOtpPayload>
          }
          findMany: {
            args: Prisma.CustomerOtpFindManyArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerOtpPayload>[]
          }
          create: {
            args: Prisma.CustomerOtpCreateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerOtpPayload>
          }
          createMany: {
            args: Prisma.CustomerOtpCreateManyArgs<ExtArgs>
            result: BatchPayload
          }
          createManyAndReturn: {
            args: Prisma.CustomerOtpCreateManyAndReturnArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerOtpPayload>[]
          }
          delete: {
            args: Prisma.CustomerOtpDeleteArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerOtpPayload>
          }
          update: {
            args: Prisma.CustomerOtpUpdateArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerOtpPayload>
          }
          deleteMany: {
            args: Prisma.CustomerOtpDeleteManyArgs<ExtArgs>
            result: BatchPayload
          }
          updateMany: {
            args: Prisma.CustomerOtpUpdateManyArgs<ExtArgs>
            result: BatchPayload
          }
          upsert: {
            args: Prisma.CustomerOtpUpsertArgs<ExtArgs>
            result: $Utils.PayloadToResult<Prisma.$CustomerOtpPayload>
          }
          aggregate: {
            args: Prisma.CustomerOtpAggregateArgs<ExtArgs>
            result: $Utils.Optional<AggregateCustomerOtp>
          }
          groupBy: {
            args: Prisma.CustomerOtpGroupByArgs<ExtArgs>
            result: $Utils.Optional<CustomerOtpGroupByOutputType>[]
          }
          count: {
            args: Prisma.CustomerOtpCountArgs<ExtArgs>
            result: $Utils.Optional<CustomerOtpCountAggregateOutputType> | 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 CityCountOutputType
   */

  export type CityCountOutputType = {
    customers: number
    addresses: number
    branches: number
    preOrders: number
    salesExpertProfiles: number
  }

  export type CityCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    customers?: boolean | CityCountOutputTypeCountCustomersArgs
    addresses?: boolean | CityCountOutputTypeCountAddressesArgs
    branches?: boolean | CityCountOutputTypeCountBranchesArgs
    preOrders?: boolean | CityCountOutputTypeCountPreOrdersArgs
    salesExpertProfiles?: boolean | CityCountOutputTypeCountSalesExpertProfilesArgs
  }

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

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

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

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

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

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


  /**
   * Count Type AdminUserCountOutputType
   */

  export type AdminUserCountOutputType = {
    referredCustomers: number
    supervisedWorkshops: number
    branchAllocations: number
    postedLedgerEntries: number
    orderStatusEvents: number
    preOrderStatusEvents: number
    sentSmsMessages: number
    sentNotifications: number
    uploadedFiles: number
    sessions: number
  }

  export type AdminUserCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    referredCustomers?: boolean | AdminUserCountOutputTypeCountReferredCustomersArgs
    supervisedWorkshops?: boolean | AdminUserCountOutputTypeCountSupervisedWorkshopsArgs
    branchAllocations?: boolean | AdminUserCountOutputTypeCountBranchAllocationsArgs
    postedLedgerEntries?: boolean | AdminUserCountOutputTypeCountPostedLedgerEntriesArgs
    orderStatusEvents?: boolean | AdminUserCountOutputTypeCountOrderStatusEventsArgs
    preOrderStatusEvents?: boolean | AdminUserCountOutputTypeCountPreOrderStatusEventsArgs
    sentSmsMessages?: boolean | AdminUserCountOutputTypeCountSentSmsMessagesArgs
    sentNotifications?: boolean | AdminUserCountOutputTypeCountSentNotificationsArgs
    uploadedFiles?: boolean | AdminUserCountOutputTypeCountUploadedFilesArgs
    sessions?: boolean | AdminUserCountOutputTypeCountSessionsArgs
  }

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

  /**
   * AdminUserCountOutputType without action
   */
  export type AdminUserCountOutputTypeCountReferredCustomersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CustomerWhereInput
  }

  /**
   * AdminUserCountOutputType without action
   */
  export type AdminUserCountOutputTypeCountSupervisedWorkshopsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: WorkshopWhereInput
  }

  /**
   * AdminUserCountOutputType without action
   */
  export type AdminUserCountOutputTypeCountBranchAllocationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: BranchAllocationWhereInput
  }

  /**
   * AdminUserCountOutputType without action
   */
  export type AdminUserCountOutputTypeCountPostedLedgerEntriesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: LedgerEntryWhereInput
  }

  /**
   * AdminUserCountOutputType without action
   */
  export type AdminUserCountOutputTypeCountOrderStatusEventsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: OrderStatusEventWhereInput
  }

  /**
   * AdminUserCountOutputType without action
   */
  export type AdminUserCountOutputTypeCountPreOrderStatusEventsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PreOrderStatusEventWhereInput
  }

  /**
   * AdminUserCountOutputType without action
   */
  export type AdminUserCountOutputTypeCountSentSmsMessagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SmsMessageWhereInput
  }

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

  /**
   * AdminUserCountOutputType without action
   */
  export type AdminUserCountOutputTypeCountUploadedFilesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: UploadedFileWhereInput
  }

  /**
   * AdminUserCountOutputType without action
   */
  export type AdminUserCountOutputTypeCountSessionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AdminSessionWhereInput
  }


  /**
   * Count Type CustomerCountOutputType
   */

  export type CustomerCountOutputType = {
    addresses: number
    orders: number
    preOrders: number
    ledgerEntries: number
    walletBonuses: number
    comments: number
    promotions: number
    notifications: number
    activityLogs: number
    otpChallenges: number
  }

  export type CustomerCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    addresses?: boolean | CustomerCountOutputTypeCountAddressesArgs
    orders?: boolean | CustomerCountOutputTypeCountOrdersArgs
    preOrders?: boolean | CustomerCountOutputTypeCountPreOrdersArgs
    ledgerEntries?: boolean | CustomerCountOutputTypeCountLedgerEntriesArgs
    walletBonuses?: boolean | CustomerCountOutputTypeCountWalletBonusesArgs
    comments?: boolean | CustomerCountOutputTypeCountCommentsArgs
    promotions?: boolean | CustomerCountOutputTypeCountPromotionsArgs
    notifications?: boolean | CustomerCountOutputTypeCountNotificationsArgs
    activityLogs?: boolean | CustomerCountOutputTypeCountActivityLogsArgs
    otpChallenges?: boolean | CustomerCountOutputTypeCountOtpChallengesArgs
  }

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

  /**
   * CustomerCountOutputType without action
   */
  export type CustomerCountOutputTypeCountAddressesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CustomerAddressWhereInput
  }

  /**
   * CustomerCountOutputType without action
   */
  export type CustomerCountOutputTypeCountOrdersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: OrderWhereInput
  }

  /**
   * CustomerCountOutputType without action
   */
  export type CustomerCountOutputTypeCountPreOrdersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PreOrderWhereInput
  }

  /**
   * CustomerCountOutputType without action
   */
  export type CustomerCountOutputTypeCountLedgerEntriesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: LedgerEntryWhereInput
  }

  /**
   * CustomerCountOutputType without action
   */
  export type CustomerCountOutputTypeCountWalletBonusesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: WalletBonusWhereInput
  }

  /**
   * CustomerCountOutputType without action
   */
  export type CustomerCountOutputTypeCountCommentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CommentWhereInput
  }

  /**
   * CustomerCountOutputType without action
   */
  export type CustomerCountOutputTypeCountPromotionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PromotionWhereInput
  }

  /**
   * CustomerCountOutputType without action
   */
  export type CustomerCountOutputTypeCountNotificationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: NotificationRecipientWhereInput
  }

  /**
   * CustomerCountOutputType without action
   */
  export type CustomerCountOutputTypeCountActivityLogsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CustomerActivityLogWhereInput
  }

  /**
   * CustomerCountOutputType without action
   */
  export type CustomerCountOutputTypeCountOtpChallengesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CustomerOtpWhereInput
  }


  /**
   * Count Type BranchCountOutputType
   */

  export type BranchCountOutputType = {
    adminUsers: number
    orders: number
    allocations: number
  }

  export type BranchCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    adminUsers?: boolean | BranchCountOutputTypeCountAdminUsersArgs
    orders?: boolean | BranchCountOutputTypeCountOrdersArgs
    allocations?: boolean | BranchCountOutputTypeCountAllocationsArgs
  }

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

  /**
   * BranchCountOutputType without action
   */
  export type BranchCountOutputTypeCountAdminUsersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AdminUserWhereInput
  }

  /**
   * BranchCountOutputType without action
   */
  export type BranchCountOutputTypeCountOrdersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: OrderWhereInput
  }

  /**
   * BranchCountOutputType without action
   */
  export type BranchCountOutputTypeCountAllocationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: BranchAllocationWhereInput
  }


  /**
   * Count Type WorkshopCountOutputType
   */

  export type WorkshopCountOutputType = {
    preOrders: number
  }

  export type WorkshopCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    preOrders?: boolean | WorkshopCountOutputTypeCountPreOrdersArgs
  }

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

  /**
   * WorkshopCountOutputType without action
   */
  export type WorkshopCountOutputTypeCountPreOrdersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PreOrderWhereInput
  }


  /**
   * Count Type CategoryCountOutputType
   */

  export type CategoryCountOutputType = {
    children: number
    products: number
    promotions: number
  }

  export type CategoryCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    children?: boolean | CategoryCountOutputTypeCountChildrenArgs
    products?: boolean | CategoryCountOutputTypeCountProductsArgs
    promotions?: boolean | CategoryCountOutputTypeCountPromotionsArgs
  }

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

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

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


  /**
   * Count Type BrandCountOutputType
   */

  export type BrandCountOutputType = {
    products: number
    promotions: number
  }

  export type BrandCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    products?: boolean | BrandCountOutputTypeCountProductsArgs
    promotions?: boolean | BrandCountOutputTypeCountPromotionsArgs
  }

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

  /**
   * BrandCountOutputType without action
   */
  export type BrandCountOutputTypeCountProductsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ProductWhereInput
  }

  /**
   * BrandCountOutputType without action
   */
  export type BrandCountOutputTypeCountPromotionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PromotionWhereInput
  }


  /**
   * Count Type CollectionCountOutputType
   */

  export type CollectionCountOutputType = {
    products: number
  }

  export type CollectionCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    products?: boolean | CollectionCountOutputTypeCountProductsArgs
  }

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

  /**
   * CollectionCountOutputType without action
   */
  export type CollectionCountOutputTypeCountProductsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CollectionProductWhereInput
  }


  /**
   * Count Type ProductCountOutputType
   */

  export type ProductCountOutputType = {
    variants: number
    images: number
    collections: number
    comments: number
    promotions: number
    allocationItems: number
  }

  export type ProductCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    variants?: boolean | ProductCountOutputTypeCountVariantsArgs
    images?: boolean | ProductCountOutputTypeCountImagesArgs
    collections?: boolean | ProductCountOutputTypeCountCollectionsArgs
    comments?: boolean | ProductCountOutputTypeCountCommentsArgs
    promotions?: boolean | ProductCountOutputTypeCountPromotionsArgs
    allocationItems?: boolean | ProductCountOutputTypeCountAllocationItemsArgs
  }

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

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

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

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

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

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


  /**
   * Count Type ProductImageCountOutputType
   */

  export type ProductImageCountOutputType = {
    variants: number
  }

  export type ProductImageCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    variants?: boolean | ProductImageCountOutputTypeCountVariantsArgs
  }

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

  /**
   * ProductImageCountOutputType without action
   */
  export type ProductImageCountOutputTypeCountVariantsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ProductVariantWhereInput
  }


  /**
   * Count Type ProductVariantCountOutputType
   */

  export type ProductVariantCountOutputType = {
    orderItems: number
  }

  export type ProductVariantCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    orderItems?: boolean | ProductVariantCountOutputTypeCountOrderItemsArgs
  }

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

  /**
   * ProductVariantCountOutputType without action
   */
  export type ProductVariantCountOutputTypeCountOrderItemsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: OrderItemWhereInput
  }


  /**
   * Count Type OrderCountOutputType
   */

  export type OrderCountOutputType = {
    items: number
    statusEvents: number
    ledgerEntries: number
  }

  export type OrderCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    items?: boolean | OrderCountOutputTypeCountItemsArgs
    statusEvents?: boolean | OrderCountOutputTypeCountStatusEventsArgs
    ledgerEntries?: boolean | OrderCountOutputTypeCountLedgerEntriesArgs
  }

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

  /**
   * OrderCountOutputType without action
   */
  export type OrderCountOutputTypeCountItemsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: OrderItemWhereInput
  }

  /**
   * OrderCountOutputType without action
   */
  export type OrderCountOutputTypeCountStatusEventsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: OrderStatusEventWhereInput
  }

  /**
   * OrderCountOutputType without action
   */
  export type OrderCountOutputTypeCountLedgerEntriesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: LedgerEntryWhereInput
  }


  /**
   * Count Type PreOrderCountOutputType
   */

  export type PreOrderCountOutputType = {
    statusEvents: number
  }

  export type PreOrderCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    statusEvents?: boolean | PreOrderCountOutputTypeCountStatusEventsArgs
  }

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

  /**
   * PreOrderCountOutputType without action
   */
  export type PreOrderCountOutputTypeCountStatusEventsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PreOrderStatusEventWhereInput
  }


  /**
   * Count Type UserTypeCountOutputType
   */

  export type UserTypeCountOutputType = {
    permissions: number
    adminUsers: number
  }

  export type UserTypeCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    permissions?: boolean | UserTypeCountOutputTypeCountPermissionsArgs
    adminUsers?: boolean | UserTypeCountOutputTypeCountAdminUsersArgs
  }

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

  /**
   * UserTypeCountOutputType without action
   */
  export type UserTypeCountOutputTypeCountPermissionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PermissionWhereInput
  }

  /**
   * UserTypeCountOutputType without action
   */
  export type UserTypeCountOutputTypeCountAdminUsersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AdminUserWhereInput
  }


  /**
   * Count Type CommentCountOutputType
   */

  export type CommentCountOutputType = {
    replies: number
  }

  export type CommentCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    replies?: boolean | CommentCountOutputTypeCountRepliesArgs
  }

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

  /**
   * CommentCountOutputType without action
   */
  export type CommentCountOutputTypeCountRepliesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CommentWhereInput
  }


  /**
   * Count Type BranchAllocationCountOutputType
   */

  export type BranchAllocationCountOutputType = {
    items: number
  }

  export type BranchAllocationCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    items?: boolean | BranchAllocationCountOutputTypeCountItemsArgs
  }

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

  /**
   * BranchAllocationCountOutputType without action
   */
  export type BranchAllocationCountOutputTypeCountItemsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: BranchAllocationItemWhereInput
  }


  /**
   * Count Type NotificationCountOutputType
   */

  export type NotificationCountOutputType = {
    recipients: number
  }

  export type NotificationCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    recipients?: boolean | NotificationCountOutputTypeCountRecipientsArgs
  }

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

  /**
   * NotificationCountOutputType without action
   */
  export type NotificationCountOutputTypeCountRecipientsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: NotificationRecipientWhereInput
  }


  /**
   * Count Type UploadedFileCountOutputType
   */

  export type UploadedFileCountOutputType = {
    customerAvatars: number
    adminUserAvatars: number
  }

  export type UploadedFileCountOutputTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    customerAvatars?: boolean | UploadedFileCountOutputTypeCountCustomerAvatarsArgs
    adminUserAvatars?: boolean | UploadedFileCountOutputTypeCountAdminUserAvatarsArgs
  }

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

  /**
   * UploadedFileCountOutputType without action
   */
  export type UploadedFileCountOutputTypeCountCustomerAvatarsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CustomerWhereInput
  }

  /**
   * UploadedFileCountOutputType without action
   */
  export type UploadedFileCountOutputTypeCountAdminUserAvatarsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AdminUserWhereInput
  }


  /**
   * Models
   */

  /**
   * Model City
   */

  export type AggregateCity = {
    _count: CityCountAggregateOutputType | null
    _avg: CityAvgAggregateOutputType | null
    _sum: CitySumAggregateOutputType | null
    _min: CityMinAggregateOutputType | null
    _max: CityMaxAggregateOutputType | null
  }

  export type CityAvgAggregateOutputType = {
    percent: Decimal | null
    percentAux: Decimal | null
  }

  export type CitySumAggregateOutputType = {
    percent: Decimal | null
    percentAux: Decimal | null
  }

  export type CityMinAggregateOutputType = {
    id: string | null
    name: string | null
    province: string | null
    percent: Decimal | null
    percentAux: Decimal | null
  }

  export type CityMaxAggregateOutputType = {
    id: string | null
    name: string | null
    province: string | null
    percent: Decimal | null
    percentAux: Decimal | null
  }

  export type CityCountAggregateOutputType = {
    id: number
    name: number
    province: number
    percent: number
    percentAux: number
    _all: number
  }


  export type CityAvgAggregateInputType = {
    percent?: true
    percentAux?: true
  }

  export type CitySumAggregateInputType = {
    percent?: true
    percentAux?: true
  }

  export type CityMinAggregateInputType = {
    id?: true
    name?: true
    province?: true
    percent?: true
    percentAux?: true
  }

  export type CityMaxAggregateInputType = {
    id?: true
    name?: true
    province?: true
    percent?: true
    percentAux?: true
  }

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

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

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




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

  export type CityGroupByOutputType = {
    id: string
    name: string
    province: string | null
    percent: Decimal | null
    percentAux: Decimal | null
    _count: CityCountAggregateOutputType | null
    _avg: CityAvgAggregateOutputType | null
    _sum: CitySumAggregateOutputType | null
    _min: CityMinAggregateOutputType | null
    _max: CityMaxAggregateOutputType | null
  }

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


  export type CitySelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    province?: boolean
    percent?: boolean
    percentAux?: boolean
    customers?: boolean | City$customersArgs<ExtArgs>
    addresses?: boolean | City$addressesArgs<ExtArgs>
    branches?: boolean | City$branchesArgs<ExtArgs>
    preOrders?: boolean | City$preOrdersArgs<ExtArgs>
    salesExpertProfiles?: boolean | City$salesExpertProfilesArgs<ExtArgs>
    _count?: boolean | CityCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["city"]>

  export type CitySelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    province?: boolean
    percent?: boolean
    percentAux?: boolean
  }, ExtArgs["result"]["city"]>

  export type CitySelectScalar = {
    id?: boolean
    name?: boolean
    province?: boolean
    percent?: boolean
    percentAux?: boolean
  }

  export type CityInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    customers?: boolean | City$customersArgs<ExtArgs>
    addresses?: boolean | City$addressesArgs<ExtArgs>
    branches?: boolean | City$branchesArgs<ExtArgs>
    preOrders?: boolean | City$preOrdersArgs<ExtArgs>
    salesExpertProfiles?: boolean | City$salesExpertProfilesArgs<ExtArgs>
    _count?: boolean | CityCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type CityIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}

  export type $CityPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "City"
    objects: {
      customers: Prisma.$CustomerPayload<ExtArgs>[]
      addresses: Prisma.$CustomerAddressPayload<ExtArgs>[]
      branches: Prisma.$BranchPayload<ExtArgs>[]
      preOrders: Prisma.$PreOrderPayload<ExtArgs>[]
      salesExpertProfiles: Prisma.$SalesExpertProfilePayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      province: string | null
      /**
       * Legacy cities.percent / percent_aux — per-city wage surcharges the city
       * screen edits through GET cities/get-percent/{id} and get-percent-aux/{id}.
       */
      percent: Prisma.Decimal | null
      percentAux: Prisma.Decimal | null
    }, ExtArgs["result"]["city"]>
    composites: {}
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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




  /**
   * Fields of the City model
   */ 
  interface CityFieldRefs {
    readonly id: FieldRef<"City", 'String'>
    readonly name: FieldRef<"City", 'String'>
    readonly province: FieldRef<"City", 'String'>
    readonly percent: FieldRef<"City", 'Decimal'>
    readonly percentAux: FieldRef<"City", 'Decimal'>
  }
    

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

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

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

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

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

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

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

  /**
   * City createManyAndReturn
   */
  export type CityCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the City
     */
    select?: CitySelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Cities.
     */
    data: CityCreateManyInput | CityCreateManyInput[]
    skipDuplicates?: boolean
  }

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

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

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

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

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

  /**
   * City.customers
   */
  export type City$customersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Customer
     */
    select?: CustomerSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerInclude<ExtArgs> | null
    where?: CustomerWhereInput
    orderBy?: CustomerOrderByWithRelationInput | CustomerOrderByWithRelationInput[]
    cursor?: CustomerWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CustomerScalarFieldEnum | CustomerScalarFieldEnum[]
  }

  /**
   * City.addresses
   */
  export type City$addressesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerAddress
     */
    select?: CustomerAddressSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerAddressInclude<ExtArgs> | null
    where?: CustomerAddressWhereInput
    orderBy?: CustomerAddressOrderByWithRelationInput | CustomerAddressOrderByWithRelationInput[]
    cursor?: CustomerAddressWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CustomerAddressScalarFieldEnum | CustomerAddressScalarFieldEnum[]
  }

  /**
   * City.branches
   */
  export type City$branchesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Branch
     */
    select?: BranchSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchInclude<ExtArgs> | null
    where?: BranchWhereInput
    orderBy?: BranchOrderByWithRelationInput | BranchOrderByWithRelationInput[]
    cursor?: BranchWhereUniqueInput
    take?: number
    skip?: number
    distinct?: BranchScalarFieldEnum | BranchScalarFieldEnum[]
  }

  /**
   * City.preOrders
   */
  export type City$preOrdersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PreOrder
     */
    select?: PreOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PreOrderInclude<ExtArgs> | null
    where?: PreOrderWhereInput
    orderBy?: PreOrderOrderByWithRelationInput | PreOrderOrderByWithRelationInput[]
    cursor?: PreOrderWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PreOrderScalarFieldEnum | PreOrderScalarFieldEnum[]
  }

  /**
   * City.salesExpertProfiles
   */
  export type City$salesExpertProfilesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SalesExpertProfile
     */
    select?: SalesExpertProfileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SalesExpertProfileInclude<ExtArgs> | null
    where?: SalesExpertProfileWhereInput
    orderBy?: SalesExpertProfileOrderByWithRelationInput | SalesExpertProfileOrderByWithRelationInput[]
    cursor?: SalesExpertProfileWhereUniqueInput
    take?: number
    skip?: number
    distinct?: SalesExpertProfileScalarFieldEnum | SalesExpertProfileScalarFieldEnum[]
  }

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


  /**
   * Model AdminUser
   */

  export type AggregateAdminUser = {
    _count: AdminUserCountAggregateOutputType | null
    _avg: AdminUserAvgAggregateOutputType | null
    _sum: AdminUserSumAggregateOutputType | null
    _min: AdminUserMinAggregateOutputType | null
    _max: AdminUserMaxAggregateOutputType | null
  }

  export type AdminUserAvgAggregateOutputType = {
    userTypeId: number | null
    wagePercent: Decimal | null
  }

  export type AdminUserSumAggregateOutputType = {
    userTypeId: number | null
    wagePercent: Decimal | null
  }

  export type AdminUserMinAggregateOutputType = {
    id: string | null
    fullName: string | null
    firstName: string | null
    lastName: string | null
    mobile: string | null
    passwordHash: string | null
    role: $Enums.AdminRole | null
    userTypeId: number | null
    branchId: string | null
    wagePercent: Decimal | null
    isActive: boolean | null
    createdAt: Date | null
    avatarFileId: string | null
    address: string | null
    storeName: string | null
    pasazhName: string | null
    memberCode: string | null
  }

  export type AdminUserMaxAggregateOutputType = {
    id: string | null
    fullName: string | null
    firstName: string | null
    lastName: string | null
    mobile: string | null
    passwordHash: string | null
    role: $Enums.AdminRole | null
    userTypeId: number | null
    branchId: string | null
    wagePercent: Decimal | null
    isActive: boolean | null
    createdAt: Date | null
    avatarFileId: string | null
    address: string | null
    storeName: string | null
    pasazhName: string | null
    memberCode: string | null
  }

  export type AdminUserCountAggregateOutputType = {
    id: number
    fullName: number
    firstName: number
    lastName: number
    mobile: number
    passwordHash: number
    role: number
    userTypeId: number
    branchId: number
    wagePercent: number
    isActive: number
    createdAt: number
    avatarFileId: number
    address: number
    storeName: number
    pasazhName: number
    memberCode: number
    _all: number
  }


  export type AdminUserAvgAggregateInputType = {
    userTypeId?: true
    wagePercent?: true
  }

  export type AdminUserSumAggregateInputType = {
    userTypeId?: true
    wagePercent?: true
  }

  export type AdminUserMinAggregateInputType = {
    id?: true
    fullName?: true
    firstName?: true
    lastName?: true
    mobile?: true
    passwordHash?: true
    role?: true
    userTypeId?: true
    branchId?: true
    wagePercent?: true
    isActive?: true
    createdAt?: true
    avatarFileId?: true
    address?: true
    storeName?: true
    pasazhName?: true
    memberCode?: true
  }

  export type AdminUserMaxAggregateInputType = {
    id?: true
    fullName?: true
    firstName?: true
    lastName?: true
    mobile?: true
    passwordHash?: true
    role?: true
    userTypeId?: true
    branchId?: true
    wagePercent?: true
    isActive?: true
    createdAt?: true
    avatarFileId?: true
    address?: true
    storeName?: true
    pasazhName?: true
    memberCode?: true
  }

  export type AdminUserCountAggregateInputType = {
    id?: true
    fullName?: true
    firstName?: true
    lastName?: true
    mobile?: true
    passwordHash?: true
    role?: true
    userTypeId?: true
    branchId?: true
    wagePercent?: true
    isActive?: true
    createdAt?: true
    avatarFileId?: true
    address?: true
    storeName?: true
    pasazhName?: true
    memberCode?: true
    _all?: true
  }

  export type AdminUserAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which AdminUser to aggregate.
     */
    where?: AdminUserWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of AdminUsers to fetch.
     */
    orderBy?: AdminUserOrderByWithRelationInput | AdminUserOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: AdminUserWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` AdminUsers from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` AdminUsers.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned AdminUsers
    **/
    _count?: true | AdminUserCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: AdminUserAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: AdminUserSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: AdminUserMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: AdminUserMaxAggregateInputType
  }

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




  export type AdminUserGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AdminUserWhereInput
    orderBy?: AdminUserOrderByWithAggregationInput | AdminUserOrderByWithAggregationInput[]
    by: AdminUserScalarFieldEnum[] | AdminUserScalarFieldEnum
    having?: AdminUserScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AdminUserCountAggregateInputType | true
    _avg?: AdminUserAvgAggregateInputType
    _sum?: AdminUserSumAggregateInputType
    _min?: AdminUserMinAggregateInputType
    _max?: AdminUserMaxAggregateInputType
  }

  export type AdminUserGroupByOutputType = {
    id: string
    fullName: string
    firstName: string | null
    lastName: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    userTypeId: number | null
    branchId: string | null
    wagePercent: Decimal | null
    isActive: boolean
    createdAt: Date
    avatarFileId: string | null
    address: string | null
    storeName: string | null
    pasazhName: string | null
    memberCode: string | null
    _count: AdminUserCountAggregateOutputType | null
    _avg: AdminUserAvgAggregateOutputType | null
    _sum: AdminUserSumAggregateOutputType | null
    _min: AdminUserMinAggregateOutputType | null
    _max: AdminUserMaxAggregateOutputType | null
  }

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


  export type AdminUserSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    fullName?: boolean
    firstName?: boolean
    lastName?: boolean
    mobile?: boolean
    passwordHash?: boolean
    role?: boolean
    userTypeId?: boolean
    branchId?: boolean
    wagePercent?: boolean
    isActive?: boolean
    createdAt?: boolean
    avatarFileId?: boolean
    address?: boolean
    storeName?: boolean
    pasazhName?: boolean
    memberCode?: boolean
    userType?: boolean | AdminUser$userTypeArgs<ExtArgs>
    branch?: boolean | AdminUser$branchArgs<ExtArgs>
    avatarFile?: boolean | AdminUser$avatarFileArgs<ExtArgs>
    referredCustomers?: boolean | AdminUser$referredCustomersArgs<ExtArgs>
    supervisedWorkshops?: boolean | AdminUser$supervisedWorkshopsArgs<ExtArgs>
    branchAllocations?: boolean | AdminUser$branchAllocationsArgs<ExtArgs>
    postedLedgerEntries?: boolean | AdminUser$postedLedgerEntriesArgs<ExtArgs>
    orderStatusEvents?: boolean | AdminUser$orderStatusEventsArgs<ExtArgs>
    preOrderStatusEvents?: boolean | AdminUser$preOrderStatusEventsArgs<ExtArgs>
    sentSmsMessages?: boolean | AdminUser$sentSmsMessagesArgs<ExtArgs>
    sentNotifications?: boolean | AdminUser$sentNotificationsArgs<ExtArgs>
    uploadedFiles?: boolean | AdminUser$uploadedFilesArgs<ExtArgs>
    salesExpertProfile?: boolean | AdminUser$salesExpertProfileArgs<ExtArgs>
    sessions?: boolean | AdminUser$sessionsArgs<ExtArgs>
    _count?: boolean | AdminUserCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["adminUser"]>

  export type AdminUserSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    fullName?: boolean
    firstName?: boolean
    lastName?: boolean
    mobile?: boolean
    passwordHash?: boolean
    role?: boolean
    userTypeId?: boolean
    branchId?: boolean
    wagePercent?: boolean
    isActive?: boolean
    createdAt?: boolean
    avatarFileId?: boolean
    address?: boolean
    storeName?: boolean
    pasazhName?: boolean
    memberCode?: boolean
    userType?: boolean | AdminUser$userTypeArgs<ExtArgs>
    branch?: boolean | AdminUser$branchArgs<ExtArgs>
    avatarFile?: boolean | AdminUser$avatarFileArgs<ExtArgs>
  }, ExtArgs["result"]["adminUser"]>

  export type AdminUserSelectScalar = {
    id?: boolean
    fullName?: boolean
    firstName?: boolean
    lastName?: boolean
    mobile?: boolean
    passwordHash?: boolean
    role?: boolean
    userTypeId?: boolean
    branchId?: boolean
    wagePercent?: boolean
    isActive?: boolean
    createdAt?: boolean
    avatarFileId?: boolean
    address?: boolean
    storeName?: boolean
    pasazhName?: boolean
    memberCode?: boolean
  }

  export type AdminUserInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    userType?: boolean | AdminUser$userTypeArgs<ExtArgs>
    branch?: boolean | AdminUser$branchArgs<ExtArgs>
    avatarFile?: boolean | AdminUser$avatarFileArgs<ExtArgs>
    referredCustomers?: boolean | AdminUser$referredCustomersArgs<ExtArgs>
    supervisedWorkshops?: boolean | AdminUser$supervisedWorkshopsArgs<ExtArgs>
    branchAllocations?: boolean | AdminUser$branchAllocationsArgs<ExtArgs>
    postedLedgerEntries?: boolean | AdminUser$postedLedgerEntriesArgs<ExtArgs>
    orderStatusEvents?: boolean | AdminUser$orderStatusEventsArgs<ExtArgs>
    preOrderStatusEvents?: boolean | AdminUser$preOrderStatusEventsArgs<ExtArgs>
    sentSmsMessages?: boolean | AdminUser$sentSmsMessagesArgs<ExtArgs>
    sentNotifications?: boolean | AdminUser$sentNotificationsArgs<ExtArgs>
    uploadedFiles?: boolean | AdminUser$uploadedFilesArgs<ExtArgs>
    salesExpertProfile?: boolean | AdminUser$salesExpertProfileArgs<ExtArgs>
    sessions?: boolean | AdminUser$sessionsArgs<ExtArgs>
    _count?: boolean | AdminUserCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type AdminUserIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    userType?: boolean | AdminUser$userTypeArgs<ExtArgs>
    branch?: boolean | AdminUser$branchArgs<ExtArgs>
    avatarFile?: boolean | AdminUser$avatarFileArgs<ExtArgs>
  }

  export type $AdminUserPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "AdminUser"
    objects: {
      userType: Prisma.$UserTypePayload<ExtArgs> | null
      branch: Prisma.$BranchPayload<ExtArgs> | null
      avatarFile: Prisma.$UploadedFilePayload<ExtArgs> | null
      referredCustomers: Prisma.$CustomerPayload<ExtArgs>[]
      supervisedWorkshops: Prisma.$WorkshopPayload<ExtArgs>[]
      branchAllocations: Prisma.$BranchAllocationPayload<ExtArgs>[]
      postedLedgerEntries: Prisma.$LedgerEntryPayload<ExtArgs>[]
      orderStatusEvents: Prisma.$OrderStatusEventPayload<ExtArgs>[]
      preOrderStatusEvents: Prisma.$PreOrderStatusEventPayload<ExtArgs>[]
      sentSmsMessages: Prisma.$SmsMessagePayload<ExtArgs>[]
      sentNotifications: Prisma.$NotificationPayload<ExtArgs>[]
      uploadedFiles: Prisma.$UploadedFilePayload<ExtArgs>[]
      /**
       * Only ever set for role = SALES_EXPERT (D17).
       */
      salesExpertProfile: Prisma.$SalesExpertProfilePayload<ExtArgs> | null
      /**
       * Issued admin-panel tokens, recorded only while session tracking is on
       * (AUTH_SESSION_TRACKING, or implicitly whenever the IAM is enabled) so a
       * token can be revoked before it expires. See AdminSession.
       */
      sessions: Prisma.$AdminSessionPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      /**
       * ⚠️ Kept in sync BY A DATABASE TRIGGER — `admin_user_sync_full_name`, from
       * migration 20260922180000. Prisma cannot see it, so a write here may store
       * something other than what you passed:
       * 
       * * write the parts          -> fullName is rebuilt as "first last"
       * * write fullName only      -> the parts are re-derived from it
       * * write BOTH in one update -> THE PARTS WIN; the submitted fullName is
       * discarded
       * 
       * Re-read after writing if you need the stored value. Same arrangement as
       * Customer (D0 requirement 7 — the split applies to ALL admins, not only
       * sales experts).
       */
      fullName: string
      firstName: string | null
      lastName: string | null
      mobile: string
      passwordHash: string
      role: $Enums.AdminRole
      /**
       * Legacy `users.ut`. Granular ACL lives here (Permission rows hang off UserType);
       * the coarse `role` enum above is retained for the business rules that already
       * switch on it. Nullable so existing seeded admins remain valid.
       */
      userTypeId: number | null
      branchId: string | null
      wagePercent: Prisma.Decimal | null
      isActive: boolean
      createdAt: Date
      /**
       * Legacy stored a sales agent as a `customers` row with type=1, so
       * ReagentCustomer.vue's shared form collected these alongside the
       * wholesale-customer fields. A sales agent is now an AdminUser
       * (role=SALES_EXPERT), so these live here instead — only ever set for that
       * role; every other AdminUser leaves them null.
       */
      avatarFileId: string | null
      address: string | null
      storeName: string | null
      pasazhName: string | null
      memberCode: string | null
    }, ExtArgs["result"]["adminUser"]>
    composites: {}
  }

  type AdminUserGetPayload<S extends boolean | null | undefined | AdminUserDefaultArgs> = $Result.GetResult<Prisma.$AdminUserPayload, S>

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

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

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

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

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

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

    /**
     * Create a AdminUser.
     * @param {AdminUserCreateArgs} args - Arguments to create a AdminUser.
     * @example
     * // Create one AdminUser
     * const AdminUser = await prisma.adminUser.create({
     *   data: {
     *     // ... data to create a AdminUser
     *   }
     * })
     * 
     */
    create<T extends AdminUserCreateArgs>(args: SelectSubset<T, AdminUserCreateArgs<ExtArgs>>): Prisma__AdminUserClient<$Result.GetResult<Prisma.$AdminUserPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a AdminUser.
     * @param {AdminUserDeleteArgs} args - Arguments to delete one AdminUser.
     * @example
     * // Delete one AdminUser
     * const AdminUser = await prisma.adminUser.delete({
     *   where: {
     *     // ... filter to delete one AdminUser
     *   }
     * })
     * 
     */
    delete<T extends AdminUserDeleteArgs>(args: SelectSubset<T, AdminUserDeleteArgs<ExtArgs>>): Prisma__AdminUserClient<$Result.GetResult<Prisma.$AdminUserPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for AdminUser.
   * 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__AdminUserClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    userType<T extends AdminUser$userTypeArgs<ExtArgs> = {}>(args?: Subset<T, AdminUser$userTypeArgs<ExtArgs>>): Prisma__UserTypeClient<$Result.GetResult<Prisma.$UserTypePayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    branch<T extends AdminUser$branchArgs<ExtArgs> = {}>(args?: Subset<T, AdminUser$branchArgs<ExtArgs>>): Prisma__BranchClient<$Result.GetResult<Prisma.$BranchPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    avatarFile<T extends AdminUser$avatarFileArgs<ExtArgs> = {}>(args?: Subset<T, AdminUser$avatarFileArgs<ExtArgs>>): Prisma__UploadedFileClient<$Result.GetResult<Prisma.$UploadedFilePayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    referredCustomers<T extends AdminUser$referredCustomersArgs<ExtArgs> = {}>(args?: Subset<T, AdminUser$referredCustomersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CustomerPayload<ExtArgs>, T, "findMany"> | Null>
    supervisedWorkshops<T extends AdminUser$supervisedWorkshopsArgs<ExtArgs> = {}>(args?: Subset<T, AdminUser$supervisedWorkshopsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$WorkshopPayload<ExtArgs>, T, "findMany"> | Null>
    branchAllocations<T extends AdminUser$branchAllocationsArgs<ExtArgs> = {}>(args?: Subset<T, AdminUser$branchAllocationsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$BranchAllocationPayload<ExtArgs>, T, "findMany"> | Null>
    postedLedgerEntries<T extends AdminUser$postedLedgerEntriesArgs<ExtArgs> = {}>(args?: Subset<T, AdminUser$postedLedgerEntriesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LedgerEntryPayload<ExtArgs>, T, "findMany"> | Null>
    orderStatusEvents<T extends AdminUser$orderStatusEventsArgs<ExtArgs> = {}>(args?: Subset<T, AdminUser$orderStatusEventsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$OrderStatusEventPayload<ExtArgs>, T, "findMany"> | Null>
    preOrderStatusEvents<T extends AdminUser$preOrderStatusEventsArgs<ExtArgs> = {}>(args?: Subset<T, AdminUser$preOrderStatusEventsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PreOrderStatusEventPayload<ExtArgs>, T, "findMany"> | Null>
    sentSmsMessages<T extends AdminUser$sentSmsMessagesArgs<ExtArgs> = {}>(args?: Subset<T, AdminUser$sentSmsMessagesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SmsMessagePayload<ExtArgs>, T, "findMany"> | Null>
    sentNotifications<T extends AdminUser$sentNotificationsArgs<ExtArgs> = {}>(args?: Subset<T, AdminUser$sentNotificationsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, "findMany"> | Null>
    uploadedFiles<T extends AdminUser$uploadedFilesArgs<ExtArgs> = {}>(args?: Subset<T, AdminUser$uploadedFilesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UploadedFilePayload<ExtArgs>, T, "findMany"> | Null>
    salesExpertProfile<T extends AdminUser$salesExpertProfileArgs<ExtArgs> = {}>(args?: Subset<T, AdminUser$salesExpertProfileArgs<ExtArgs>>): Prisma__SalesExpertProfileClient<$Result.GetResult<Prisma.$SalesExpertProfilePayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    sessions<T extends AdminUser$sessionsArgs<ExtArgs> = {}>(args?: Subset<T, AdminUser$sessionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AdminSessionPayload<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 AdminUser model
   */ 
  interface AdminUserFieldRefs {
    readonly id: FieldRef<"AdminUser", 'String'>
    readonly fullName: FieldRef<"AdminUser", 'String'>
    readonly firstName: FieldRef<"AdminUser", 'String'>
    readonly lastName: FieldRef<"AdminUser", 'String'>
    readonly mobile: FieldRef<"AdminUser", 'String'>
    readonly passwordHash: FieldRef<"AdminUser", 'String'>
    readonly role: FieldRef<"AdminUser", 'AdminRole'>
    readonly userTypeId: FieldRef<"AdminUser", 'Int'>
    readonly branchId: FieldRef<"AdminUser", 'String'>
    readonly wagePercent: FieldRef<"AdminUser", 'Decimal'>
    readonly isActive: FieldRef<"AdminUser", 'Boolean'>
    readonly createdAt: FieldRef<"AdminUser", 'DateTime'>
    readonly avatarFileId: FieldRef<"AdminUser", 'String'>
    readonly address: FieldRef<"AdminUser", 'String'>
    readonly storeName: FieldRef<"AdminUser", 'String'>
    readonly pasazhName: FieldRef<"AdminUser", 'String'>
    readonly memberCode: FieldRef<"AdminUser", 'String'>
  }
    

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

  /**
   * AdminUser findUniqueOrThrow
   */
  export type AdminUserFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AdminUser
     */
    select?: AdminUserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AdminUserInclude<ExtArgs> | null
    /**
     * Filter, which AdminUser to fetch.
     */
    where: AdminUserWhereUniqueInput
  }

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

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

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

  /**
   * AdminUser create
   */
  export type AdminUserCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AdminUser
     */
    select?: AdminUserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AdminUserInclude<ExtArgs> | null
    /**
     * The data needed to create a AdminUser.
     */
    data: XOR<AdminUserCreateInput, AdminUserUncheckedCreateInput>
  }

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

  /**
   * AdminUser createManyAndReturn
   */
  export type AdminUserCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AdminUser
     */
    select?: AdminUserSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many AdminUsers.
     */
    data: AdminUserCreateManyInput | AdminUserCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AdminUserIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * AdminUser update
   */
  export type AdminUserUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AdminUser
     */
    select?: AdminUserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AdminUserInclude<ExtArgs> | null
    /**
     * The data needed to update a AdminUser.
     */
    data: XOR<AdminUserUpdateInput, AdminUserUncheckedUpdateInput>
    /**
     * Choose, which AdminUser to update.
     */
    where: AdminUserWhereUniqueInput
  }

  /**
   * AdminUser updateMany
   */
  export type AdminUserUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update AdminUsers.
     */
    data: XOR<AdminUserUpdateManyMutationInput, AdminUserUncheckedUpdateManyInput>
    /**
     * Filter which AdminUsers to update
     */
    where?: AdminUserWhereInput
  }

  /**
   * AdminUser upsert
   */
  export type AdminUserUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AdminUser
     */
    select?: AdminUserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AdminUserInclude<ExtArgs> | null
    /**
     * The filter to search for the AdminUser to update in case it exists.
     */
    where: AdminUserWhereUniqueInput
    /**
     * In case the AdminUser found by the `where` argument doesn't exist, create a new AdminUser with this data.
     */
    create: XOR<AdminUserCreateInput, AdminUserUncheckedCreateInput>
    /**
     * In case the AdminUser was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AdminUserUpdateInput, AdminUserUncheckedUpdateInput>
  }

  /**
   * AdminUser delete
   */
  export type AdminUserDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AdminUser
     */
    select?: AdminUserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AdminUserInclude<ExtArgs> | null
    /**
     * Filter which AdminUser to delete.
     */
    where: AdminUserWhereUniqueInput
  }

  /**
   * AdminUser deleteMany
   */
  export type AdminUserDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which AdminUsers to delete
     */
    where?: AdminUserWhereInput
  }

  /**
   * AdminUser.userType
   */
  export type AdminUser$userTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserType
     */
    select?: UserTypeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserTypeInclude<ExtArgs> | null
    where?: UserTypeWhereInput
  }

  /**
   * AdminUser.branch
   */
  export type AdminUser$branchArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Branch
     */
    select?: BranchSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchInclude<ExtArgs> | null
    where?: BranchWhereInput
  }

  /**
   * AdminUser.avatarFile
   */
  export type AdminUser$avatarFileArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UploadedFile
     */
    select?: UploadedFileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UploadedFileInclude<ExtArgs> | null
    where?: UploadedFileWhereInput
  }

  /**
   * AdminUser.referredCustomers
   */
  export type AdminUser$referredCustomersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Customer
     */
    select?: CustomerSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerInclude<ExtArgs> | null
    where?: CustomerWhereInput
    orderBy?: CustomerOrderByWithRelationInput | CustomerOrderByWithRelationInput[]
    cursor?: CustomerWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CustomerScalarFieldEnum | CustomerScalarFieldEnum[]
  }

  /**
   * AdminUser.supervisedWorkshops
   */
  export type AdminUser$supervisedWorkshopsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Workshop
     */
    select?: WorkshopSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WorkshopInclude<ExtArgs> | null
    where?: WorkshopWhereInput
    orderBy?: WorkshopOrderByWithRelationInput | WorkshopOrderByWithRelationInput[]
    cursor?: WorkshopWhereUniqueInput
    take?: number
    skip?: number
    distinct?: WorkshopScalarFieldEnum | WorkshopScalarFieldEnum[]
  }

  /**
   * AdminUser.branchAllocations
   */
  export type AdminUser$branchAllocationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BranchAllocation
     */
    select?: BranchAllocationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchAllocationInclude<ExtArgs> | null
    where?: BranchAllocationWhereInput
    orderBy?: BranchAllocationOrderByWithRelationInput | BranchAllocationOrderByWithRelationInput[]
    cursor?: BranchAllocationWhereUniqueInput
    take?: number
    skip?: number
    distinct?: BranchAllocationScalarFieldEnum | BranchAllocationScalarFieldEnum[]
  }

  /**
   * AdminUser.postedLedgerEntries
   */
  export type AdminUser$postedLedgerEntriesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LedgerEntry
     */
    select?: LedgerEntrySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LedgerEntryInclude<ExtArgs> | null
    where?: LedgerEntryWhereInput
    orderBy?: LedgerEntryOrderByWithRelationInput | LedgerEntryOrderByWithRelationInput[]
    cursor?: LedgerEntryWhereUniqueInput
    take?: number
    skip?: number
    distinct?: LedgerEntryScalarFieldEnum | LedgerEntryScalarFieldEnum[]
  }

  /**
   * AdminUser.orderStatusEvents
   */
  export type AdminUser$orderStatusEventsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OrderStatusEvent
     */
    select?: OrderStatusEventSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderStatusEventInclude<ExtArgs> | null
    where?: OrderStatusEventWhereInput
    orderBy?: OrderStatusEventOrderByWithRelationInput | OrderStatusEventOrderByWithRelationInput[]
    cursor?: OrderStatusEventWhereUniqueInput
    take?: number
    skip?: number
    distinct?: OrderStatusEventScalarFieldEnum | OrderStatusEventScalarFieldEnum[]
  }

  /**
   * AdminUser.preOrderStatusEvents
   */
  export type AdminUser$preOrderStatusEventsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PreOrderStatusEvent
     */
    select?: PreOrderStatusEventSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PreOrderStatusEventInclude<ExtArgs> | null
    where?: PreOrderStatusEventWhereInput
    orderBy?: PreOrderStatusEventOrderByWithRelationInput | PreOrderStatusEventOrderByWithRelationInput[]
    cursor?: PreOrderStatusEventWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PreOrderStatusEventScalarFieldEnum | PreOrderStatusEventScalarFieldEnum[]
  }

  /**
   * AdminUser.sentSmsMessages
   */
  export type AdminUser$sentSmsMessagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SmsMessage
     */
    select?: SmsMessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SmsMessageInclude<ExtArgs> | null
    where?: SmsMessageWhereInput
    orderBy?: SmsMessageOrderByWithRelationInput | SmsMessageOrderByWithRelationInput[]
    cursor?: SmsMessageWhereUniqueInput
    take?: number
    skip?: number
    distinct?: SmsMessageScalarFieldEnum | SmsMessageScalarFieldEnum[]
  }

  /**
   * AdminUser.sentNotifications
   */
  export type AdminUser$sentNotificationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
    where?: NotificationWhereInput
    orderBy?: NotificationOrderByWithRelationInput | NotificationOrderByWithRelationInput[]
    cursor?: NotificationWhereUniqueInput
    take?: number
    skip?: number
    distinct?: NotificationScalarFieldEnum | NotificationScalarFieldEnum[]
  }

  /**
   * AdminUser.uploadedFiles
   */
  export type AdminUser$uploadedFilesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UploadedFile
     */
    select?: UploadedFileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UploadedFileInclude<ExtArgs> | null
    where?: UploadedFileWhereInput
    orderBy?: UploadedFileOrderByWithRelationInput | UploadedFileOrderByWithRelationInput[]
    cursor?: UploadedFileWhereUniqueInput
    take?: number
    skip?: number
    distinct?: UploadedFileScalarFieldEnum | UploadedFileScalarFieldEnum[]
  }

  /**
   * AdminUser.salesExpertProfile
   */
  export type AdminUser$salesExpertProfileArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SalesExpertProfile
     */
    select?: SalesExpertProfileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SalesExpertProfileInclude<ExtArgs> | null
    where?: SalesExpertProfileWhereInput
  }

  /**
   * AdminUser.sessions
   */
  export type AdminUser$sessionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AdminSession
     */
    select?: AdminSessionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AdminSessionInclude<ExtArgs> | null
    where?: AdminSessionWhereInput
    orderBy?: AdminSessionOrderByWithRelationInput | AdminSessionOrderByWithRelationInput[]
    cursor?: AdminSessionWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AdminSessionScalarFieldEnum | AdminSessionScalarFieldEnum[]
  }

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


  /**
   * Model AppSession
   */

  export type AggregateAppSession = {
    _count: AppSessionCountAggregateOutputType | null
    _min: AppSessionMinAggregateOutputType | null
    _max: AppSessionMaxAggregateOutputType | null
  }

  export type AppSessionMinAggregateOutputType = {
    id: string | null
    jti: string | null
    subjectId: string | null
    subjectType: string | null
    mobile: string | null
    iamSessionId: string | null
    iamSub: string | null
    ipAddress: string | null
    userAgent: string | null
    createdAt: Date | null
    expiresAt: Date | null
    lastSeenAt: Date | null
    revokedAt: Date | null
    revokedReason: string | null
  }

  export type AppSessionMaxAggregateOutputType = {
    id: string | null
    jti: string | null
    subjectId: string | null
    subjectType: string | null
    mobile: string | null
    iamSessionId: string | null
    iamSub: string | null
    ipAddress: string | null
    userAgent: string | null
    createdAt: Date | null
    expiresAt: Date | null
    lastSeenAt: Date | null
    revokedAt: Date | null
    revokedReason: string | null
  }

  export type AppSessionCountAggregateOutputType = {
    id: number
    jti: number
    subjectId: number
    subjectType: number
    mobile: number
    iamSessionId: number
    iamSub: number
    ipAddress: number
    userAgent: number
    createdAt: number
    expiresAt: number
    lastSeenAt: number
    revokedAt: number
    revokedReason: number
    _all: number
  }


  export type AppSessionMinAggregateInputType = {
    id?: true
    jti?: true
    subjectId?: true
    subjectType?: true
    mobile?: true
    iamSessionId?: true
    iamSub?: true
    ipAddress?: true
    userAgent?: true
    createdAt?: true
    expiresAt?: true
    lastSeenAt?: true
    revokedAt?: true
    revokedReason?: true
  }

  export type AppSessionMaxAggregateInputType = {
    id?: true
    jti?: true
    subjectId?: true
    subjectType?: true
    mobile?: true
    iamSessionId?: true
    iamSub?: true
    ipAddress?: true
    userAgent?: true
    createdAt?: true
    expiresAt?: true
    lastSeenAt?: true
    revokedAt?: true
    revokedReason?: true
  }

  export type AppSessionCountAggregateInputType = {
    id?: true
    jti?: true
    subjectId?: true
    subjectType?: true
    mobile?: true
    iamSessionId?: true
    iamSub?: true
    ipAddress?: true
    userAgent?: true
    createdAt?: true
    expiresAt?: true
    lastSeenAt?: true
    revokedAt?: true
    revokedReason?: true
    _all?: true
  }

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

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




  export type AppSessionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AppSessionWhereInput
    orderBy?: AppSessionOrderByWithAggregationInput | AppSessionOrderByWithAggregationInput[]
    by: AppSessionScalarFieldEnum[] | AppSessionScalarFieldEnum
    having?: AppSessionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AppSessionCountAggregateInputType | true
    _min?: AppSessionMinAggregateInputType
    _max?: AppSessionMaxAggregateInputType
  }

  export type AppSessionGroupByOutputType = {
    id: string
    jti: string
    subjectId: string
    subjectType: string
    mobile: string | null
    iamSessionId: string | null
    iamSub: string | null
    ipAddress: string | null
    userAgent: string | null
    createdAt: Date
    expiresAt: Date | null
    lastSeenAt: Date | null
    revokedAt: Date | null
    revokedReason: string | null
    _count: AppSessionCountAggregateOutputType | null
    _min: AppSessionMinAggregateOutputType | null
    _max: AppSessionMaxAggregateOutputType | null
  }

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


  export type AppSessionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    jti?: boolean
    subjectId?: boolean
    subjectType?: boolean
    mobile?: boolean
    iamSessionId?: boolean
    iamSub?: boolean
    ipAddress?: boolean
    userAgent?: boolean
    createdAt?: boolean
    expiresAt?: boolean
    lastSeenAt?: boolean
    revokedAt?: boolean
    revokedReason?: boolean
  }, ExtArgs["result"]["appSession"]>

  export type AppSessionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    jti?: boolean
    subjectId?: boolean
    subjectType?: boolean
    mobile?: boolean
    iamSessionId?: boolean
    iamSub?: boolean
    ipAddress?: boolean
    userAgent?: boolean
    createdAt?: boolean
    expiresAt?: boolean
    lastSeenAt?: boolean
    revokedAt?: boolean
    revokedReason?: boolean
  }, ExtArgs["result"]["appSession"]>

  export type AppSessionSelectScalar = {
    id?: boolean
    jti?: boolean
    subjectId?: boolean
    subjectType?: boolean
    mobile?: boolean
    iamSessionId?: boolean
    iamSub?: boolean
    ipAddress?: boolean
    userAgent?: boolean
    createdAt?: boolean
    expiresAt?: boolean
    lastSeenAt?: boolean
    revokedAt?: boolean
    revokedReason?: boolean
  }


  export type $AppSessionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "AppSession"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      /**
       * The token's `jti` claim. Unique: one row per issued token.
       */
      jti: string
      /**
       * Customer.id, or AdminUser.id when subjectType is "sales-expert".
       */
      subjectId: string
      subjectType: string
      mobile: string | null
      /**
       * Set when the login was confirmed by the central IAM: its session id (`sid`)
       * and stable user id (`sub`), which is what a back-channel logout arrives with.
       */
      iamSessionId: string | null
      iamSub: string | null
      ipAddress: string | null
      userAgent: string | null
      createdAt: Date
      expiresAt: Date | null
      lastSeenAt: Date | null
      revokedAt: Date | null
      revokedReason: string | null
    }, ExtArgs["result"]["appSession"]>
    composites: {}
  }

  type AppSessionGetPayload<S extends boolean | null | undefined | AppSessionDefaultArgs> = $Result.GetResult<Prisma.$AppSessionPayload, S>

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

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

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

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

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

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

    /**
     * Create a AppSession.
     * @param {AppSessionCreateArgs} args - Arguments to create a AppSession.
     * @example
     * // Create one AppSession
     * const AppSession = await prisma.appSession.create({
     *   data: {
     *     // ... data to create a AppSession
     *   }
     * })
     * 
     */
    create<T extends AppSessionCreateArgs>(args: SelectSubset<T, AppSessionCreateArgs<ExtArgs>>): Prisma__AppSessionClient<$Result.GetResult<Prisma.$AppSessionPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a AppSession.
     * @param {AppSessionDeleteArgs} args - Arguments to delete one AppSession.
     * @example
     * // Delete one AppSession
     * const AppSession = await prisma.appSession.delete({
     *   where: {
     *     // ... filter to delete one AppSession
     *   }
     * })
     * 
     */
    delete<T extends AppSessionDeleteArgs>(args: SelectSubset<T, AppSessionDeleteArgs<ExtArgs>>): Prisma__AppSessionClient<$Result.GetResult<Prisma.$AppSessionPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for AppSession.
   * 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__AppSessionClient<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 AppSession model
   */ 
  interface AppSessionFieldRefs {
    readonly id: FieldRef<"AppSession", 'String'>
    readonly jti: FieldRef<"AppSession", 'String'>
    readonly subjectId: FieldRef<"AppSession", 'String'>
    readonly subjectType: FieldRef<"AppSession", 'String'>
    readonly mobile: FieldRef<"AppSession", 'String'>
    readonly iamSessionId: FieldRef<"AppSession", 'String'>
    readonly iamSub: FieldRef<"AppSession", 'String'>
    readonly ipAddress: FieldRef<"AppSession", 'String'>
    readonly userAgent: FieldRef<"AppSession", 'String'>
    readonly createdAt: FieldRef<"AppSession", 'DateTime'>
    readonly expiresAt: FieldRef<"AppSession", 'DateTime'>
    readonly lastSeenAt: FieldRef<"AppSession", 'DateTime'>
    readonly revokedAt: FieldRef<"AppSession", 'DateTime'>
    readonly revokedReason: FieldRef<"AppSession", 'String'>
  }
    

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

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

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

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

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

  /**
   * AppSession create
   */
  export type AppSessionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppSession
     */
    select?: AppSessionSelect<ExtArgs> | null
    /**
     * The data needed to create a AppSession.
     */
    data: XOR<AppSessionCreateInput, AppSessionUncheckedCreateInput>
  }

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

  /**
   * AppSession createManyAndReturn
   */
  export type AppSessionCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppSession
     */
    select?: AppSessionSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many AppSessions.
     */
    data: AppSessionCreateManyInput | AppSessionCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * AppSession update
   */
  export type AppSessionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppSession
     */
    select?: AppSessionSelect<ExtArgs> | null
    /**
     * The data needed to update a AppSession.
     */
    data: XOR<AppSessionUpdateInput, AppSessionUncheckedUpdateInput>
    /**
     * Choose, which AppSession to update.
     */
    where: AppSessionWhereUniqueInput
  }

  /**
   * AppSession updateMany
   */
  export type AppSessionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update AppSessions.
     */
    data: XOR<AppSessionUpdateManyMutationInput, AppSessionUncheckedUpdateManyInput>
    /**
     * Filter which AppSessions to update
     */
    where?: AppSessionWhereInput
  }

  /**
   * AppSession upsert
   */
  export type AppSessionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AppSession
     */
    select?: AppSessionSelect<ExtArgs> | null
    /**
     * The filter to search for the AppSession to update in case it exists.
     */
    where: AppSessionWhereUniqueInput
    /**
     * In case the AppSession found by the `where` argument doesn't exist, create a new AppSession with this data.
     */
    create: XOR<AppSessionCreateInput, AppSessionUncheckedCreateInput>
    /**
     * In case the AppSession was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AppSessionUpdateInput, AppSessionUncheckedUpdateInput>
  }

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

  /**
   * AppSession deleteMany
   */
  export type AppSessionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which AppSessions to delete
     */
    where?: AppSessionWhereInput
  }

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


  /**
   * Model AdminSession
   */

  export type AggregateAdminSession = {
    _count: AdminSessionCountAggregateOutputType | null
    _min: AdminSessionMinAggregateOutputType | null
    _max: AdminSessionMaxAggregateOutputType | null
  }

  export type AdminSessionMinAggregateOutputType = {
    id: string | null
    jti: string | null
    adminUserId: string | null
    iamSessionId: string | null
    iamSub: string | null
    ipAddress: string | null
    userAgent: string | null
    createdAt: Date | null
    expiresAt: Date | null
    lastSeenAt: Date | null
    revokedAt: Date | null
    revokedReason: string | null
  }

  export type AdminSessionMaxAggregateOutputType = {
    id: string | null
    jti: string | null
    adminUserId: string | null
    iamSessionId: string | null
    iamSub: string | null
    ipAddress: string | null
    userAgent: string | null
    createdAt: Date | null
    expiresAt: Date | null
    lastSeenAt: Date | null
    revokedAt: Date | null
    revokedReason: string | null
  }

  export type AdminSessionCountAggregateOutputType = {
    id: number
    jti: number
    adminUserId: number
    iamSessionId: number
    iamSub: number
    ipAddress: number
    userAgent: number
    createdAt: number
    expiresAt: number
    lastSeenAt: number
    revokedAt: number
    revokedReason: number
    _all: number
  }


  export type AdminSessionMinAggregateInputType = {
    id?: true
    jti?: true
    adminUserId?: true
    iamSessionId?: true
    iamSub?: true
    ipAddress?: true
    userAgent?: true
    createdAt?: true
    expiresAt?: true
    lastSeenAt?: true
    revokedAt?: true
    revokedReason?: true
  }

  export type AdminSessionMaxAggregateInputType = {
    id?: true
    jti?: true
    adminUserId?: true
    iamSessionId?: true
    iamSub?: true
    ipAddress?: true
    userAgent?: true
    createdAt?: true
    expiresAt?: true
    lastSeenAt?: true
    revokedAt?: true
    revokedReason?: true
  }

  export type AdminSessionCountAggregateInputType = {
    id?: true
    jti?: true
    adminUserId?: true
    iamSessionId?: true
    iamSub?: true
    ipAddress?: true
    userAgent?: true
    createdAt?: true
    expiresAt?: true
    lastSeenAt?: true
    revokedAt?: true
    revokedReason?: true
    _all?: true
  }

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

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




  export type AdminSessionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: AdminSessionWhereInput
    orderBy?: AdminSessionOrderByWithAggregationInput | AdminSessionOrderByWithAggregationInput[]
    by: AdminSessionScalarFieldEnum[] | AdminSessionScalarFieldEnum
    having?: AdminSessionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: AdminSessionCountAggregateInputType | true
    _min?: AdminSessionMinAggregateInputType
    _max?: AdminSessionMaxAggregateInputType
  }

  export type AdminSessionGroupByOutputType = {
    id: string
    jti: string
    adminUserId: string
    iamSessionId: string | null
    iamSub: string | null
    ipAddress: string | null
    userAgent: string | null
    createdAt: Date
    expiresAt: Date | null
    lastSeenAt: Date | null
    revokedAt: Date | null
    revokedReason: string | null
    _count: AdminSessionCountAggregateOutputType | null
    _min: AdminSessionMinAggregateOutputType | null
    _max: AdminSessionMaxAggregateOutputType | null
  }

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


  export type AdminSessionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    jti?: boolean
    adminUserId?: boolean
    iamSessionId?: boolean
    iamSub?: boolean
    ipAddress?: boolean
    userAgent?: boolean
    createdAt?: boolean
    expiresAt?: boolean
    lastSeenAt?: boolean
    revokedAt?: boolean
    revokedReason?: boolean
    adminUser?: boolean | AdminUserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["adminSession"]>

  export type AdminSessionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    jti?: boolean
    adminUserId?: boolean
    iamSessionId?: boolean
    iamSub?: boolean
    ipAddress?: boolean
    userAgent?: boolean
    createdAt?: boolean
    expiresAt?: boolean
    lastSeenAt?: boolean
    revokedAt?: boolean
    revokedReason?: boolean
    adminUser?: boolean | AdminUserDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["adminSession"]>

  export type AdminSessionSelectScalar = {
    id?: boolean
    jti?: boolean
    adminUserId?: boolean
    iamSessionId?: boolean
    iamSub?: boolean
    ipAddress?: boolean
    userAgent?: boolean
    createdAt?: boolean
    expiresAt?: boolean
    lastSeenAt?: boolean
    revokedAt?: boolean
    revokedReason?: boolean
  }

  export type AdminSessionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    adminUser?: boolean | AdminUserDefaultArgs<ExtArgs>
  }
  export type AdminSessionIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    adminUser?: boolean | AdminUserDefaultArgs<ExtArgs>
  }

  export type $AdminSessionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "AdminSession"
    objects: {
      adminUser: Prisma.$AdminUserPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      /**
       * The token's `jti` claim. Unique: one row per issued token.
       */
      jti: string
      adminUserId: string
      /**
       * Set when the login was verified by the IAM: its session id (`sid`) and the
       * stable user id (`sub`) there. Back-channel logout arrives keyed by these —
       * deliberately here rather than as columns on AdminUser, so enabling the
       * feature needs no change to an existing table.
       */
      iamSessionId: string | null
      iamSub: string | null
      ipAddress: string | null
      userAgent: string | null
      createdAt: Date
      expiresAt: Date | null
      lastSeenAt: Date | null
      revokedAt: Date | null
      revokedReason: string | null
    }, ExtArgs["result"]["adminSession"]>
    composites: {}
  }

  type AdminSessionGetPayload<S extends boolean | null | undefined | AdminSessionDefaultArgs> = $Result.GetResult<Prisma.$AdminSessionPayload, S>

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

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

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

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

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

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

    /**
     * Create a AdminSession.
     * @param {AdminSessionCreateArgs} args - Arguments to create a AdminSession.
     * @example
     * // Create one AdminSession
     * const AdminSession = await prisma.adminSession.create({
     *   data: {
     *     // ... data to create a AdminSession
     *   }
     * })
     * 
     */
    create<T extends AdminSessionCreateArgs>(args: SelectSubset<T, AdminSessionCreateArgs<ExtArgs>>): Prisma__AdminSessionClient<$Result.GetResult<Prisma.$AdminSessionPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a AdminSession.
     * @param {AdminSessionDeleteArgs} args - Arguments to delete one AdminSession.
     * @example
     * // Delete one AdminSession
     * const AdminSession = await prisma.adminSession.delete({
     *   where: {
     *     // ... filter to delete one AdminSession
     *   }
     * })
     * 
     */
    delete<T extends AdminSessionDeleteArgs>(args: SelectSubset<T, AdminSessionDeleteArgs<ExtArgs>>): Prisma__AdminSessionClient<$Result.GetResult<Prisma.$AdminSessionPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for AdminSession.
   * 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__AdminSessionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    adminUser<T extends AdminUserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, AdminUserDefaultArgs<ExtArgs>>): Prisma__AdminUserClient<$Result.GetResult<Prisma.$AdminUserPayload<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 AdminSession model
   */ 
  interface AdminSessionFieldRefs {
    readonly id: FieldRef<"AdminSession", 'String'>
    readonly jti: FieldRef<"AdminSession", 'String'>
    readonly adminUserId: FieldRef<"AdminSession", 'String'>
    readonly iamSessionId: FieldRef<"AdminSession", 'String'>
    readonly iamSub: FieldRef<"AdminSession", 'String'>
    readonly ipAddress: FieldRef<"AdminSession", 'String'>
    readonly userAgent: FieldRef<"AdminSession", 'String'>
    readonly createdAt: FieldRef<"AdminSession", 'DateTime'>
    readonly expiresAt: FieldRef<"AdminSession", 'DateTime'>
    readonly lastSeenAt: FieldRef<"AdminSession", 'DateTime'>
    readonly revokedAt: FieldRef<"AdminSession", 'DateTime'>
    readonly revokedReason: FieldRef<"AdminSession", 'String'>
  }
    

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

  /**
   * AdminSession findUniqueOrThrow
   */
  export type AdminSessionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AdminSession
     */
    select?: AdminSessionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AdminSessionInclude<ExtArgs> | null
    /**
     * Filter, which AdminSession to fetch.
     */
    where: AdminSessionWhereUniqueInput
  }

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

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

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

  /**
   * AdminSession create
   */
  export type AdminSessionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AdminSession
     */
    select?: AdminSessionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AdminSessionInclude<ExtArgs> | null
    /**
     * The data needed to create a AdminSession.
     */
    data: XOR<AdminSessionCreateInput, AdminSessionUncheckedCreateInput>
  }

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

  /**
   * AdminSession createManyAndReturn
   */
  export type AdminSessionCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AdminSession
     */
    select?: AdminSessionSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many AdminSessions.
     */
    data: AdminSessionCreateManyInput | AdminSessionCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AdminSessionIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * AdminSession update
   */
  export type AdminSessionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AdminSession
     */
    select?: AdminSessionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AdminSessionInclude<ExtArgs> | null
    /**
     * The data needed to update a AdminSession.
     */
    data: XOR<AdminSessionUpdateInput, AdminSessionUncheckedUpdateInput>
    /**
     * Choose, which AdminSession to update.
     */
    where: AdminSessionWhereUniqueInput
  }

  /**
   * AdminSession updateMany
   */
  export type AdminSessionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update AdminSessions.
     */
    data: XOR<AdminSessionUpdateManyMutationInput, AdminSessionUncheckedUpdateManyInput>
    /**
     * Filter which AdminSessions to update
     */
    where?: AdminSessionWhereInput
  }

  /**
   * AdminSession upsert
   */
  export type AdminSessionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AdminSession
     */
    select?: AdminSessionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AdminSessionInclude<ExtArgs> | null
    /**
     * The filter to search for the AdminSession to update in case it exists.
     */
    where: AdminSessionWhereUniqueInput
    /**
     * In case the AdminSession found by the `where` argument doesn't exist, create a new AdminSession with this data.
     */
    create: XOR<AdminSessionCreateInput, AdminSessionUncheckedCreateInput>
    /**
     * In case the AdminSession was found with the provided `where` argument, update it with this data.
     */
    update: XOR<AdminSessionUpdateInput, AdminSessionUncheckedUpdateInput>
  }

  /**
   * AdminSession delete
   */
  export type AdminSessionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AdminSession
     */
    select?: AdminSessionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AdminSessionInclude<ExtArgs> | null
    /**
     * Filter which AdminSession to delete.
     */
    where: AdminSessionWhereUniqueInput
  }

  /**
   * AdminSession deleteMany
   */
  export type AdminSessionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which AdminSessions to delete
     */
    where?: AdminSessionWhereInput
  }

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


  /**
   * Model SalesExpertProfile
   */

  export type AggregateSalesExpertProfile = {
    _count: SalesExpertProfileCountAggregateOutputType | null
    _avg: SalesExpertProfileAvgAggregateOutputType | null
    _sum: SalesExpertProfileSumAggregateOutputType | null
    _min: SalesExpertProfileMinAggregateOutputType | null
    _max: SalesExpertProfileMaxAggregateOutputType | null
  }

  export type SalesExpertProfileAvgAggregateOutputType = {
    gramLevel: Decimal | null
  }

  export type SalesExpertProfileSumAggregateOutputType = {
    gramLevel: Decimal | null
  }

  export type SalesExpertProfileMinAggregateOutputType = {
    id: string | null
    adminUserId: string | null
    cityId: string | null
    gramLevel: Decimal | null
    phone: string | null
    nationalCode: string | null
    tradingCustomerId: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type SalesExpertProfileMaxAggregateOutputType = {
    id: string | null
    adminUserId: string | null
    cityId: string | null
    gramLevel: Decimal | null
    phone: string | null
    nationalCode: string | null
    tradingCustomerId: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type SalesExpertProfileCountAggregateOutputType = {
    id: number
    adminUserId: number
    cityId: number
    gramLevel: number
    phone: number
    nationalCode: number
    tradingCustomerId: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type SalesExpertProfileAvgAggregateInputType = {
    gramLevel?: true
  }

  export type SalesExpertProfileSumAggregateInputType = {
    gramLevel?: true
  }

  export type SalesExpertProfileMinAggregateInputType = {
    id?: true
    adminUserId?: true
    cityId?: true
    gramLevel?: true
    phone?: true
    nationalCode?: true
    tradingCustomerId?: true
    createdAt?: true
    updatedAt?: true
  }

  export type SalesExpertProfileMaxAggregateInputType = {
    id?: true
    adminUserId?: true
    cityId?: true
    gramLevel?: true
    phone?: true
    nationalCode?: true
    tradingCustomerId?: true
    createdAt?: true
    updatedAt?: true
  }

  export type SalesExpertProfileCountAggregateInputType = {
    id?: true
    adminUserId?: true
    cityId?: true
    gramLevel?: true
    phone?: true
    nationalCode?: true
    tradingCustomerId?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type SalesExpertProfileAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which SalesExpertProfile to aggregate.
     */
    where?: SalesExpertProfileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SalesExpertProfiles to fetch.
     */
    orderBy?: SalesExpertProfileOrderByWithRelationInput | SalesExpertProfileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: SalesExpertProfileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SalesExpertProfiles from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` SalesExpertProfiles.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned SalesExpertProfiles
    **/
    _count?: true | SalesExpertProfileCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: SalesExpertProfileAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: SalesExpertProfileSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: SalesExpertProfileMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: SalesExpertProfileMaxAggregateInputType
  }

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




  export type SalesExpertProfileGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SalesExpertProfileWhereInput
    orderBy?: SalesExpertProfileOrderByWithAggregationInput | SalesExpertProfileOrderByWithAggregationInput[]
    by: SalesExpertProfileScalarFieldEnum[] | SalesExpertProfileScalarFieldEnum
    having?: SalesExpertProfileScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: SalesExpertProfileCountAggregateInputType | true
    _avg?: SalesExpertProfileAvgAggregateInputType
    _sum?: SalesExpertProfileSumAggregateInputType
    _min?: SalesExpertProfileMinAggregateInputType
    _max?: SalesExpertProfileMaxAggregateInputType
  }

  export type SalesExpertProfileGroupByOutputType = {
    id: string
    adminUserId: string
    cityId: string | null
    gramLevel: Decimal
    phone: string | null
    nationalCode: string | null
    tradingCustomerId: string | null
    createdAt: Date
    updatedAt: Date
    _count: SalesExpertProfileCountAggregateOutputType | null
    _avg: SalesExpertProfileAvgAggregateOutputType | null
    _sum: SalesExpertProfileSumAggregateOutputType | null
    _min: SalesExpertProfileMinAggregateOutputType | null
    _max: SalesExpertProfileMaxAggregateOutputType | null
  }

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


  export type SalesExpertProfileSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    adminUserId?: boolean
    cityId?: boolean
    gramLevel?: boolean
    phone?: boolean
    nationalCode?: boolean
    tradingCustomerId?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    adminUser?: boolean | AdminUserDefaultArgs<ExtArgs>
    city?: boolean | SalesExpertProfile$cityArgs<ExtArgs>
    tradingCustomer?: boolean | SalesExpertProfile$tradingCustomerArgs<ExtArgs>
  }, ExtArgs["result"]["salesExpertProfile"]>

  export type SalesExpertProfileSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    adminUserId?: boolean
    cityId?: boolean
    gramLevel?: boolean
    phone?: boolean
    nationalCode?: boolean
    tradingCustomerId?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    adminUser?: boolean | AdminUserDefaultArgs<ExtArgs>
    city?: boolean | SalesExpertProfile$cityArgs<ExtArgs>
    tradingCustomer?: boolean | SalesExpertProfile$tradingCustomerArgs<ExtArgs>
  }, ExtArgs["result"]["salesExpertProfile"]>

  export type SalesExpertProfileSelectScalar = {
    id?: boolean
    adminUserId?: boolean
    cityId?: boolean
    gramLevel?: boolean
    phone?: boolean
    nationalCode?: boolean
    tradingCustomerId?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type SalesExpertProfileInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    adminUser?: boolean | AdminUserDefaultArgs<ExtArgs>
    city?: boolean | SalesExpertProfile$cityArgs<ExtArgs>
    tradingCustomer?: boolean | SalesExpertProfile$tradingCustomerArgs<ExtArgs>
  }
  export type SalesExpertProfileIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    adminUser?: boolean | AdminUserDefaultArgs<ExtArgs>
    city?: boolean | SalesExpertProfile$cityArgs<ExtArgs>
    tradingCustomer?: boolean | SalesExpertProfile$tradingCustomerArgs<ExtArgs>
  }

  export type $SalesExpertProfilePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "SalesExpertProfile"
    objects: {
      adminUser: Prisma.$AdminUserPayload<ExtArgs>
      city: Prisma.$CityPayload<ExtArgs> | null
      tradingCustomer: Prisma.$CustomerPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      adminUserId: string
      /**
       * Legacy customers.city_id — a filterable grid column
       * (ReagentListModel.js:14) and the source of the commission autofill
       * (ReagentCustomer.vue:215-228).
       */
      cityId: string | null
      /**
       * Legacy customers.gram_level — the «سطح اعتبار» column, filterable.
       * Decimal(14,4) matches Customer.goldCreditLimitGrams exactly so the same
       * credit limit has identical precision on both tables.
       */
      gramLevel: Prisma.Decimal
      /**
       * Legacy customers.phone (varchar 15) and ncode (varchar 20). The reference
       * stores both and reads neither back; kept so the form matches it. Neither
       * is unique and neither has a validation rule in the reference — inventing
       * one would reject data the reference accepts.
       */
      phone: string | null
      nationalCode: string | null
      /**
       * The Customer row carrying this expert's OWN orders, debt and credit limit.
       * 
       * The reference stored a sales agent AS a Customer (type=1), so an order the
       * agent placed from the app was simply their own, against their own
       * gram_level (ApiMobileController.php:534-535). Here the expert is an
       * AdminUser (D17), which has no ledger and cannot be an Order's subject, so
       * this one linked Customer plays that part.
       * 
       * Distinct from the expert's REFERRED customers, which are ordinary Customer
       * rows pointing at the AdminUser through Customer.referredByAgentId.
       * 
       * Null until the expert first signs into the app, when it is created from
       * this profile. See D21.
       */
      tradingCustomerId: string | null
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["salesExpertProfile"]>
    composites: {}
  }

  type SalesExpertProfileGetPayload<S extends boolean | null | undefined | SalesExpertProfileDefaultArgs> = $Result.GetResult<Prisma.$SalesExpertProfilePayload, S>

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

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

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

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

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

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

    /**
     * Create a SalesExpertProfile.
     * @param {SalesExpertProfileCreateArgs} args - Arguments to create a SalesExpertProfile.
     * @example
     * // Create one SalesExpertProfile
     * const SalesExpertProfile = await prisma.salesExpertProfile.create({
     *   data: {
     *     // ... data to create a SalesExpertProfile
     *   }
     * })
     * 
     */
    create<T extends SalesExpertProfileCreateArgs>(args: SelectSubset<T, SalesExpertProfileCreateArgs<ExtArgs>>): Prisma__SalesExpertProfileClient<$Result.GetResult<Prisma.$SalesExpertProfilePayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a SalesExpertProfile.
     * @param {SalesExpertProfileDeleteArgs} args - Arguments to delete one SalesExpertProfile.
     * @example
     * // Delete one SalesExpertProfile
     * const SalesExpertProfile = await prisma.salesExpertProfile.delete({
     *   where: {
     *     // ... filter to delete one SalesExpertProfile
     *   }
     * })
     * 
     */
    delete<T extends SalesExpertProfileDeleteArgs>(args: SelectSubset<T, SalesExpertProfileDeleteArgs<ExtArgs>>): Prisma__SalesExpertProfileClient<$Result.GetResult<Prisma.$SalesExpertProfilePayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for SalesExpertProfile.
   * 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__SalesExpertProfileClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    adminUser<T extends AdminUserDefaultArgs<ExtArgs> = {}>(args?: Subset<T, AdminUserDefaultArgs<ExtArgs>>): Prisma__AdminUserClient<$Result.GetResult<Prisma.$AdminUserPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    city<T extends SalesExpertProfile$cityArgs<ExtArgs> = {}>(args?: Subset<T, SalesExpertProfile$cityArgs<ExtArgs>>): Prisma__CityClient<$Result.GetResult<Prisma.$CityPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    tradingCustomer<T extends SalesExpertProfile$tradingCustomerArgs<ExtArgs> = {}>(args?: Subset<T, SalesExpertProfile$tradingCustomerArgs<ExtArgs>>): Prisma__CustomerClient<$Result.GetResult<Prisma.$CustomerPayload<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 SalesExpertProfile model
   */ 
  interface SalesExpertProfileFieldRefs {
    readonly id: FieldRef<"SalesExpertProfile", 'String'>
    readonly adminUserId: FieldRef<"SalesExpertProfile", 'String'>
    readonly cityId: FieldRef<"SalesExpertProfile", 'String'>
    readonly gramLevel: FieldRef<"SalesExpertProfile", 'Decimal'>
    readonly phone: FieldRef<"SalesExpertProfile", 'String'>
    readonly nationalCode: FieldRef<"SalesExpertProfile", 'String'>
    readonly tradingCustomerId: FieldRef<"SalesExpertProfile", 'String'>
    readonly createdAt: FieldRef<"SalesExpertProfile", 'DateTime'>
    readonly updatedAt: FieldRef<"SalesExpertProfile", 'DateTime'>
  }
    

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

  /**
   * SalesExpertProfile findUniqueOrThrow
   */
  export type SalesExpertProfileFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SalesExpertProfile
     */
    select?: SalesExpertProfileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SalesExpertProfileInclude<ExtArgs> | null
    /**
     * Filter, which SalesExpertProfile to fetch.
     */
    where: SalesExpertProfileWhereUniqueInput
  }

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

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

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

  /**
   * SalesExpertProfile create
   */
  export type SalesExpertProfileCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SalesExpertProfile
     */
    select?: SalesExpertProfileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SalesExpertProfileInclude<ExtArgs> | null
    /**
     * The data needed to create a SalesExpertProfile.
     */
    data: XOR<SalesExpertProfileCreateInput, SalesExpertProfileUncheckedCreateInput>
  }

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

  /**
   * SalesExpertProfile createManyAndReturn
   */
  export type SalesExpertProfileCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SalesExpertProfile
     */
    select?: SalesExpertProfileSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many SalesExpertProfiles.
     */
    data: SalesExpertProfileCreateManyInput | SalesExpertProfileCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SalesExpertProfileIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * SalesExpertProfile update
   */
  export type SalesExpertProfileUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SalesExpertProfile
     */
    select?: SalesExpertProfileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SalesExpertProfileInclude<ExtArgs> | null
    /**
     * The data needed to update a SalesExpertProfile.
     */
    data: XOR<SalesExpertProfileUpdateInput, SalesExpertProfileUncheckedUpdateInput>
    /**
     * Choose, which SalesExpertProfile to update.
     */
    where: SalesExpertProfileWhereUniqueInput
  }

  /**
   * SalesExpertProfile updateMany
   */
  export type SalesExpertProfileUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update SalesExpertProfiles.
     */
    data: XOR<SalesExpertProfileUpdateManyMutationInput, SalesExpertProfileUncheckedUpdateManyInput>
    /**
     * Filter which SalesExpertProfiles to update
     */
    where?: SalesExpertProfileWhereInput
  }

  /**
   * SalesExpertProfile upsert
   */
  export type SalesExpertProfileUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SalesExpertProfile
     */
    select?: SalesExpertProfileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SalesExpertProfileInclude<ExtArgs> | null
    /**
     * The filter to search for the SalesExpertProfile to update in case it exists.
     */
    where: SalesExpertProfileWhereUniqueInput
    /**
     * In case the SalesExpertProfile found by the `where` argument doesn't exist, create a new SalesExpertProfile with this data.
     */
    create: XOR<SalesExpertProfileCreateInput, SalesExpertProfileUncheckedCreateInput>
    /**
     * In case the SalesExpertProfile was found with the provided `where` argument, update it with this data.
     */
    update: XOR<SalesExpertProfileUpdateInput, SalesExpertProfileUncheckedUpdateInput>
  }

  /**
   * SalesExpertProfile delete
   */
  export type SalesExpertProfileDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SalesExpertProfile
     */
    select?: SalesExpertProfileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SalesExpertProfileInclude<ExtArgs> | null
    /**
     * Filter which SalesExpertProfile to delete.
     */
    where: SalesExpertProfileWhereUniqueInput
  }

  /**
   * SalesExpertProfile deleteMany
   */
  export type SalesExpertProfileDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which SalesExpertProfiles to delete
     */
    where?: SalesExpertProfileWhereInput
  }

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

  /**
   * SalesExpertProfile.tradingCustomer
   */
  export type SalesExpertProfile$tradingCustomerArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Customer
     */
    select?: CustomerSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerInclude<ExtArgs> | null
    where?: CustomerWhereInput
  }

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


  /**
   * Model Customer
   */

  export type AggregateCustomer = {
    _count: CustomerCountAggregateOutputType | null
    _avg: CustomerAvgAggregateOutputType | null
    _sum: CustomerSumAggregateOutputType | null
    _min: CustomerMinAggregateOutputType | null
    _max: CustomerMaxAggregateOutputType | null
  }

  export type CustomerAvgAggregateOutputType = {
    goldCreditLimitGrams: Decimal | null
    goldDebtGrams: Decimal | null
    fiatDebtRial: Decimal | null
    makingChargeOffsetPercent: Decimal | null
  }

  export type CustomerSumAggregateOutputType = {
    goldCreditLimitGrams: Decimal | null
    goldDebtGrams: Decimal | null
    fiatDebtRial: Decimal | null
    makingChargeOffsetPercent: Decimal | null
  }

  export type CustomerMinAggregateOutputType = {
    id: string | null
    fullName: string | null
    firstName: string | null
    lastName: string | null
    mobile: string | null
    nationalCode: string | null
    passwordHash: string | null
    cityId: string | null
    kind: $Enums.CustomerKind | null
    phone: string | null
    address: string | null
    storeName: string | null
    pasazhName: string | null
    zone: string | null
    memberCode: string | null
    referredByAgentId: string | null
    goldCreditLimitGrams: Decimal | null
    goldDebtGrams: Decimal | null
    fiatDebtRial: Decimal | null
    makingChargeOffsetPercent: Decimal | null
    verificationStep: $Enums.VerificationStep | null
    nationalIdImageUrl: string | null
    businessLicenseUrl: string | null
    shopImageUrl: string | null
    avatarFileId: string | null
    canPlaceOrders: boolean | null
    isActive: boolean | null
    isArchived: boolean | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type CustomerMaxAggregateOutputType = {
    id: string | null
    fullName: string | null
    firstName: string | null
    lastName: string | null
    mobile: string | null
    nationalCode: string | null
    passwordHash: string | null
    cityId: string | null
    kind: $Enums.CustomerKind | null
    phone: string | null
    address: string | null
    storeName: string | null
    pasazhName: string | null
    zone: string | null
    memberCode: string | null
    referredByAgentId: string | null
    goldCreditLimitGrams: Decimal | null
    goldDebtGrams: Decimal | null
    fiatDebtRial: Decimal | null
    makingChargeOffsetPercent: Decimal | null
    verificationStep: $Enums.VerificationStep | null
    nationalIdImageUrl: string | null
    businessLicenseUrl: string | null
    shopImageUrl: string | null
    avatarFileId: string | null
    canPlaceOrders: boolean | null
    isActive: boolean | null
    isArchived: boolean | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type CustomerCountAggregateOutputType = {
    id: number
    fullName: number
    firstName: number
    lastName: number
    mobile: number
    nationalCode: number
    passwordHash: number
    cityId: number
    kind: number
    phone: number
    address: number
    storeName: number
    pasazhName: number
    zone: number
    memberCode: number
    referredByAgentId: number
    goldCreditLimitGrams: number
    goldDebtGrams: number
    fiatDebtRial: number
    makingChargeOffsetPercent: number
    verificationStep: number
    nationalIdImageUrl: number
    businessLicenseUrl: number
    shopImageUrl: number
    avatarFileId: number
    canPlaceOrders: number
    isActive: number
    isArchived: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type CustomerAvgAggregateInputType = {
    goldCreditLimitGrams?: true
    goldDebtGrams?: true
    fiatDebtRial?: true
    makingChargeOffsetPercent?: true
  }

  export type CustomerSumAggregateInputType = {
    goldCreditLimitGrams?: true
    goldDebtGrams?: true
    fiatDebtRial?: true
    makingChargeOffsetPercent?: true
  }

  export type CustomerMinAggregateInputType = {
    id?: true
    fullName?: true
    firstName?: true
    lastName?: true
    mobile?: true
    nationalCode?: true
    passwordHash?: true
    cityId?: true
    kind?: true
    phone?: true
    address?: true
    storeName?: true
    pasazhName?: true
    zone?: true
    memberCode?: true
    referredByAgentId?: true
    goldCreditLimitGrams?: true
    goldDebtGrams?: true
    fiatDebtRial?: true
    makingChargeOffsetPercent?: true
    verificationStep?: true
    nationalIdImageUrl?: true
    businessLicenseUrl?: true
    shopImageUrl?: true
    avatarFileId?: true
    canPlaceOrders?: true
    isActive?: true
    isArchived?: true
    createdAt?: true
    updatedAt?: true
  }

  export type CustomerMaxAggregateInputType = {
    id?: true
    fullName?: true
    firstName?: true
    lastName?: true
    mobile?: true
    nationalCode?: true
    passwordHash?: true
    cityId?: true
    kind?: true
    phone?: true
    address?: true
    storeName?: true
    pasazhName?: true
    zone?: true
    memberCode?: true
    referredByAgentId?: true
    goldCreditLimitGrams?: true
    goldDebtGrams?: true
    fiatDebtRial?: true
    makingChargeOffsetPercent?: true
    verificationStep?: true
    nationalIdImageUrl?: true
    businessLicenseUrl?: true
    shopImageUrl?: true
    avatarFileId?: true
    canPlaceOrders?: true
    isActive?: true
    isArchived?: true
    createdAt?: true
    updatedAt?: true
  }

  export type CustomerCountAggregateInputType = {
    id?: true
    fullName?: true
    firstName?: true
    lastName?: true
    mobile?: true
    nationalCode?: true
    passwordHash?: true
    cityId?: true
    kind?: true
    phone?: true
    address?: true
    storeName?: true
    pasazhName?: true
    zone?: true
    memberCode?: true
    referredByAgentId?: true
    goldCreditLimitGrams?: true
    goldDebtGrams?: true
    fiatDebtRial?: true
    makingChargeOffsetPercent?: true
    verificationStep?: true
    nationalIdImageUrl?: true
    businessLicenseUrl?: true
    shopImageUrl?: true
    avatarFileId?: true
    canPlaceOrders?: true
    isActive?: true
    isArchived?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type CustomerAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Customer to aggregate.
     */
    where?: CustomerWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Customers to fetch.
     */
    orderBy?: CustomerOrderByWithRelationInput | CustomerOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: CustomerWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Customers from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Customers.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Customers
    **/
    _count?: true | CustomerCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: CustomerAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: CustomerSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: CustomerMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: CustomerMaxAggregateInputType
  }

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




  export type CustomerGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CustomerWhereInput
    orderBy?: CustomerOrderByWithAggregationInput | CustomerOrderByWithAggregationInput[]
    by: CustomerScalarFieldEnum[] | CustomerScalarFieldEnum
    having?: CustomerScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CustomerCountAggregateInputType | true
    _avg?: CustomerAvgAggregateInputType
    _sum?: CustomerSumAggregateInputType
    _min?: CustomerMinAggregateInputType
    _max?: CustomerMaxAggregateInputType
  }

  export type CustomerGroupByOutputType = {
    id: string
    fullName: string
    firstName: string | null
    lastName: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    cityId: string | null
    kind: $Enums.CustomerKind
    phone: string | null
    address: string | null
    storeName: string | null
    pasazhName: string | null
    zone: string | null
    memberCode: string | null
    referredByAgentId: string | null
    goldCreditLimitGrams: Decimal
    goldDebtGrams: Decimal
    fiatDebtRial: Decimal
    makingChargeOffsetPercent: Decimal
    verificationStep: $Enums.VerificationStep
    nationalIdImageUrl: string | null
    businessLicenseUrl: string | null
    shopImageUrl: string | null
    avatarFileId: string | null
    canPlaceOrders: boolean
    isActive: boolean
    isArchived: boolean
    createdAt: Date
    updatedAt: Date
    _count: CustomerCountAggregateOutputType | null
    _avg: CustomerAvgAggregateOutputType | null
    _sum: CustomerSumAggregateOutputType | null
    _min: CustomerMinAggregateOutputType | null
    _max: CustomerMaxAggregateOutputType | null
  }

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


  export type CustomerSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    fullName?: boolean
    firstName?: boolean
    lastName?: boolean
    mobile?: boolean
    nationalCode?: boolean
    passwordHash?: boolean
    cityId?: boolean
    kind?: boolean
    phone?: boolean
    address?: boolean
    storeName?: boolean
    pasazhName?: boolean
    zone?: boolean
    memberCode?: boolean
    referredByAgentId?: boolean
    goldCreditLimitGrams?: boolean
    goldDebtGrams?: boolean
    fiatDebtRial?: boolean
    makingChargeOffsetPercent?: boolean
    verificationStep?: boolean
    nationalIdImageUrl?: boolean
    businessLicenseUrl?: boolean
    shopImageUrl?: boolean
    avatarFileId?: boolean
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    city?: boolean | Customer$cityArgs<ExtArgs>
    referredByAgent?: boolean | Customer$referredByAgentArgs<ExtArgs>
    salesExpertTradingFor?: boolean | Customer$salesExpertTradingForArgs<ExtArgs>
    avatarFile?: boolean | Customer$avatarFileArgs<ExtArgs>
    addresses?: boolean | Customer$addressesArgs<ExtArgs>
    orders?: boolean | Customer$ordersArgs<ExtArgs>
    preOrders?: boolean | Customer$preOrdersArgs<ExtArgs>
    ledgerEntries?: boolean | Customer$ledgerEntriesArgs<ExtArgs>
    walletBonuses?: boolean | Customer$walletBonusesArgs<ExtArgs>
    comments?: boolean | Customer$commentsArgs<ExtArgs>
    promotions?: boolean | Customer$promotionsArgs<ExtArgs>
    notifications?: boolean | Customer$notificationsArgs<ExtArgs>
    activityLogs?: boolean | Customer$activityLogsArgs<ExtArgs>
    otpChallenges?: boolean | Customer$otpChallengesArgs<ExtArgs>
    _count?: boolean | CustomerCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["customer"]>

  export type CustomerSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    fullName?: boolean
    firstName?: boolean
    lastName?: boolean
    mobile?: boolean
    nationalCode?: boolean
    passwordHash?: boolean
    cityId?: boolean
    kind?: boolean
    phone?: boolean
    address?: boolean
    storeName?: boolean
    pasazhName?: boolean
    zone?: boolean
    memberCode?: boolean
    referredByAgentId?: boolean
    goldCreditLimitGrams?: boolean
    goldDebtGrams?: boolean
    fiatDebtRial?: boolean
    makingChargeOffsetPercent?: boolean
    verificationStep?: boolean
    nationalIdImageUrl?: boolean
    businessLicenseUrl?: boolean
    shopImageUrl?: boolean
    avatarFileId?: boolean
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    city?: boolean | Customer$cityArgs<ExtArgs>
    referredByAgent?: boolean | Customer$referredByAgentArgs<ExtArgs>
    avatarFile?: boolean | Customer$avatarFileArgs<ExtArgs>
  }, ExtArgs["result"]["customer"]>

  export type CustomerSelectScalar = {
    id?: boolean
    fullName?: boolean
    firstName?: boolean
    lastName?: boolean
    mobile?: boolean
    nationalCode?: boolean
    passwordHash?: boolean
    cityId?: boolean
    kind?: boolean
    phone?: boolean
    address?: boolean
    storeName?: boolean
    pasazhName?: boolean
    zone?: boolean
    memberCode?: boolean
    referredByAgentId?: boolean
    goldCreditLimitGrams?: boolean
    goldDebtGrams?: boolean
    fiatDebtRial?: boolean
    makingChargeOffsetPercent?: boolean
    verificationStep?: boolean
    nationalIdImageUrl?: boolean
    businessLicenseUrl?: boolean
    shopImageUrl?: boolean
    avatarFileId?: boolean
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type CustomerInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    city?: boolean | Customer$cityArgs<ExtArgs>
    referredByAgent?: boolean | Customer$referredByAgentArgs<ExtArgs>
    salesExpertTradingFor?: boolean | Customer$salesExpertTradingForArgs<ExtArgs>
    avatarFile?: boolean | Customer$avatarFileArgs<ExtArgs>
    addresses?: boolean | Customer$addressesArgs<ExtArgs>
    orders?: boolean | Customer$ordersArgs<ExtArgs>
    preOrders?: boolean | Customer$preOrdersArgs<ExtArgs>
    ledgerEntries?: boolean | Customer$ledgerEntriesArgs<ExtArgs>
    walletBonuses?: boolean | Customer$walletBonusesArgs<ExtArgs>
    comments?: boolean | Customer$commentsArgs<ExtArgs>
    promotions?: boolean | Customer$promotionsArgs<ExtArgs>
    notifications?: boolean | Customer$notificationsArgs<ExtArgs>
    activityLogs?: boolean | Customer$activityLogsArgs<ExtArgs>
    otpChallenges?: boolean | Customer$otpChallengesArgs<ExtArgs>
    _count?: boolean | CustomerCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type CustomerIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    city?: boolean | Customer$cityArgs<ExtArgs>
    referredByAgent?: boolean | Customer$referredByAgentArgs<ExtArgs>
    avatarFile?: boolean | Customer$avatarFileArgs<ExtArgs>
  }

  export type $CustomerPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Customer"
    objects: {
      city: Prisma.$CityPayload<ExtArgs> | null
      referredByAgent: Prisma.$AdminUserPayload<ExtArgs> | null
      /**
       * Set only on the one Customer row that acts as a sales expert's own trading
       * account (see SalesExpertProfile.tradingCustomerId). Empty for every
       * ordinary customer.
       */
      salesExpertTradingFor: Prisma.$SalesExpertProfilePayload<ExtArgs> | null
      avatarFile: Prisma.$UploadedFilePayload<ExtArgs> | null
      addresses: Prisma.$CustomerAddressPayload<ExtArgs>[]
      orders: Prisma.$OrderPayload<ExtArgs>[]
      preOrders: Prisma.$PreOrderPayload<ExtArgs>[]
      ledgerEntries: Prisma.$LedgerEntryPayload<ExtArgs>[]
      walletBonuses: Prisma.$WalletBonusPayload<ExtArgs>[]
      comments: Prisma.$CommentPayload<ExtArgs>[]
      promotions: Prisma.$PromotionPayload<ExtArgs>[]
      notifications: Prisma.$NotificationRecipientPayload<ExtArgs>[]
      activityLogs: Prisma.$CustomerActivityLogPayload<ExtArgs>[]
      otpChallenges: Prisma.$CustomerOtpPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      /**
       * ⚠️ `fullName`, `firstName` and `lastName` are kept in sync BY A DATABASE
       * TRIGGER — `customer_sync_full_name`, created in migration
       * 20260922120000_customer_name_parts. Prisma does not know about it, so a
       * write here is NOT the whole story:
       * 
       * * write the parts          -> fullName is rebuilt as "first last"
       * * write fullName only      -> the parts are re-derived from it
       * * write BOTH in one update -> THE PARTS WIN; fullName is overwritten
       * with "first last" and whatever you passed for fullName is discarded
       * 
       * So a value you wrote can differ from the value that lands in the row.
       * Re-read after writing if you need the stored value. Prefer writing the
       * parts; `fullName` exists for the legacy readers that predate D0.
       * 
       * Reference has these as two columns from the start
       * (henza_server 2020_10_01_120430_customers_table.php:18-19 fname/lname);
       * the port collapsed them, which is the D0 defect.
       */
      fullName: string
      firstName: string | null
      lastName: string | null
      mobile: string
      nationalCode: string
      passwordHash: string
      cityId: string | null
      /**
       * Legacy Customer.type — distinguishes بنکدار from مغازه دار, which the
       * BankerList / ShopkeeperList screens filter on.
       */
      kind: $Enums.CustomerKind
      /**
       * Legacy contact + shop columns, shown on the wholesale customer form and as
       * (hidden-by-default) columns in its grid.
       */
      phone: string | null
      address: string | null
      storeName: string | null
      pasazhName: string | null
      zone: string | null
      /**
       * Legacy mcode — the operator-assigned customer code.
       */
      memberCode: string | null
      referredByAgentId: string | null
      goldCreditLimitGrams: Prisma.Decimal
      goldDebtGrams: Prisma.Decimal
      fiatDebtRial: Prisma.Decimal
      /**
       * Legacy `customers.percent` — the per-customer making-charge offset. It is
       * ADDED to the variant's making charge when pricing an order line
       * (henza_pwa src/Mixins/product/index.ts:69-75:
       * getWage(v) = state.percent + v.percentage_pay)
       * and it shifts the catalogue making-charge filter bounds
       * (ApiMobileController.php:391-396,76-77). It is NOT part of the price
       * formula itself — that extra percent is ConfigStatic['product_price_extra_percent'].
       * 
       * NOT the wallet cashback rate (storefront ConfigStatic['percent'], D13) and
       * NOT the wholesale per-line charge (OrderItem.wagePercentSnapshot).
       * 
       * DB default 0 keeps every existing customer's price unchanged. The
       * reference's application-layer default for NEW customers is 3
       * (AdminController.php:338) and the field is required on create (:354).
       */
      makingChargeOffsetPercent: Prisma.Decimal
      verificationStep: $Enums.VerificationStep
      nationalIdImageUrl: string | null
      businessLicenseUrl: string | null
      shopImageUrl: string | null
      /**
       * Legacy `image_id` — the profile photo (عکس پروفایل) on the sales-agent
       * form. Legacy stored an FK to its Image table and read it back as a nested
       * `image: { id, image }`, so this is a relation, not a bare URL string.
       */
      avatarFileId: string | null
      /**
       * Legacy had TWO independent switches on a customer:
       * sts    -> may they place orders    (this field)
       * active -> is the account enabled   (isActive, below)
       * The port previously drove both from isActive; they are separate again.
       */
      canPlaceOrders: boolean
      isActive: boolean
      /**
       * Legacy archive flag — the archived list filtered on this, not on isActive.
       */
      isArchived: boolean
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["customer"]>
    composites: {}
  }

  type CustomerGetPayload<S extends boolean | null | undefined | CustomerDefaultArgs> = $Result.GetResult<Prisma.$CustomerPayload, S>

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

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

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

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

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

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

    /**
     * Create a Customer.
     * @param {CustomerCreateArgs} args - Arguments to create a Customer.
     * @example
     * // Create one Customer
     * const Customer = await prisma.customer.create({
     *   data: {
     *     // ... data to create a Customer
     *   }
     * })
     * 
     */
    create<T extends CustomerCreateArgs>(args: SelectSubset<T, CustomerCreateArgs<ExtArgs>>): Prisma__CustomerClient<$Result.GetResult<Prisma.$CustomerPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Customer.
     * @param {CustomerDeleteArgs} args - Arguments to delete one Customer.
     * @example
     * // Delete one Customer
     * const Customer = await prisma.customer.delete({
     *   where: {
     *     // ... filter to delete one Customer
     *   }
     * })
     * 
     */
    delete<T extends CustomerDeleteArgs>(args: SelectSubset<T, CustomerDeleteArgs<ExtArgs>>): Prisma__CustomerClient<$Result.GetResult<Prisma.$CustomerPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Customer.
   * 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__CustomerClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    city<T extends Customer$cityArgs<ExtArgs> = {}>(args?: Subset<T, Customer$cityArgs<ExtArgs>>): Prisma__CityClient<$Result.GetResult<Prisma.$CityPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    referredByAgent<T extends Customer$referredByAgentArgs<ExtArgs> = {}>(args?: Subset<T, Customer$referredByAgentArgs<ExtArgs>>): Prisma__AdminUserClient<$Result.GetResult<Prisma.$AdminUserPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    salesExpertTradingFor<T extends Customer$salesExpertTradingForArgs<ExtArgs> = {}>(args?: Subset<T, Customer$salesExpertTradingForArgs<ExtArgs>>): Prisma__SalesExpertProfileClient<$Result.GetResult<Prisma.$SalesExpertProfilePayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    avatarFile<T extends Customer$avatarFileArgs<ExtArgs> = {}>(args?: Subset<T, Customer$avatarFileArgs<ExtArgs>>): Prisma__UploadedFileClient<$Result.GetResult<Prisma.$UploadedFilePayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    addresses<T extends Customer$addressesArgs<ExtArgs> = {}>(args?: Subset<T, Customer$addressesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CustomerAddressPayload<ExtArgs>, T, "findMany"> | Null>
    orders<T extends Customer$ordersArgs<ExtArgs> = {}>(args?: Subset<T, Customer$ordersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$OrderPayload<ExtArgs>, T, "findMany"> | Null>
    preOrders<T extends Customer$preOrdersArgs<ExtArgs> = {}>(args?: Subset<T, Customer$preOrdersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PreOrderPayload<ExtArgs>, T, "findMany"> | Null>
    ledgerEntries<T extends Customer$ledgerEntriesArgs<ExtArgs> = {}>(args?: Subset<T, Customer$ledgerEntriesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LedgerEntryPayload<ExtArgs>, T, "findMany"> | Null>
    walletBonuses<T extends Customer$walletBonusesArgs<ExtArgs> = {}>(args?: Subset<T, Customer$walletBonusesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$WalletBonusPayload<ExtArgs>, T, "findMany"> | Null>
    comments<T extends Customer$commentsArgs<ExtArgs> = {}>(args?: Subset<T, Customer$commentsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CommentPayload<ExtArgs>, T, "findMany"> | Null>
    promotions<T extends Customer$promotionsArgs<ExtArgs> = {}>(args?: Subset<T, Customer$promotionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PromotionPayload<ExtArgs>, T, "findMany"> | Null>
    notifications<T extends Customer$notificationsArgs<ExtArgs> = {}>(args?: Subset<T, Customer$notificationsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$NotificationRecipientPayload<ExtArgs>, T, "findMany"> | Null>
    activityLogs<T extends Customer$activityLogsArgs<ExtArgs> = {}>(args?: Subset<T, Customer$activityLogsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CustomerActivityLogPayload<ExtArgs>, T, "findMany"> | Null>
    otpChallenges<T extends Customer$otpChallengesArgs<ExtArgs> = {}>(args?: Subset<T, Customer$otpChallengesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CustomerOtpPayload<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 Customer model
   */ 
  interface CustomerFieldRefs {
    readonly id: FieldRef<"Customer", 'String'>
    readonly fullName: FieldRef<"Customer", 'String'>
    readonly firstName: FieldRef<"Customer", 'String'>
    readonly lastName: FieldRef<"Customer", 'String'>
    readonly mobile: FieldRef<"Customer", 'String'>
    readonly nationalCode: FieldRef<"Customer", 'String'>
    readonly passwordHash: FieldRef<"Customer", 'String'>
    readonly cityId: FieldRef<"Customer", 'String'>
    readonly kind: FieldRef<"Customer", 'CustomerKind'>
    readonly phone: FieldRef<"Customer", 'String'>
    readonly address: FieldRef<"Customer", 'String'>
    readonly storeName: FieldRef<"Customer", 'String'>
    readonly pasazhName: FieldRef<"Customer", 'String'>
    readonly zone: FieldRef<"Customer", 'String'>
    readonly memberCode: FieldRef<"Customer", 'String'>
    readonly referredByAgentId: FieldRef<"Customer", 'String'>
    readonly goldCreditLimitGrams: FieldRef<"Customer", 'Decimal'>
    readonly goldDebtGrams: FieldRef<"Customer", 'Decimal'>
    readonly fiatDebtRial: FieldRef<"Customer", 'Decimal'>
    readonly makingChargeOffsetPercent: FieldRef<"Customer", 'Decimal'>
    readonly verificationStep: FieldRef<"Customer", 'VerificationStep'>
    readonly nationalIdImageUrl: FieldRef<"Customer", 'String'>
    readonly businessLicenseUrl: FieldRef<"Customer", 'String'>
    readonly shopImageUrl: FieldRef<"Customer", 'String'>
    readonly avatarFileId: FieldRef<"Customer", 'String'>
    readonly canPlaceOrders: FieldRef<"Customer", 'Boolean'>
    readonly isActive: FieldRef<"Customer", 'Boolean'>
    readonly isArchived: FieldRef<"Customer", 'Boolean'>
    readonly createdAt: FieldRef<"Customer", 'DateTime'>
    readonly updatedAt: FieldRef<"Customer", 'DateTime'>
  }
    

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

  /**
   * Customer findUniqueOrThrow
   */
  export type CustomerFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Customer
     */
    select?: CustomerSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerInclude<ExtArgs> | null
    /**
     * Filter, which Customer to fetch.
     */
    where: CustomerWhereUniqueInput
  }

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

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

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

  /**
   * Customer create
   */
  export type CustomerCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Customer
     */
    select?: CustomerSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerInclude<ExtArgs> | null
    /**
     * The data needed to create a Customer.
     */
    data: XOR<CustomerCreateInput, CustomerUncheckedCreateInput>
  }

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

  /**
   * Customer createManyAndReturn
   */
  export type CustomerCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Customer
     */
    select?: CustomerSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Customers.
     */
    data: CustomerCreateManyInput | CustomerCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Customer update
   */
  export type CustomerUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Customer
     */
    select?: CustomerSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerInclude<ExtArgs> | null
    /**
     * The data needed to update a Customer.
     */
    data: XOR<CustomerUpdateInput, CustomerUncheckedUpdateInput>
    /**
     * Choose, which Customer to update.
     */
    where: CustomerWhereUniqueInput
  }

  /**
   * Customer updateMany
   */
  export type CustomerUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Customers.
     */
    data: XOR<CustomerUpdateManyMutationInput, CustomerUncheckedUpdateManyInput>
    /**
     * Filter which Customers to update
     */
    where?: CustomerWhereInput
  }

  /**
   * Customer upsert
   */
  export type CustomerUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Customer
     */
    select?: CustomerSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerInclude<ExtArgs> | null
    /**
     * The filter to search for the Customer to update in case it exists.
     */
    where: CustomerWhereUniqueInput
    /**
     * In case the Customer found by the `where` argument doesn't exist, create a new Customer with this data.
     */
    create: XOR<CustomerCreateInput, CustomerUncheckedCreateInput>
    /**
     * In case the Customer was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CustomerUpdateInput, CustomerUncheckedUpdateInput>
  }

  /**
   * Customer delete
   */
  export type CustomerDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Customer
     */
    select?: CustomerSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerInclude<ExtArgs> | null
    /**
     * Filter which Customer to delete.
     */
    where: CustomerWhereUniqueInput
  }

  /**
   * Customer deleteMany
   */
  export type CustomerDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Customers to delete
     */
    where?: CustomerWhereInput
  }

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

  /**
   * Customer.referredByAgent
   */
  export type Customer$referredByAgentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AdminUser
     */
    select?: AdminUserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AdminUserInclude<ExtArgs> | null
    where?: AdminUserWhereInput
  }

  /**
   * Customer.salesExpertTradingFor
   */
  export type Customer$salesExpertTradingForArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SalesExpertProfile
     */
    select?: SalesExpertProfileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SalesExpertProfileInclude<ExtArgs> | null
    where?: SalesExpertProfileWhereInput
  }

  /**
   * Customer.avatarFile
   */
  export type Customer$avatarFileArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UploadedFile
     */
    select?: UploadedFileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UploadedFileInclude<ExtArgs> | null
    where?: UploadedFileWhereInput
  }

  /**
   * Customer.addresses
   */
  export type Customer$addressesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerAddress
     */
    select?: CustomerAddressSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerAddressInclude<ExtArgs> | null
    where?: CustomerAddressWhereInput
    orderBy?: CustomerAddressOrderByWithRelationInput | CustomerAddressOrderByWithRelationInput[]
    cursor?: CustomerAddressWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CustomerAddressScalarFieldEnum | CustomerAddressScalarFieldEnum[]
  }

  /**
   * Customer.orders
   */
  export type Customer$ordersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Order
     */
    select?: OrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderInclude<ExtArgs> | null
    where?: OrderWhereInput
    orderBy?: OrderOrderByWithRelationInput | OrderOrderByWithRelationInput[]
    cursor?: OrderWhereUniqueInput
    take?: number
    skip?: number
    distinct?: OrderScalarFieldEnum | OrderScalarFieldEnum[]
  }

  /**
   * Customer.preOrders
   */
  export type Customer$preOrdersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PreOrder
     */
    select?: PreOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PreOrderInclude<ExtArgs> | null
    where?: PreOrderWhereInput
    orderBy?: PreOrderOrderByWithRelationInput | PreOrderOrderByWithRelationInput[]
    cursor?: PreOrderWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PreOrderScalarFieldEnum | PreOrderScalarFieldEnum[]
  }

  /**
   * Customer.ledgerEntries
   */
  export type Customer$ledgerEntriesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LedgerEntry
     */
    select?: LedgerEntrySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LedgerEntryInclude<ExtArgs> | null
    where?: LedgerEntryWhereInput
    orderBy?: LedgerEntryOrderByWithRelationInput | LedgerEntryOrderByWithRelationInput[]
    cursor?: LedgerEntryWhereUniqueInput
    take?: number
    skip?: number
    distinct?: LedgerEntryScalarFieldEnum | LedgerEntryScalarFieldEnum[]
  }

  /**
   * Customer.walletBonuses
   */
  export type Customer$walletBonusesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WalletBonus
     */
    select?: WalletBonusSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WalletBonusInclude<ExtArgs> | null
    where?: WalletBonusWhereInput
    orderBy?: WalletBonusOrderByWithRelationInput | WalletBonusOrderByWithRelationInput[]
    cursor?: WalletBonusWhereUniqueInput
    take?: number
    skip?: number
    distinct?: WalletBonusScalarFieldEnum | WalletBonusScalarFieldEnum[]
  }

  /**
   * Customer.comments
   */
  export type Customer$commentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Comment
     */
    select?: CommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommentInclude<ExtArgs> | null
    where?: CommentWhereInput
    orderBy?: CommentOrderByWithRelationInput | CommentOrderByWithRelationInput[]
    cursor?: CommentWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CommentScalarFieldEnum | CommentScalarFieldEnum[]
  }

  /**
   * Customer.promotions
   */
  export type Customer$promotionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Promotion
     */
    select?: PromotionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PromotionInclude<ExtArgs> | null
    where?: PromotionWhereInput
    orderBy?: PromotionOrderByWithRelationInput | PromotionOrderByWithRelationInput[]
    cursor?: PromotionWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PromotionScalarFieldEnum | PromotionScalarFieldEnum[]
  }

  /**
   * Customer.notifications
   */
  export type Customer$notificationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NotificationRecipient
     */
    select?: NotificationRecipientSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationRecipientInclude<ExtArgs> | null
    where?: NotificationRecipientWhereInput
    orderBy?: NotificationRecipientOrderByWithRelationInput | NotificationRecipientOrderByWithRelationInput[]
    cursor?: NotificationRecipientWhereUniqueInput
    take?: number
    skip?: number
    distinct?: NotificationRecipientScalarFieldEnum | NotificationRecipientScalarFieldEnum[]
  }

  /**
   * Customer.activityLogs
   */
  export type Customer$activityLogsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerActivityLog
     */
    select?: CustomerActivityLogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerActivityLogInclude<ExtArgs> | null
    where?: CustomerActivityLogWhereInput
    orderBy?: CustomerActivityLogOrderByWithRelationInput | CustomerActivityLogOrderByWithRelationInput[]
    cursor?: CustomerActivityLogWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CustomerActivityLogScalarFieldEnum | CustomerActivityLogScalarFieldEnum[]
  }

  /**
   * Customer.otpChallenges
   */
  export type Customer$otpChallengesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerOtp
     */
    select?: CustomerOtpSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerOtpInclude<ExtArgs> | null
    where?: CustomerOtpWhereInput
    orderBy?: CustomerOtpOrderByWithRelationInput | CustomerOtpOrderByWithRelationInput[]
    cursor?: CustomerOtpWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CustomerOtpScalarFieldEnum | CustomerOtpScalarFieldEnum[]
  }

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


  /**
   * Model CustomerAddress
   */

  export type AggregateCustomerAddress = {
    _count: CustomerAddressCountAggregateOutputType | null
    _min: CustomerAddressMinAggregateOutputType | null
    _max: CustomerAddressMaxAggregateOutputType | null
  }

  export type CustomerAddressMinAggregateOutputType = {
    id: string | null
    customerId: string | null
    cityId: string | null
    addressLine: string | null
    isDefault: boolean | null
  }

  export type CustomerAddressMaxAggregateOutputType = {
    id: string | null
    customerId: string | null
    cityId: string | null
    addressLine: string | null
    isDefault: boolean | null
  }

  export type CustomerAddressCountAggregateOutputType = {
    id: number
    customerId: number
    cityId: number
    addressLine: number
    isDefault: number
    _all: number
  }


  export type CustomerAddressMinAggregateInputType = {
    id?: true
    customerId?: true
    cityId?: true
    addressLine?: true
    isDefault?: true
  }

  export type CustomerAddressMaxAggregateInputType = {
    id?: true
    customerId?: true
    cityId?: true
    addressLine?: true
    isDefault?: true
  }

  export type CustomerAddressCountAggregateInputType = {
    id?: true
    customerId?: true
    cityId?: true
    addressLine?: true
    isDefault?: true
    _all?: true
  }

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

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




  export type CustomerAddressGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CustomerAddressWhereInput
    orderBy?: CustomerAddressOrderByWithAggregationInput | CustomerAddressOrderByWithAggregationInput[]
    by: CustomerAddressScalarFieldEnum[] | CustomerAddressScalarFieldEnum
    having?: CustomerAddressScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CustomerAddressCountAggregateInputType | true
    _min?: CustomerAddressMinAggregateInputType
    _max?: CustomerAddressMaxAggregateInputType
  }

  export type CustomerAddressGroupByOutputType = {
    id: string
    customerId: string
    cityId: string | null
    addressLine: string
    isDefault: boolean
    _count: CustomerAddressCountAggregateOutputType | null
    _min: CustomerAddressMinAggregateOutputType | null
    _max: CustomerAddressMaxAggregateOutputType | null
  }

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


  export type CustomerAddressSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    customerId?: boolean
    cityId?: boolean
    addressLine?: boolean
    isDefault?: boolean
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
    city?: boolean | CustomerAddress$cityArgs<ExtArgs>
  }, ExtArgs["result"]["customerAddress"]>

  export type CustomerAddressSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    customerId?: boolean
    cityId?: boolean
    addressLine?: boolean
    isDefault?: boolean
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
    city?: boolean | CustomerAddress$cityArgs<ExtArgs>
  }, ExtArgs["result"]["customerAddress"]>

  export type CustomerAddressSelectScalar = {
    id?: boolean
    customerId?: boolean
    cityId?: boolean
    addressLine?: boolean
    isDefault?: boolean
  }

  export type CustomerAddressInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
    city?: boolean | CustomerAddress$cityArgs<ExtArgs>
  }
  export type CustomerAddressIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
    city?: boolean | CustomerAddress$cityArgs<ExtArgs>
  }

  export type $CustomerAddressPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "CustomerAddress"
    objects: {
      customer: Prisma.$CustomerPayload<ExtArgs>
      city: Prisma.$CityPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      customerId: string
      cityId: string | null
      addressLine: string
      isDefault: boolean
    }, ExtArgs["result"]["customerAddress"]>
    composites: {}
  }

  type CustomerAddressGetPayload<S extends boolean | null | undefined | CustomerAddressDefaultArgs> = $Result.GetResult<Prisma.$CustomerAddressPayload, S>

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

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

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

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

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

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

    /**
     * Create a CustomerAddress.
     * @param {CustomerAddressCreateArgs} args - Arguments to create a CustomerAddress.
     * @example
     * // Create one CustomerAddress
     * const CustomerAddress = await prisma.customerAddress.create({
     *   data: {
     *     // ... data to create a CustomerAddress
     *   }
     * })
     * 
     */
    create<T extends CustomerAddressCreateArgs>(args: SelectSubset<T, CustomerAddressCreateArgs<ExtArgs>>): Prisma__CustomerAddressClient<$Result.GetResult<Prisma.$CustomerAddressPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a CustomerAddress.
     * @param {CustomerAddressDeleteArgs} args - Arguments to delete one CustomerAddress.
     * @example
     * // Delete one CustomerAddress
     * const CustomerAddress = await prisma.customerAddress.delete({
     *   where: {
     *     // ... filter to delete one CustomerAddress
     *   }
     * })
     * 
     */
    delete<T extends CustomerAddressDeleteArgs>(args: SelectSubset<T, CustomerAddressDeleteArgs<ExtArgs>>): Prisma__CustomerAddressClient<$Result.GetResult<Prisma.$CustomerAddressPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for CustomerAddress.
   * 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__CustomerAddressClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    customer<T extends CustomerDefaultArgs<ExtArgs> = {}>(args?: Subset<T, CustomerDefaultArgs<ExtArgs>>): Prisma__CustomerClient<$Result.GetResult<Prisma.$CustomerPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    city<T extends CustomerAddress$cityArgs<ExtArgs> = {}>(args?: Subset<T, CustomerAddress$cityArgs<ExtArgs>>): Prisma__CityClient<$Result.GetResult<Prisma.$CityPayload<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 CustomerAddress model
   */ 
  interface CustomerAddressFieldRefs {
    readonly id: FieldRef<"CustomerAddress", 'String'>
    readonly customerId: FieldRef<"CustomerAddress", 'String'>
    readonly cityId: FieldRef<"CustomerAddress", 'String'>
    readonly addressLine: FieldRef<"CustomerAddress", 'String'>
    readonly isDefault: FieldRef<"CustomerAddress", 'Boolean'>
  }
    

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

  /**
   * CustomerAddress findUniqueOrThrow
   */
  export type CustomerAddressFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerAddress
     */
    select?: CustomerAddressSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerAddressInclude<ExtArgs> | null
    /**
     * Filter, which CustomerAddress to fetch.
     */
    where: CustomerAddressWhereUniqueInput
  }

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

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

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

  /**
   * CustomerAddress create
   */
  export type CustomerAddressCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerAddress
     */
    select?: CustomerAddressSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerAddressInclude<ExtArgs> | null
    /**
     * The data needed to create a CustomerAddress.
     */
    data: XOR<CustomerAddressCreateInput, CustomerAddressUncheckedCreateInput>
  }

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

  /**
   * CustomerAddress createManyAndReturn
   */
  export type CustomerAddressCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerAddress
     */
    select?: CustomerAddressSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many CustomerAddresses.
     */
    data: CustomerAddressCreateManyInput | CustomerAddressCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerAddressIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * CustomerAddress update
   */
  export type CustomerAddressUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerAddress
     */
    select?: CustomerAddressSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerAddressInclude<ExtArgs> | null
    /**
     * The data needed to update a CustomerAddress.
     */
    data: XOR<CustomerAddressUpdateInput, CustomerAddressUncheckedUpdateInput>
    /**
     * Choose, which CustomerAddress to update.
     */
    where: CustomerAddressWhereUniqueInput
  }

  /**
   * CustomerAddress updateMany
   */
  export type CustomerAddressUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update CustomerAddresses.
     */
    data: XOR<CustomerAddressUpdateManyMutationInput, CustomerAddressUncheckedUpdateManyInput>
    /**
     * Filter which CustomerAddresses to update
     */
    where?: CustomerAddressWhereInput
  }

  /**
   * CustomerAddress upsert
   */
  export type CustomerAddressUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerAddress
     */
    select?: CustomerAddressSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerAddressInclude<ExtArgs> | null
    /**
     * The filter to search for the CustomerAddress to update in case it exists.
     */
    where: CustomerAddressWhereUniqueInput
    /**
     * In case the CustomerAddress found by the `where` argument doesn't exist, create a new CustomerAddress with this data.
     */
    create: XOR<CustomerAddressCreateInput, CustomerAddressUncheckedCreateInput>
    /**
     * In case the CustomerAddress was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CustomerAddressUpdateInput, CustomerAddressUncheckedUpdateInput>
  }

  /**
   * CustomerAddress delete
   */
  export type CustomerAddressDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerAddress
     */
    select?: CustomerAddressSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerAddressInclude<ExtArgs> | null
    /**
     * Filter which CustomerAddress to delete.
     */
    where: CustomerAddressWhereUniqueInput
  }

  /**
   * CustomerAddress deleteMany
   */
  export type CustomerAddressDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CustomerAddresses to delete
     */
    where?: CustomerAddressWhereInput
  }

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

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


  /**
   * Model Branch
   */

  export type AggregateBranch = {
    _count: BranchCountAggregateOutputType | null
    _min: BranchMinAggregateOutputType | null
    _max: BranchMaxAggregateOutputType | null
  }

  export type BranchMinAggregateOutputType = {
    id: string | null
    name: string | null
    address: string | null
    phone: string | null
    isActive: boolean | null
    cityId: string | null
  }

  export type BranchMaxAggregateOutputType = {
    id: string | null
    name: string | null
    address: string | null
    phone: string | null
    isActive: boolean | null
    cityId: string | null
  }

  export type BranchCountAggregateOutputType = {
    id: number
    name: number
    address: number
    phone: number
    isActive: number
    cityId: number
    _all: number
  }


  export type BranchMinAggregateInputType = {
    id?: true
    name?: true
    address?: true
    phone?: true
    isActive?: true
    cityId?: true
  }

  export type BranchMaxAggregateInputType = {
    id?: true
    name?: true
    address?: true
    phone?: true
    isActive?: true
    cityId?: true
  }

  export type BranchCountAggregateInputType = {
    id?: true
    name?: true
    address?: true
    phone?: true
    isActive?: true
    cityId?: true
    _all?: true
  }

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

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




  export type BranchGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: BranchWhereInput
    orderBy?: BranchOrderByWithAggregationInput | BranchOrderByWithAggregationInput[]
    by: BranchScalarFieldEnum[] | BranchScalarFieldEnum
    having?: BranchScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: BranchCountAggregateInputType | true
    _min?: BranchMinAggregateInputType
    _max?: BranchMaxAggregateInputType
  }

  export type BranchGroupByOutputType = {
    id: string
    name: string
    address: string | null
    phone: string | null
    isActive: boolean
    cityId: string | null
    _count: BranchCountAggregateOutputType | null
    _min: BranchMinAggregateOutputType | null
    _max: BranchMaxAggregateOutputType | null
  }

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


  export type BranchSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    address?: boolean
    phone?: boolean
    isActive?: boolean
    cityId?: boolean
    city?: boolean | Branch$cityArgs<ExtArgs>
    adminUsers?: boolean | Branch$adminUsersArgs<ExtArgs>
    orders?: boolean | Branch$ordersArgs<ExtArgs>
    allocations?: boolean | Branch$allocationsArgs<ExtArgs>
    _count?: boolean | BranchCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["branch"]>

  export type BranchSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    address?: boolean
    phone?: boolean
    isActive?: boolean
    cityId?: boolean
    city?: boolean | Branch$cityArgs<ExtArgs>
  }, ExtArgs["result"]["branch"]>

  export type BranchSelectScalar = {
    id?: boolean
    name?: boolean
    address?: boolean
    phone?: boolean
    isActive?: boolean
    cityId?: boolean
  }

  export type BranchInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    city?: boolean | Branch$cityArgs<ExtArgs>
    adminUsers?: boolean | Branch$adminUsersArgs<ExtArgs>
    orders?: boolean | Branch$ordersArgs<ExtArgs>
    allocations?: boolean | Branch$allocationsArgs<ExtArgs>
    _count?: boolean | BranchCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type BranchIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    city?: boolean | Branch$cityArgs<ExtArgs>
  }

  export type $BranchPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Branch"
    objects: {
      city: Prisma.$CityPayload<ExtArgs> | null
      adminUsers: Prisma.$AdminUserPayload<ExtArgs>[]
      orders: Prisma.$OrderPayload<ExtArgs>[]
      allocations: Prisma.$BranchAllocationPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      /**
       * Legacy Branch.address / phone — both are columns in the branch grid.
       */
      address: string | null
      phone: string | null
      /**
       * Legacy GET branch/active/{id} toggles this.
       */
      isActive: boolean
      cityId: string | null
    }, ExtArgs["result"]["branch"]>
    composites: {}
  }

  type BranchGetPayload<S extends boolean | null | undefined | BranchDefaultArgs> = $Result.GetResult<Prisma.$BranchPayload, S>

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

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

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

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

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

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

    /**
     * Create a Branch.
     * @param {BranchCreateArgs} args - Arguments to create a Branch.
     * @example
     * // Create one Branch
     * const Branch = await prisma.branch.create({
     *   data: {
     *     // ... data to create a Branch
     *   }
     * })
     * 
     */
    create<T extends BranchCreateArgs>(args: SelectSubset<T, BranchCreateArgs<ExtArgs>>): Prisma__BranchClient<$Result.GetResult<Prisma.$BranchPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Branch.
     * @param {BranchDeleteArgs} args - Arguments to delete one Branch.
     * @example
     * // Delete one Branch
     * const Branch = await prisma.branch.delete({
     *   where: {
     *     // ... filter to delete one Branch
     *   }
     * })
     * 
     */
    delete<T extends BranchDeleteArgs>(args: SelectSubset<T, BranchDeleteArgs<ExtArgs>>): Prisma__BranchClient<$Result.GetResult<Prisma.$BranchPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Branch.
   * 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__BranchClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    city<T extends Branch$cityArgs<ExtArgs> = {}>(args?: Subset<T, Branch$cityArgs<ExtArgs>>): Prisma__CityClient<$Result.GetResult<Prisma.$CityPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    adminUsers<T extends Branch$adminUsersArgs<ExtArgs> = {}>(args?: Subset<T, Branch$adminUsersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AdminUserPayload<ExtArgs>, T, "findMany"> | Null>
    orders<T extends Branch$ordersArgs<ExtArgs> = {}>(args?: Subset<T, Branch$ordersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$OrderPayload<ExtArgs>, T, "findMany"> | Null>
    allocations<T extends Branch$allocationsArgs<ExtArgs> = {}>(args?: Subset<T, Branch$allocationsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$BranchAllocationPayload<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 Branch model
   */ 
  interface BranchFieldRefs {
    readonly id: FieldRef<"Branch", 'String'>
    readonly name: FieldRef<"Branch", 'String'>
    readonly address: FieldRef<"Branch", 'String'>
    readonly phone: FieldRef<"Branch", 'String'>
    readonly isActive: FieldRef<"Branch", 'Boolean'>
    readonly cityId: FieldRef<"Branch", 'String'>
  }
    

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

  /**
   * Branch findUniqueOrThrow
   */
  export type BranchFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Branch
     */
    select?: BranchSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchInclude<ExtArgs> | null
    /**
     * Filter, which Branch to fetch.
     */
    where: BranchWhereUniqueInput
  }

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

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

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

  /**
   * Branch create
   */
  export type BranchCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Branch
     */
    select?: BranchSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchInclude<ExtArgs> | null
    /**
     * The data needed to create a Branch.
     */
    data: XOR<BranchCreateInput, BranchUncheckedCreateInput>
  }

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

  /**
   * Branch createManyAndReturn
   */
  export type BranchCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Branch
     */
    select?: BranchSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Branches.
     */
    data: BranchCreateManyInput | BranchCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Branch update
   */
  export type BranchUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Branch
     */
    select?: BranchSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchInclude<ExtArgs> | null
    /**
     * The data needed to update a Branch.
     */
    data: XOR<BranchUpdateInput, BranchUncheckedUpdateInput>
    /**
     * Choose, which Branch to update.
     */
    where: BranchWhereUniqueInput
  }

  /**
   * Branch updateMany
   */
  export type BranchUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Branches.
     */
    data: XOR<BranchUpdateManyMutationInput, BranchUncheckedUpdateManyInput>
    /**
     * Filter which Branches to update
     */
    where?: BranchWhereInput
  }

  /**
   * Branch upsert
   */
  export type BranchUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Branch
     */
    select?: BranchSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchInclude<ExtArgs> | null
    /**
     * The filter to search for the Branch to update in case it exists.
     */
    where: BranchWhereUniqueInput
    /**
     * In case the Branch found by the `where` argument doesn't exist, create a new Branch with this data.
     */
    create: XOR<BranchCreateInput, BranchUncheckedCreateInput>
    /**
     * In case the Branch was found with the provided `where` argument, update it with this data.
     */
    update: XOR<BranchUpdateInput, BranchUncheckedUpdateInput>
  }

  /**
   * Branch delete
   */
  export type BranchDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Branch
     */
    select?: BranchSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchInclude<ExtArgs> | null
    /**
     * Filter which Branch to delete.
     */
    where: BranchWhereUniqueInput
  }

  /**
   * Branch deleteMany
   */
  export type BranchDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Branches to delete
     */
    where?: BranchWhereInput
  }

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

  /**
   * Branch.adminUsers
   */
  export type Branch$adminUsersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AdminUser
     */
    select?: AdminUserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AdminUserInclude<ExtArgs> | null
    where?: AdminUserWhereInput
    orderBy?: AdminUserOrderByWithRelationInput | AdminUserOrderByWithRelationInput[]
    cursor?: AdminUserWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AdminUserScalarFieldEnum | AdminUserScalarFieldEnum[]
  }

  /**
   * Branch.orders
   */
  export type Branch$ordersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Order
     */
    select?: OrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderInclude<ExtArgs> | null
    where?: OrderWhereInput
    orderBy?: OrderOrderByWithRelationInput | OrderOrderByWithRelationInput[]
    cursor?: OrderWhereUniqueInput
    take?: number
    skip?: number
    distinct?: OrderScalarFieldEnum | OrderScalarFieldEnum[]
  }

  /**
   * Branch.allocations
   */
  export type Branch$allocationsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BranchAllocation
     */
    select?: BranchAllocationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchAllocationInclude<ExtArgs> | null
    where?: BranchAllocationWhereInput
    orderBy?: BranchAllocationOrderByWithRelationInput | BranchAllocationOrderByWithRelationInput[]
    cursor?: BranchAllocationWhereUniqueInput
    take?: number
    skip?: number
    distinct?: BranchAllocationScalarFieldEnum | BranchAllocationScalarFieldEnum[]
  }

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


  /**
   * Model Workshop
   */

  export type AggregateWorkshop = {
    _count: WorkshopCountAggregateOutputType | null
    _min: WorkshopMinAggregateOutputType | null
    _max: WorkshopMaxAggregateOutputType | null
  }

  export type WorkshopMinAggregateOutputType = {
    id: string | null
    name: string | null
    address: string | null
    phone: string | null
    supervisorId: string | null
    isActive: boolean | null
  }

  export type WorkshopMaxAggregateOutputType = {
    id: string | null
    name: string | null
    address: string | null
    phone: string | null
    supervisorId: string | null
    isActive: boolean | null
  }

  export type WorkshopCountAggregateOutputType = {
    id: number
    name: number
    address: number
    phone: number
    supervisorId: number
    isActive: number
    _all: number
  }


  export type WorkshopMinAggregateInputType = {
    id?: true
    name?: true
    address?: true
    phone?: true
    supervisorId?: true
    isActive?: true
  }

  export type WorkshopMaxAggregateInputType = {
    id?: true
    name?: true
    address?: true
    phone?: true
    supervisorId?: true
    isActive?: true
  }

  export type WorkshopCountAggregateInputType = {
    id?: true
    name?: true
    address?: true
    phone?: true
    supervisorId?: true
    isActive?: true
    _all?: true
  }

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

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




  export type WorkshopGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: WorkshopWhereInput
    orderBy?: WorkshopOrderByWithAggregationInput | WorkshopOrderByWithAggregationInput[]
    by: WorkshopScalarFieldEnum[] | WorkshopScalarFieldEnum
    having?: WorkshopScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: WorkshopCountAggregateInputType | true
    _min?: WorkshopMinAggregateInputType
    _max?: WorkshopMaxAggregateInputType
  }

  export type WorkshopGroupByOutputType = {
    id: string
    name: string
    address: string | null
    phone: string | null
    supervisorId: string | null
    isActive: boolean
    _count: WorkshopCountAggregateOutputType | null
    _min: WorkshopMinAggregateOutputType | null
    _max: WorkshopMaxAggregateOutputType | null
  }

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


  export type WorkshopSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    address?: boolean
    phone?: boolean
    supervisorId?: boolean
    isActive?: boolean
    supervisor?: boolean | Workshop$supervisorArgs<ExtArgs>
    preOrders?: boolean | Workshop$preOrdersArgs<ExtArgs>
    _count?: boolean | WorkshopCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["workshop"]>

  export type WorkshopSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    name?: boolean
    address?: boolean
    phone?: boolean
    supervisorId?: boolean
    isActive?: boolean
    supervisor?: boolean | Workshop$supervisorArgs<ExtArgs>
  }, ExtArgs["result"]["workshop"]>

  export type WorkshopSelectScalar = {
    id?: boolean
    name?: boolean
    address?: boolean
    phone?: boolean
    supervisorId?: boolean
    isActive?: boolean
  }

  export type WorkshopInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    supervisor?: boolean | Workshop$supervisorArgs<ExtArgs>
    preOrders?: boolean | Workshop$preOrdersArgs<ExtArgs>
    _count?: boolean | WorkshopCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type WorkshopIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    supervisor?: boolean | Workshop$supervisorArgs<ExtArgs>
  }

  export type $WorkshopPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Workshop"
    objects: {
      supervisor: Prisma.$AdminUserPayload<ExtArgs> | null
      preOrders: Prisma.$PreOrderPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      name: string
      /**
       * Legacy Workshop.address / phone — both are columns in the workshop grid.
       */
      address: string | null
      phone: string | null
      /**
       * The supervisor created alongside the workshop by the legacy Add form.
       */
      supervisorId: string | null
      isActive: boolean
    }, ExtArgs["result"]["workshop"]>
    composites: {}
  }

  type WorkshopGetPayload<S extends boolean | null | undefined | WorkshopDefaultArgs> = $Result.GetResult<Prisma.$WorkshopPayload, S>

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

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

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

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

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

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

    /**
     * Create a Workshop.
     * @param {WorkshopCreateArgs} args - Arguments to create a Workshop.
     * @example
     * // Create one Workshop
     * const Workshop = await prisma.workshop.create({
     *   data: {
     *     // ... data to create a Workshop
     *   }
     * })
     * 
     */
    create<T extends WorkshopCreateArgs>(args: SelectSubset<T, WorkshopCreateArgs<ExtArgs>>): Prisma__WorkshopClient<$Result.GetResult<Prisma.$WorkshopPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Workshop.
     * @param {WorkshopDeleteArgs} args - Arguments to delete one Workshop.
     * @example
     * // Delete one Workshop
     * const Workshop = await prisma.workshop.delete({
     *   where: {
     *     // ... filter to delete one Workshop
     *   }
     * })
     * 
     */
    delete<T extends WorkshopDeleteArgs>(args: SelectSubset<T, WorkshopDeleteArgs<ExtArgs>>): Prisma__WorkshopClient<$Result.GetResult<Prisma.$WorkshopPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Workshop.
   * 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__WorkshopClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    supervisor<T extends Workshop$supervisorArgs<ExtArgs> = {}>(args?: Subset<T, Workshop$supervisorArgs<ExtArgs>>): Prisma__AdminUserClient<$Result.GetResult<Prisma.$AdminUserPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    preOrders<T extends Workshop$preOrdersArgs<ExtArgs> = {}>(args?: Subset<T, Workshop$preOrdersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PreOrderPayload<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 Workshop model
   */ 
  interface WorkshopFieldRefs {
    readonly id: FieldRef<"Workshop", 'String'>
    readonly name: FieldRef<"Workshop", 'String'>
    readonly address: FieldRef<"Workshop", 'String'>
    readonly phone: FieldRef<"Workshop", 'String'>
    readonly supervisorId: FieldRef<"Workshop", 'String'>
    readonly isActive: FieldRef<"Workshop", 'Boolean'>
  }
    

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

  /**
   * Workshop findUniqueOrThrow
   */
  export type WorkshopFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Workshop
     */
    select?: WorkshopSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WorkshopInclude<ExtArgs> | null
    /**
     * Filter, which Workshop to fetch.
     */
    where: WorkshopWhereUniqueInput
  }

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

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

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

  /**
   * Workshop create
   */
  export type WorkshopCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Workshop
     */
    select?: WorkshopSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WorkshopInclude<ExtArgs> | null
    /**
     * The data needed to create a Workshop.
     */
    data: XOR<WorkshopCreateInput, WorkshopUncheckedCreateInput>
  }

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

  /**
   * Workshop createManyAndReturn
   */
  export type WorkshopCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Workshop
     */
    select?: WorkshopSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Workshops.
     */
    data: WorkshopCreateManyInput | WorkshopCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WorkshopIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Workshop update
   */
  export type WorkshopUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Workshop
     */
    select?: WorkshopSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WorkshopInclude<ExtArgs> | null
    /**
     * The data needed to update a Workshop.
     */
    data: XOR<WorkshopUpdateInput, WorkshopUncheckedUpdateInput>
    /**
     * Choose, which Workshop to update.
     */
    where: WorkshopWhereUniqueInput
  }

  /**
   * Workshop updateMany
   */
  export type WorkshopUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Workshops.
     */
    data: XOR<WorkshopUpdateManyMutationInput, WorkshopUncheckedUpdateManyInput>
    /**
     * Filter which Workshops to update
     */
    where?: WorkshopWhereInput
  }

  /**
   * Workshop upsert
   */
  export type WorkshopUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Workshop
     */
    select?: WorkshopSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WorkshopInclude<ExtArgs> | null
    /**
     * The filter to search for the Workshop to update in case it exists.
     */
    where: WorkshopWhereUniqueInput
    /**
     * In case the Workshop found by the `where` argument doesn't exist, create a new Workshop with this data.
     */
    create: XOR<WorkshopCreateInput, WorkshopUncheckedCreateInput>
    /**
     * In case the Workshop was found with the provided `where` argument, update it with this data.
     */
    update: XOR<WorkshopUpdateInput, WorkshopUncheckedUpdateInput>
  }

  /**
   * Workshop delete
   */
  export type WorkshopDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Workshop
     */
    select?: WorkshopSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WorkshopInclude<ExtArgs> | null
    /**
     * Filter which Workshop to delete.
     */
    where: WorkshopWhereUniqueInput
  }

  /**
   * Workshop deleteMany
   */
  export type WorkshopDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Workshops to delete
     */
    where?: WorkshopWhereInput
  }

  /**
   * Workshop.supervisor
   */
  export type Workshop$supervisorArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AdminUser
     */
    select?: AdminUserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AdminUserInclude<ExtArgs> | null
    where?: AdminUserWhereInput
  }

  /**
   * Workshop.preOrders
   */
  export type Workshop$preOrdersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PreOrder
     */
    select?: PreOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PreOrderInclude<ExtArgs> | null
    where?: PreOrderWhereInput
    orderBy?: PreOrderOrderByWithRelationInput | PreOrderOrderByWithRelationInput[]
    cursor?: PreOrderWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PreOrderScalarFieldEnum | PreOrderScalarFieldEnum[]
  }

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


  /**
   * Model Category
   */

  export type AggregateCategory = {
    _count: CategoryCountAggregateOutputType | null
    _avg: CategoryAvgAggregateOutputType | null
    _sum: CategorySumAggregateOutputType | null
    _min: CategoryMinAggregateOutputType | null
    _max: CategoryMaxAggregateOutputType | null
  }

  export type CategoryAvgAggregateOutputType = {
    type: number | null
  }

  export type CategorySumAggregateOutputType = {
    type: number | null
  }

  export type CategoryMinAggregateOutputType = {
    id: string | null
    title: string | null
    type: number | null
    imageUrl: string | null
    iconUrl: string | null
    metaTag: string | null
    description: string | null
    parentId: string | null
  }

  export type CategoryMaxAggregateOutputType = {
    id: string | null
    title: string | null
    type: number | null
    imageUrl: string | null
    iconUrl: string | null
    metaTag: string | null
    description: string | null
    parentId: string | null
  }

  export type CategoryCountAggregateOutputType = {
    id: number
    title: number
    type: number
    imageUrl: number
    iconUrl: number
    metaTag: number
    description: number
    parentId: number
    _all: number
  }


  export type CategoryAvgAggregateInputType = {
    type?: true
  }

  export type CategorySumAggregateInputType = {
    type?: true
  }

  export type CategoryMinAggregateInputType = {
    id?: true
    title?: true
    type?: true
    imageUrl?: true
    iconUrl?: true
    metaTag?: true
    description?: true
    parentId?: true
  }

  export type CategoryMaxAggregateInputType = {
    id?: true
    title?: true
    type?: true
    imageUrl?: true
    iconUrl?: true
    metaTag?: true
    description?: true
    parentId?: true
  }

  export type CategoryCountAggregateInputType = {
    id?: true
    title?: true
    type?: true
    imageUrl?: true
    iconUrl?: true
    metaTag?: true
    description?: true
    parentId?: 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 average
    **/
    _avg?: CategoryAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: CategorySumAggregateInputType
    /**
     * {@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
    _avg?: CategoryAvgAggregateInputType
    _sum?: CategorySumAggregateInputType
    _min?: CategoryMinAggregateInputType
    _max?: CategoryMaxAggregateInputType
  }

  export type CategoryGroupByOutputType = {
    id: string
    title: string
    type: number
    imageUrl: string | null
    iconUrl: string | null
    metaTag: string | null
    description: string | null
    parentId: string | null
    _count: CategoryCountAggregateOutputType | null
    _avg: CategoryAvgAggregateOutputType | null
    _sum: CategorySumAggregateOutputType | 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
    title?: boolean
    type?: boolean
    imageUrl?: boolean
    iconUrl?: boolean
    metaTag?: boolean
    description?: boolean
    parentId?: boolean
    parent?: boolean | Category$parentArgs<ExtArgs>
    children?: boolean | Category$childrenArgs<ExtArgs>
    products?: boolean | Category$productsArgs<ExtArgs>
    promotions?: boolean | Category$promotionsArgs<ExtArgs>
    _count?: boolean | CategoryCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["category"]>

  export type CategorySelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    type?: boolean
    imageUrl?: boolean
    iconUrl?: boolean
    metaTag?: boolean
    description?: boolean
    parentId?: boolean
    parent?: boolean | Category$parentArgs<ExtArgs>
  }, ExtArgs["result"]["category"]>

  export type CategorySelectScalar = {
    id?: boolean
    title?: boolean
    type?: boolean
    imageUrl?: boolean
    iconUrl?: boolean
    metaTag?: boolean
    description?: boolean
    parentId?: boolean
  }

  export type CategoryInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    parent?: boolean | Category$parentArgs<ExtArgs>
    children?: boolean | Category$childrenArgs<ExtArgs>
    products?: boolean | Category$productsArgs<ExtArgs>
    promotions?: boolean | Category$promotionsArgs<ExtArgs>
    _count?: boolean | CategoryCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type CategoryIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    parent?: boolean | Category$parentArgs<ExtArgs>
  }

  export type $CategoryPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Category"
    objects: {
      parent: Prisma.$CategoryPayload<ExtArgs> | null
      children: Prisma.$CategoryPayload<ExtArgs>[]
      products: Prisma.$ProductPayload<ExtArgs>[]
      promotions: Prisma.$PromotionPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      title: string
      /**
       * Legacy Category.type — which storefront the category belongs to:
       * 1 سایت | 2 اپلیکشن موبایل. Drives the "type_str" grid column.
       */
      type: number
      /**
       * Legacy Category.image / icon — the grid renders the image, the storefront the icon.
       */
      imageUrl: string | null
      iconUrl: string | null
      /**
       * Legacy meta tag + description, used for SEO on the site categories.
       */
      metaTag: string | null
      description: string | null
      parentId: string | null
    }, 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>

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

    /**
     * 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"
    parent<T extends Category$parentArgs<ExtArgs> = {}>(args?: Subset<T, Category$parentArgs<ExtArgs>>): Prisma__CategoryClient<$Result.GetResult<Prisma.$CategoryPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    children<T extends Category$childrenArgs<ExtArgs> = {}>(args?: Subset<T, Category$childrenArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CategoryPayload<ExtArgs>, T, "findMany"> | Null>
    products<T extends Category$productsArgs<ExtArgs> = {}>(args?: Subset<T, Category$productsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ProductPayload<ExtArgs>, T, "findMany"> | Null>
    promotions<T extends Category$promotionsArgs<ExtArgs> = {}>(args?: Subset<T, Category$promotionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PromotionPayload<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 title: FieldRef<"Category", 'String'>
    readonly type: FieldRef<"Category", 'Int'>
    readonly imageUrl: FieldRef<"Category", 'String'>
    readonly iconUrl: FieldRef<"Category", 'String'>
    readonly metaTag: FieldRef<"Category", 'String'>
    readonly description: FieldRef<"Category", 'String'>
    readonly parentId: FieldRef<"Category", 'String'>
  }
    

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

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

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

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

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

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

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

  /**
   * Category createManyAndReturn
   */
  export type CategoryCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Category
     */
    select?: CategorySelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Categories.
     */
    data: CategoryCreateManyInput | CategoryCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CategoryIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * 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.parent
   */
  export type Category$parentArgs<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
    where?: CategoryWhereInput
  }

  /**
   * Category.children
   */
  export type Category$childrenArgs<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
    where?: CategoryWhereInput
    orderBy?: CategoryOrderByWithRelationInput | CategoryOrderByWithRelationInput[]
    cursor?: CategoryWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CategoryScalarFieldEnum | CategoryScalarFieldEnum[]
  }

  /**
   * Category.products
   */
  export type Category$productsArgs<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
    where?: ProductWhereInput
    orderBy?: ProductOrderByWithRelationInput | ProductOrderByWithRelationInput[]
    cursor?: ProductWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ProductScalarFieldEnum | ProductScalarFieldEnum[]
  }

  /**
   * Category.promotions
   */
  export type Category$promotionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Promotion
     */
    select?: PromotionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PromotionInclude<ExtArgs> | null
    where?: PromotionWhereInput
    orderBy?: PromotionOrderByWithRelationInput | PromotionOrderByWithRelationInput[]
    cursor?: PromotionWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PromotionScalarFieldEnum | PromotionScalarFieldEnum[]
  }

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

  export type AggregateBrand = {
    _count: BrandCountAggregateOutputType | null
    _min: BrandMinAggregateOutputType | null
    _max: BrandMaxAggregateOutputType | null
  }

  export type BrandMinAggregateOutputType = {
    id: string | null
    title: string | null
  }

  export type BrandMaxAggregateOutputType = {
    id: string | null
    title: string | null
  }

  export type BrandCountAggregateOutputType = {
    id: number
    title: number
    _all: number
  }


  export type BrandMinAggregateInputType = {
    id?: true
    title?: true
  }

  export type BrandMaxAggregateInputType = {
    id?: true
    title?: true
  }

  export type BrandCountAggregateInputType = {
    id?: true
    title?: true
    _all?: true
  }

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

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




  export type BrandGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: BrandWhereInput
    orderBy?: BrandOrderByWithAggregationInput | BrandOrderByWithAggregationInput[]
    by: BrandScalarFieldEnum[] | BrandScalarFieldEnum
    having?: BrandScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: BrandCountAggregateInputType | true
    _min?: BrandMinAggregateInputType
    _max?: BrandMaxAggregateInputType
  }

  export type BrandGroupByOutputType = {
    id: string
    title: string
    _count: BrandCountAggregateOutputType | null
    _min: BrandMinAggregateOutputType | null
    _max: BrandMaxAggregateOutputType | null
  }

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


  export type BrandSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    products?: boolean | Brand$productsArgs<ExtArgs>
    promotions?: boolean | Brand$promotionsArgs<ExtArgs>
    _count?: boolean | BrandCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["brand"]>

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

  export type BrandSelectScalar = {
    id?: boolean
    title?: boolean
  }

  export type BrandInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    products?: boolean | Brand$productsArgs<ExtArgs>
    promotions?: boolean | Brand$promotionsArgs<ExtArgs>
    _count?: boolean | BrandCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type BrandIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}

  export type $BrandPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Brand"
    objects: {
      products: Prisma.$ProductPayload<ExtArgs>[]
      promotions: Prisma.$PromotionPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      title: string
    }, ExtArgs["result"]["brand"]>
    composites: {}
  }

  type BrandGetPayload<S extends boolean | null | undefined | BrandDefaultArgs> = $Result.GetResult<Prisma.$BrandPayload, S>

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

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

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

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

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

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

    /**
     * Create a Brand.
     * @param {BrandCreateArgs} args - Arguments to create a Brand.
     * @example
     * // Create one Brand
     * const Brand = await prisma.brand.create({
     *   data: {
     *     // ... data to create a Brand
     *   }
     * })
     * 
     */
    create<T extends BrandCreateArgs>(args: SelectSubset<T, BrandCreateArgs<ExtArgs>>): Prisma__BrandClient<$Result.GetResult<Prisma.$BrandPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Brand.
     * @param {BrandDeleteArgs} args - Arguments to delete one Brand.
     * @example
     * // Delete one Brand
     * const Brand = await prisma.brand.delete({
     *   where: {
     *     // ... filter to delete one Brand
     *   }
     * })
     * 
     */
    delete<T extends BrandDeleteArgs>(args: SelectSubset<T, BrandDeleteArgs<ExtArgs>>): Prisma__BrandClient<$Result.GetResult<Prisma.$BrandPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Brand.
   * 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__BrandClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    products<T extends Brand$productsArgs<ExtArgs> = {}>(args?: Subset<T, Brand$productsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ProductPayload<ExtArgs>, T, "findMany"> | Null>
    promotions<T extends Brand$promotionsArgs<ExtArgs> = {}>(args?: Subset<T, Brand$promotionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PromotionPayload<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 Brand model
   */ 
  interface BrandFieldRefs {
    readonly id: FieldRef<"Brand", 'String'>
    readonly title: FieldRef<"Brand", 'String'>
  }
    

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

  /**
   * Brand findUniqueOrThrow
   */
  export type BrandFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Brand
     */
    select?: BrandSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BrandInclude<ExtArgs> | null
    /**
     * Filter, which Brand to fetch.
     */
    where: BrandWhereUniqueInput
  }

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

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

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

  /**
   * Brand create
   */
  export type BrandCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Brand
     */
    select?: BrandSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BrandInclude<ExtArgs> | null
    /**
     * The data needed to create a Brand.
     */
    data: XOR<BrandCreateInput, BrandUncheckedCreateInput>
  }

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

  /**
   * Brand createManyAndReturn
   */
  export type BrandCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Brand
     */
    select?: BrandSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Brands.
     */
    data: BrandCreateManyInput | BrandCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Brand update
   */
  export type BrandUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Brand
     */
    select?: BrandSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BrandInclude<ExtArgs> | null
    /**
     * The data needed to update a Brand.
     */
    data: XOR<BrandUpdateInput, BrandUncheckedUpdateInput>
    /**
     * Choose, which Brand to update.
     */
    where: BrandWhereUniqueInput
  }

  /**
   * Brand updateMany
   */
  export type BrandUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Brands.
     */
    data: XOR<BrandUpdateManyMutationInput, BrandUncheckedUpdateManyInput>
    /**
     * Filter which Brands to update
     */
    where?: BrandWhereInput
  }

  /**
   * Brand upsert
   */
  export type BrandUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Brand
     */
    select?: BrandSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BrandInclude<ExtArgs> | null
    /**
     * The filter to search for the Brand to update in case it exists.
     */
    where: BrandWhereUniqueInput
    /**
     * In case the Brand found by the `where` argument doesn't exist, create a new Brand with this data.
     */
    create: XOR<BrandCreateInput, BrandUncheckedCreateInput>
    /**
     * In case the Brand was found with the provided `where` argument, update it with this data.
     */
    update: XOR<BrandUpdateInput, BrandUncheckedUpdateInput>
  }

  /**
   * Brand delete
   */
  export type BrandDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Brand
     */
    select?: BrandSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BrandInclude<ExtArgs> | null
    /**
     * Filter which Brand to delete.
     */
    where: BrandWhereUniqueInput
  }

  /**
   * Brand deleteMany
   */
  export type BrandDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Brands to delete
     */
    where?: BrandWhereInput
  }

  /**
   * Brand.products
   */
  export type Brand$productsArgs<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
    where?: ProductWhereInput
    orderBy?: ProductOrderByWithRelationInput | ProductOrderByWithRelationInput[]
    cursor?: ProductWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ProductScalarFieldEnum | ProductScalarFieldEnum[]
  }

  /**
   * Brand.promotions
   */
  export type Brand$promotionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Promotion
     */
    select?: PromotionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PromotionInclude<ExtArgs> | null
    where?: PromotionWhereInput
    orderBy?: PromotionOrderByWithRelationInput | PromotionOrderByWithRelationInput[]
    cursor?: PromotionWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PromotionScalarFieldEnum | PromotionScalarFieldEnum[]
  }

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


  /**
   * Model Collection
   */

  export type AggregateCollection = {
    _count: CollectionCountAggregateOutputType | null
    _min: CollectionMinAggregateOutputType | null
    _max: CollectionMaxAggregateOutputType | null
  }

  export type CollectionMinAggregateOutputType = {
    id: string | null
    title: string | null
    description: string | null
    isActive: boolean | null
  }

  export type CollectionMaxAggregateOutputType = {
    id: string | null
    title: string | null
    description: string | null
    isActive: boolean | null
  }

  export type CollectionCountAggregateOutputType = {
    id: number
    title: number
    description: number
    isActive: number
    _all: number
  }


  export type CollectionMinAggregateInputType = {
    id?: true
    title?: true
    description?: true
    isActive?: true
  }

  export type CollectionMaxAggregateInputType = {
    id?: true
    title?: true
    description?: true
    isActive?: true
  }

  export type CollectionCountAggregateInputType = {
    id?: true
    title?: true
    description?: true
    isActive?: true
    _all?: true
  }

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

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




  export type CollectionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CollectionWhereInput
    orderBy?: CollectionOrderByWithAggregationInput | CollectionOrderByWithAggregationInput[]
    by: CollectionScalarFieldEnum[] | CollectionScalarFieldEnum
    having?: CollectionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CollectionCountAggregateInputType | true
    _min?: CollectionMinAggregateInputType
    _max?: CollectionMaxAggregateInputType
  }

  export type CollectionGroupByOutputType = {
    id: string
    title: string
    description: string | null
    isActive: boolean
    _count: CollectionCountAggregateOutputType | null
    _min: CollectionMinAggregateOutputType | null
    _max: CollectionMaxAggregateOutputType | null
  }

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


  export type CollectionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    description?: boolean
    isActive?: boolean
    products?: boolean | Collection$productsArgs<ExtArgs>
    _count?: boolean | CollectionCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["collection"]>

  export type CollectionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    description?: boolean
    isActive?: boolean
  }, ExtArgs["result"]["collection"]>

  export type CollectionSelectScalar = {
    id?: boolean
    title?: boolean
    description?: boolean
    isActive?: boolean
  }

  export type CollectionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    products?: boolean | Collection$productsArgs<ExtArgs>
    _count?: boolean | CollectionCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type CollectionIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}

  export type $CollectionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Collection"
    objects: {
      products: Prisma.$CollectionProductPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      title: string
      description: string | null
      isActive: boolean
    }, ExtArgs["result"]["collection"]>
    composites: {}
  }

  type CollectionGetPayload<S extends boolean | null | undefined | CollectionDefaultArgs> = $Result.GetResult<Prisma.$CollectionPayload, S>

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

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

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

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

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

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

    /**
     * Create a Collection.
     * @param {CollectionCreateArgs} args - Arguments to create a Collection.
     * @example
     * // Create one Collection
     * const Collection = await prisma.collection.create({
     *   data: {
     *     // ... data to create a Collection
     *   }
     * })
     * 
     */
    create<T extends CollectionCreateArgs>(args: SelectSubset<T, CollectionCreateArgs<ExtArgs>>): Prisma__CollectionClient<$Result.GetResult<Prisma.$CollectionPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Collection.
     * @param {CollectionDeleteArgs} args - Arguments to delete one Collection.
     * @example
     * // Delete one Collection
     * const Collection = await prisma.collection.delete({
     *   where: {
     *     // ... filter to delete one Collection
     *   }
     * })
     * 
     */
    delete<T extends CollectionDeleteArgs>(args: SelectSubset<T, CollectionDeleteArgs<ExtArgs>>): Prisma__CollectionClient<$Result.GetResult<Prisma.$CollectionPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Collection.
   * 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__CollectionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    products<T extends Collection$productsArgs<ExtArgs> = {}>(args?: Subset<T, Collection$productsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CollectionProductPayload<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 Collection model
   */ 
  interface CollectionFieldRefs {
    readonly id: FieldRef<"Collection", 'String'>
    readonly title: FieldRef<"Collection", 'String'>
    readonly description: FieldRef<"Collection", 'String'>
    readonly isActive: FieldRef<"Collection", 'Boolean'>
  }
    

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

  /**
   * Collection findUniqueOrThrow
   */
  export type CollectionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Collection
     */
    select?: CollectionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CollectionInclude<ExtArgs> | null
    /**
     * Filter, which Collection to fetch.
     */
    where: CollectionWhereUniqueInput
  }

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

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

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

  /**
   * Collection create
   */
  export type CollectionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Collection
     */
    select?: CollectionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CollectionInclude<ExtArgs> | null
    /**
     * The data needed to create a Collection.
     */
    data: XOR<CollectionCreateInput, CollectionUncheckedCreateInput>
  }

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

  /**
   * Collection createManyAndReturn
   */
  export type CollectionCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Collection
     */
    select?: CollectionSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Collections.
     */
    data: CollectionCreateManyInput | CollectionCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Collection update
   */
  export type CollectionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Collection
     */
    select?: CollectionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CollectionInclude<ExtArgs> | null
    /**
     * The data needed to update a Collection.
     */
    data: XOR<CollectionUpdateInput, CollectionUncheckedUpdateInput>
    /**
     * Choose, which Collection to update.
     */
    where: CollectionWhereUniqueInput
  }

  /**
   * Collection updateMany
   */
  export type CollectionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Collections.
     */
    data: XOR<CollectionUpdateManyMutationInput, CollectionUncheckedUpdateManyInput>
    /**
     * Filter which Collections to update
     */
    where?: CollectionWhereInput
  }

  /**
   * Collection upsert
   */
  export type CollectionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Collection
     */
    select?: CollectionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CollectionInclude<ExtArgs> | null
    /**
     * The filter to search for the Collection to update in case it exists.
     */
    where: CollectionWhereUniqueInput
    /**
     * In case the Collection found by the `where` argument doesn't exist, create a new Collection with this data.
     */
    create: XOR<CollectionCreateInput, CollectionUncheckedCreateInput>
    /**
     * In case the Collection was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CollectionUpdateInput, CollectionUncheckedUpdateInput>
  }

  /**
   * Collection delete
   */
  export type CollectionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Collection
     */
    select?: CollectionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CollectionInclude<ExtArgs> | null
    /**
     * Filter which Collection to delete.
     */
    where: CollectionWhereUniqueInput
  }

  /**
   * Collection deleteMany
   */
  export type CollectionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Collections to delete
     */
    where?: CollectionWhereInput
  }

  /**
   * Collection.products
   */
  export type Collection$productsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CollectionProduct
     */
    select?: CollectionProductSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CollectionProductInclude<ExtArgs> | null
    where?: CollectionProductWhereInput
    orderBy?: CollectionProductOrderByWithRelationInput | CollectionProductOrderByWithRelationInput[]
    cursor?: CollectionProductWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CollectionProductScalarFieldEnum | CollectionProductScalarFieldEnum[]
  }

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


  /**
   * Model CollectionProduct
   */

  export type AggregateCollectionProduct = {
    _count: CollectionProductCountAggregateOutputType | null
    _min: CollectionProductMinAggregateOutputType | null
    _max: CollectionProductMaxAggregateOutputType | null
  }

  export type CollectionProductMinAggregateOutputType = {
    collectionId: string | null
    productId: string | null
  }

  export type CollectionProductMaxAggregateOutputType = {
    collectionId: string | null
    productId: string | null
  }

  export type CollectionProductCountAggregateOutputType = {
    collectionId: number
    productId: number
    _all: number
  }


  export type CollectionProductMinAggregateInputType = {
    collectionId?: true
    productId?: true
  }

  export type CollectionProductMaxAggregateInputType = {
    collectionId?: true
    productId?: true
  }

  export type CollectionProductCountAggregateInputType = {
    collectionId?: true
    productId?: true
    _all?: true
  }

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

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




  export type CollectionProductGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CollectionProductWhereInput
    orderBy?: CollectionProductOrderByWithAggregationInput | CollectionProductOrderByWithAggregationInput[]
    by: CollectionProductScalarFieldEnum[] | CollectionProductScalarFieldEnum
    having?: CollectionProductScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CollectionProductCountAggregateInputType | true
    _min?: CollectionProductMinAggregateInputType
    _max?: CollectionProductMaxAggregateInputType
  }

  export type CollectionProductGroupByOutputType = {
    collectionId: string
    productId: string
    _count: CollectionProductCountAggregateOutputType | null
    _min: CollectionProductMinAggregateOutputType | null
    _max: CollectionProductMaxAggregateOutputType | null
  }

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


  export type CollectionProductSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    collectionId?: boolean
    productId?: boolean
    collection?: boolean | CollectionDefaultArgs<ExtArgs>
    product?: boolean | ProductDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["collectionProduct"]>

  export type CollectionProductSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    collectionId?: boolean
    productId?: boolean
    collection?: boolean | CollectionDefaultArgs<ExtArgs>
    product?: boolean | ProductDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["collectionProduct"]>

  export type CollectionProductSelectScalar = {
    collectionId?: boolean
    productId?: boolean
  }

  export type CollectionProductInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    collection?: boolean | CollectionDefaultArgs<ExtArgs>
    product?: boolean | ProductDefaultArgs<ExtArgs>
  }
  export type CollectionProductIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    collection?: boolean | CollectionDefaultArgs<ExtArgs>
    product?: boolean | ProductDefaultArgs<ExtArgs>
  }

  export type $CollectionProductPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "CollectionProduct"
    objects: {
      collection: Prisma.$CollectionPayload<ExtArgs>
      product: Prisma.$ProductPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      collectionId: string
      productId: string
    }, ExtArgs["result"]["collectionProduct"]>
    composites: {}
  }

  type CollectionProductGetPayload<S extends boolean | null | undefined | CollectionProductDefaultArgs> = $Result.GetResult<Prisma.$CollectionProductPayload, S>

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

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

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

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

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

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

    /**
     * Create a CollectionProduct.
     * @param {CollectionProductCreateArgs} args - Arguments to create a CollectionProduct.
     * @example
     * // Create one CollectionProduct
     * const CollectionProduct = await prisma.collectionProduct.create({
     *   data: {
     *     // ... data to create a CollectionProduct
     *   }
     * })
     * 
     */
    create<T extends CollectionProductCreateArgs>(args: SelectSubset<T, CollectionProductCreateArgs<ExtArgs>>): Prisma__CollectionProductClient<$Result.GetResult<Prisma.$CollectionProductPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a CollectionProduct.
     * @param {CollectionProductDeleteArgs} args - Arguments to delete one CollectionProduct.
     * @example
     * // Delete one CollectionProduct
     * const CollectionProduct = await prisma.collectionProduct.delete({
     *   where: {
     *     // ... filter to delete one CollectionProduct
     *   }
     * })
     * 
     */
    delete<T extends CollectionProductDeleteArgs>(args: SelectSubset<T, CollectionProductDeleteArgs<ExtArgs>>): Prisma__CollectionProductClient<$Result.GetResult<Prisma.$CollectionProductPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for CollectionProduct.
   * 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__CollectionProductClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    collection<T extends CollectionDefaultArgs<ExtArgs> = {}>(args?: Subset<T, CollectionDefaultArgs<ExtArgs>>): Prisma__CollectionClient<$Result.GetResult<Prisma.$CollectionPayload<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>
    /**
     * 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 CollectionProduct model
   */ 
  interface CollectionProductFieldRefs {
    readonly collectionId: FieldRef<"CollectionProduct", 'String'>
    readonly productId: FieldRef<"CollectionProduct", 'String'>
  }
    

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

  /**
   * CollectionProduct findUniqueOrThrow
   */
  export type CollectionProductFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CollectionProduct
     */
    select?: CollectionProductSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CollectionProductInclude<ExtArgs> | null
    /**
     * Filter, which CollectionProduct to fetch.
     */
    where: CollectionProductWhereUniqueInput
  }

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

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

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

  /**
   * CollectionProduct create
   */
  export type CollectionProductCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CollectionProduct
     */
    select?: CollectionProductSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CollectionProductInclude<ExtArgs> | null
    /**
     * The data needed to create a CollectionProduct.
     */
    data: XOR<CollectionProductCreateInput, CollectionProductUncheckedCreateInput>
  }

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

  /**
   * CollectionProduct createManyAndReturn
   */
  export type CollectionProductCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CollectionProduct
     */
    select?: CollectionProductSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many CollectionProducts.
     */
    data: CollectionProductCreateManyInput | CollectionProductCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CollectionProductIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * CollectionProduct update
   */
  export type CollectionProductUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CollectionProduct
     */
    select?: CollectionProductSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CollectionProductInclude<ExtArgs> | null
    /**
     * The data needed to update a CollectionProduct.
     */
    data: XOR<CollectionProductUpdateInput, CollectionProductUncheckedUpdateInput>
    /**
     * Choose, which CollectionProduct to update.
     */
    where: CollectionProductWhereUniqueInput
  }

  /**
   * CollectionProduct updateMany
   */
  export type CollectionProductUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update CollectionProducts.
     */
    data: XOR<CollectionProductUpdateManyMutationInput, CollectionProductUncheckedUpdateManyInput>
    /**
     * Filter which CollectionProducts to update
     */
    where?: CollectionProductWhereInput
  }

  /**
   * CollectionProduct upsert
   */
  export type CollectionProductUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CollectionProduct
     */
    select?: CollectionProductSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CollectionProductInclude<ExtArgs> | null
    /**
     * The filter to search for the CollectionProduct to update in case it exists.
     */
    where: CollectionProductWhereUniqueInput
    /**
     * In case the CollectionProduct found by the `where` argument doesn't exist, create a new CollectionProduct with this data.
     */
    create: XOR<CollectionProductCreateInput, CollectionProductUncheckedCreateInput>
    /**
     * In case the CollectionProduct was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CollectionProductUpdateInput, CollectionProductUncheckedUpdateInput>
  }

  /**
   * CollectionProduct delete
   */
  export type CollectionProductDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CollectionProduct
     */
    select?: CollectionProductSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CollectionProductInclude<ExtArgs> | null
    /**
     * Filter which CollectionProduct to delete.
     */
    where: CollectionProductWhereUniqueInput
  }

  /**
   * CollectionProduct deleteMany
   */
  export type CollectionProductDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CollectionProducts to delete
     */
    where?: CollectionProductWhereInput
  }

  /**
   * CollectionProduct without action
   */
  export type CollectionProductDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CollectionProduct
     */
    select?: CollectionProductSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CollectionProductInclude<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 = {
    showType: number | null
  }

  export type ProductSumAggregateOutputType = {
    showType: number | null
  }

  export type ProductMinAggregateOutputType = {
    id: string | null
    title: string | null
    description: string | null
    categoryId: string | null
    brandId: string | null
    productCode: string | null
    showType: number | null
    isActive: boolean | null
    createdAt: Date | null
  }

  export type ProductMaxAggregateOutputType = {
    id: string | null
    title: string | null
    description: string | null
    categoryId: string | null
    brandId: string | null
    productCode: string | null
    showType: number | null
    isActive: boolean | null
    createdAt: Date | null
  }

  export type ProductCountAggregateOutputType = {
    id: number
    title: number
    description: number
    categoryId: number
    brandId: number
    productCode: number
    showType: number
    isActive: number
    createdAt: number
    _all: number
  }


  export type ProductAvgAggregateInputType = {
    showType?: true
  }

  export type ProductSumAggregateInputType = {
    showType?: true
  }

  export type ProductMinAggregateInputType = {
    id?: true
    title?: true
    description?: true
    categoryId?: true
    brandId?: true
    productCode?: true
    showType?: true
    isActive?: true
    createdAt?: true
  }

  export type ProductMaxAggregateInputType = {
    id?: true
    title?: true
    description?: true
    categoryId?: true
    brandId?: true
    productCode?: true
    showType?: true
    isActive?: true
    createdAt?: true
  }

  export type ProductCountAggregateInputType = {
    id?: true
    title?: true
    description?: true
    categoryId?: true
    brandId?: true
    productCode?: true
    showType?: true
    isActive?: true
    createdAt?: 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
    title: string
    description: string | null
    categoryId: string | null
    brandId: string | null
    productCode: string | null
    showType: number
    isActive: boolean
    createdAt: 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
    title?: boolean
    description?: boolean
    categoryId?: boolean
    brandId?: boolean
    productCode?: boolean
    showType?: boolean
    isActive?: boolean
    createdAt?: boolean
    category?: boolean | Product$categoryArgs<ExtArgs>
    brand?: boolean | Product$brandArgs<ExtArgs>
    variants?: boolean | Product$variantsArgs<ExtArgs>
    images?: boolean | Product$imagesArgs<ExtArgs>
    collections?: boolean | Product$collectionsArgs<ExtArgs>
    comments?: boolean | Product$commentsArgs<ExtArgs>
    promotions?: boolean | Product$promotionsArgs<ExtArgs>
    allocationItems?: boolean | Product$allocationItemsArgs<ExtArgs>
    _count?: boolean | ProductCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["product"]>

  export type ProductSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    description?: boolean
    categoryId?: boolean
    brandId?: boolean
    productCode?: boolean
    showType?: boolean
    isActive?: boolean
    createdAt?: boolean
    category?: boolean | Product$categoryArgs<ExtArgs>
    brand?: boolean | Product$brandArgs<ExtArgs>
  }, ExtArgs["result"]["product"]>

  export type ProductSelectScalar = {
    id?: boolean
    title?: boolean
    description?: boolean
    categoryId?: boolean
    brandId?: boolean
    productCode?: boolean
    showType?: boolean
    isActive?: boolean
    createdAt?: boolean
  }

  export type ProductInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    category?: boolean | Product$categoryArgs<ExtArgs>
    brand?: boolean | Product$brandArgs<ExtArgs>
    variants?: boolean | Product$variantsArgs<ExtArgs>
    images?: boolean | Product$imagesArgs<ExtArgs>
    collections?: boolean | Product$collectionsArgs<ExtArgs>
    comments?: boolean | Product$commentsArgs<ExtArgs>
    promotions?: boolean | Product$promotionsArgs<ExtArgs>
    allocationItems?: boolean | Product$allocationItemsArgs<ExtArgs>
    _count?: boolean | ProductCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type ProductIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    category?: boolean | Product$categoryArgs<ExtArgs>
    brand?: boolean | Product$brandArgs<ExtArgs>
  }

  export type $ProductPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Product"
    objects: {
      category: Prisma.$CategoryPayload<ExtArgs> | null
      brand: Prisma.$BrandPayload<ExtArgs> | null
      variants: Prisma.$ProductVariantPayload<ExtArgs>[]
      images: Prisma.$ProductImagePayload<ExtArgs>[]
      collections: Prisma.$CollectionProductPayload<ExtArgs>[]
      comments: Prisma.$CommentPayload<ExtArgs>[]
      promotions: Prisma.$PromotionPayload<ExtArgs>[]
      allocationItems: Prisma.$BranchAllocationItemPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      title: string
      description: string | null
      categoryId: string | null
      brandId: string | null
      /**
       * Legacy Product.product_code — the human-facing SKU shown in the grid.
       */
      productCode: string | null
      /**
       * Legacy Product.show_type: 1 site, 2 mobile, 3 both.
       */
      showType: number
      isActive: boolean
      createdAt: 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>

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

    /**
     * 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"
    category<T extends Product$categoryArgs<ExtArgs> = {}>(args?: Subset<T, Product$categoryArgs<ExtArgs>>): Prisma__CategoryClient<$Result.GetResult<Prisma.$CategoryPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    brand<T extends Product$brandArgs<ExtArgs> = {}>(args?: Subset<T, Product$brandArgs<ExtArgs>>): Prisma__BrandClient<$Result.GetResult<Prisma.$BrandPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    variants<T extends Product$variantsArgs<ExtArgs> = {}>(args?: Subset<T, Product$variantsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ProductVariantPayload<ExtArgs>, T, "findMany"> | Null>
    images<T extends Product$imagesArgs<ExtArgs> = {}>(args?: Subset<T, Product$imagesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ProductImagePayload<ExtArgs>, T, "findMany"> | Null>
    collections<T extends Product$collectionsArgs<ExtArgs> = {}>(args?: Subset<T, Product$collectionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CollectionProductPayload<ExtArgs>, T, "findMany"> | Null>
    comments<T extends Product$commentsArgs<ExtArgs> = {}>(args?: Subset<T, Product$commentsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CommentPayload<ExtArgs>, T, "findMany"> | Null>
    promotions<T extends Product$promotionsArgs<ExtArgs> = {}>(args?: Subset<T, Product$promotionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PromotionPayload<ExtArgs>, T, "findMany"> | Null>
    allocationItems<T extends Product$allocationItemsArgs<ExtArgs> = {}>(args?: Subset<T, Product$allocationItemsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$BranchAllocationItemPayload<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 title: FieldRef<"Product", 'String'>
    readonly description: FieldRef<"Product", 'String'>
    readonly categoryId: FieldRef<"Product", 'String'>
    readonly brandId: FieldRef<"Product", 'String'>
    readonly productCode: FieldRef<"Product", 'String'>
    readonly showType: FieldRef<"Product", 'Int'>
    readonly isActive: FieldRef<"Product", 'Boolean'>
    readonly createdAt: 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 createManyAndReturn
   */
  export type ProductCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Product
     */
    select?: ProductSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Products.
     */
    data: ProductCreateManyInput | ProductCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * 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.category
   */
  export type Product$categoryArgs<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
    where?: CategoryWhereInput
  }

  /**
   * Product.brand
   */
  export type Product$brandArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Brand
     */
    select?: BrandSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BrandInclude<ExtArgs> | null
    where?: BrandWhereInput
  }

  /**
   * Product.variants
   */
  export type Product$variantsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductVariant
     */
    select?: ProductVariantSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductVariantInclude<ExtArgs> | null
    where?: ProductVariantWhereInput
    orderBy?: ProductVariantOrderByWithRelationInput | ProductVariantOrderByWithRelationInput[]
    cursor?: ProductVariantWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ProductVariantScalarFieldEnum | ProductVariantScalarFieldEnum[]
  }

  /**
   * Product.images
   */
  export type Product$imagesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductImage
     */
    select?: ProductImageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductImageInclude<ExtArgs> | null
    where?: ProductImageWhereInput
    orderBy?: ProductImageOrderByWithRelationInput | ProductImageOrderByWithRelationInput[]
    cursor?: ProductImageWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ProductImageScalarFieldEnum | ProductImageScalarFieldEnum[]
  }

  /**
   * Product.collections
   */
  export type Product$collectionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CollectionProduct
     */
    select?: CollectionProductSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CollectionProductInclude<ExtArgs> | null
    where?: CollectionProductWhereInput
    orderBy?: CollectionProductOrderByWithRelationInput | CollectionProductOrderByWithRelationInput[]
    cursor?: CollectionProductWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CollectionProductScalarFieldEnum | CollectionProductScalarFieldEnum[]
  }

  /**
   * Product.comments
   */
  export type Product$commentsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Comment
     */
    select?: CommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommentInclude<ExtArgs> | null
    where?: CommentWhereInput
    orderBy?: CommentOrderByWithRelationInput | CommentOrderByWithRelationInput[]
    cursor?: CommentWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CommentScalarFieldEnum | CommentScalarFieldEnum[]
  }

  /**
   * Product.promotions
   */
  export type Product$promotionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Promotion
     */
    select?: PromotionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PromotionInclude<ExtArgs> | null
    where?: PromotionWhereInput
    orderBy?: PromotionOrderByWithRelationInput | PromotionOrderByWithRelationInput[]
    cursor?: PromotionWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PromotionScalarFieldEnum | PromotionScalarFieldEnum[]
  }

  /**
   * Product.allocationItems
   */
  export type Product$allocationItemsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BranchAllocationItem
     */
    select?: BranchAllocationItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchAllocationItemInclude<ExtArgs> | null
    where?: BranchAllocationItemWhereInput
    orderBy?: BranchAllocationItemOrderByWithRelationInput | BranchAllocationItemOrderByWithRelationInput[]
    cursor?: BranchAllocationItemWhereUniqueInput
    take?: number
    skip?: number
    distinct?: BranchAllocationItemScalarFieldEnum | BranchAllocationItemScalarFieldEnum[]
  }

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

  export type AggregateProductImage = {
    _count: ProductImageCountAggregateOutputType | null
    _avg: ProductImageAvgAggregateOutputType | null
    _sum: ProductImageSumAggregateOutputType | null
    _min: ProductImageMinAggregateOutputType | null
    _max: ProductImageMaxAggregateOutputType | null
  }

  export type ProductImageAvgAggregateOutputType = {
    sortOrder: number | null
  }

  export type ProductImageSumAggregateOutputType = {
    sortOrder: number | null
  }

  export type ProductImageMinAggregateOutputType = {
    id: string | null
    productId: string | null
    url: string | null
    sortOrder: number | null
    role: $Enums.ProductImageRole | null
  }

  export type ProductImageMaxAggregateOutputType = {
    id: string | null
    productId: string | null
    url: string | null
    sortOrder: number | null
    role: $Enums.ProductImageRole | null
  }

  export type ProductImageCountAggregateOutputType = {
    id: number
    productId: number
    url: number
    sortOrder: number
    role: number
    _all: number
  }


  export type ProductImageAvgAggregateInputType = {
    sortOrder?: true
  }

  export type ProductImageSumAggregateInputType = {
    sortOrder?: true
  }

  export type ProductImageMinAggregateInputType = {
    id?: true
    productId?: true
    url?: true
    sortOrder?: true
    role?: true
  }

  export type ProductImageMaxAggregateInputType = {
    id?: true
    productId?: true
    url?: true
    sortOrder?: true
    role?: true
  }

  export type ProductImageCountAggregateInputType = {
    id?: true
    productId?: true
    url?: true
    sortOrder?: true
    role?: true
    _all?: true
  }

  export type ProductImageAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ProductImage to aggregate.
     */
    where?: ProductImageWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ProductImages to fetch.
     */
    orderBy?: ProductImageOrderByWithRelationInput | ProductImageOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ProductImageWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ProductImages from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` ProductImages.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ProductImages
    **/
    _count?: true | ProductImageCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ProductImageAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ProductImageSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ProductImageMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ProductImageMaxAggregateInputType
  }

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




  export type ProductImageGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ProductImageWhereInput
    orderBy?: ProductImageOrderByWithAggregationInput | ProductImageOrderByWithAggregationInput[]
    by: ProductImageScalarFieldEnum[] | ProductImageScalarFieldEnum
    having?: ProductImageScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ProductImageCountAggregateInputType | true
    _avg?: ProductImageAvgAggregateInputType
    _sum?: ProductImageSumAggregateInputType
    _min?: ProductImageMinAggregateInputType
    _max?: ProductImageMaxAggregateInputType
  }

  export type ProductImageGroupByOutputType = {
    id: string
    productId: string
    url: string
    sortOrder: number
    role: $Enums.ProductImageRole
    _count: ProductImageCountAggregateOutputType | null
    _avg: ProductImageAvgAggregateOutputType | null
    _sum: ProductImageSumAggregateOutputType | null
    _min: ProductImageMinAggregateOutputType | null
    _max: ProductImageMaxAggregateOutputType | null
  }

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


  export type ProductImageSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    productId?: boolean
    url?: boolean
    sortOrder?: boolean
    role?: boolean
    product?: boolean | ProductDefaultArgs<ExtArgs>
    variants?: boolean | ProductImage$variantsArgs<ExtArgs>
    _count?: boolean | ProductImageCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["productImage"]>

  export type ProductImageSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    productId?: boolean
    url?: boolean
    sortOrder?: boolean
    role?: boolean
    product?: boolean | ProductDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["productImage"]>

  export type ProductImageSelectScalar = {
    id?: boolean
    productId?: boolean
    url?: boolean
    sortOrder?: boolean
    role?: boolean
  }

  export type ProductImageInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    product?: boolean | ProductDefaultArgs<ExtArgs>
    variants?: boolean | ProductImage$variantsArgs<ExtArgs>
    _count?: boolean | ProductImageCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type ProductImageIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    product?: boolean | ProductDefaultArgs<ExtArgs>
  }

  export type $ProductImagePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ProductImage"
    objects: {
      product: Prisma.$ProductPayload<ExtArgs>
      /**
       * Variants that display this image. A gallery image may back several
       * variants (one photo, several weights), which is why this is a plain
       * one-to-many and not a join table.
       */
      variants: Prisma.$ProductVariantPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      productId: string
      url: string
      sortOrder: number
      /**
       * Legacy had 4 distinct upload slots (تصویر شاخص / تصویر شاخص موبایل /
       * گالری تصاویر سایت / گالری تصاویر موبایل) — GALLERY is the default so
       * existing rows and any generic "just attach an image" caller keep working.
       */
      role: $Enums.ProductImageRole
    }, ExtArgs["result"]["productImage"]>
    composites: {}
  }

  type ProductImageGetPayload<S extends boolean | null | undefined | ProductImageDefaultArgs> = $Result.GetResult<Prisma.$ProductImagePayload, S>

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

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

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

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

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

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

    /**
     * Create a ProductImage.
     * @param {ProductImageCreateArgs} args - Arguments to create a ProductImage.
     * @example
     * // Create one ProductImage
     * const ProductImage = await prisma.productImage.create({
     *   data: {
     *     // ... data to create a ProductImage
     *   }
     * })
     * 
     */
    create<T extends ProductImageCreateArgs>(args: SelectSubset<T, ProductImageCreateArgs<ExtArgs>>): Prisma__ProductImageClient<$Result.GetResult<Prisma.$ProductImagePayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a ProductImage.
     * @param {ProductImageDeleteArgs} args - Arguments to delete one ProductImage.
     * @example
     * // Delete one ProductImage
     * const ProductImage = await prisma.productImage.delete({
     *   where: {
     *     // ... filter to delete one ProductImage
     *   }
     * })
     * 
     */
    delete<T extends ProductImageDeleteArgs>(args: SelectSubset<T, ProductImageDeleteArgs<ExtArgs>>): Prisma__ProductImageClient<$Result.GetResult<Prisma.$ProductImagePayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for ProductImage.
   * 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__ProductImageClient<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>
    variants<T extends ProductImage$variantsArgs<ExtArgs> = {}>(args?: Subset<T, ProductImage$variantsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ProductVariantPayload<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 ProductImage model
   */ 
  interface ProductImageFieldRefs {
    readonly id: FieldRef<"ProductImage", 'String'>
    readonly productId: FieldRef<"ProductImage", 'String'>
    readonly url: FieldRef<"ProductImage", 'String'>
    readonly sortOrder: FieldRef<"ProductImage", 'Int'>
    readonly role: FieldRef<"ProductImage", 'ProductImageRole'>
  }
    

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

  /**
   * ProductImage findUniqueOrThrow
   */
  export type ProductImageFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductImage
     */
    select?: ProductImageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductImageInclude<ExtArgs> | null
    /**
     * Filter, which ProductImage to fetch.
     */
    where: ProductImageWhereUniqueInput
  }

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

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

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

  /**
   * ProductImage create
   */
  export type ProductImageCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductImage
     */
    select?: ProductImageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductImageInclude<ExtArgs> | null
    /**
     * The data needed to create a ProductImage.
     */
    data: XOR<ProductImageCreateInput, ProductImageUncheckedCreateInput>
  }

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

  /**
   * ProductImage createManyAndReturn
   */
  export type ProductImageCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductImage
     */
    select?: ProductImageSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many ProductImages.
     */
    data: ProductImageCreateManyInput | ProductImageCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductImageIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * ProductImage update
   */
  export type ProductImageUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductImage
     */
    select?: ProductImageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductImageInclude<ExtArgs> | null
    /**
     * The data needed to update a ProductImage.
     */
    data: XOR<ProductImageUpdateInput, ProductImageUncheckedUpdateInput>
    /**
     * Choose, which ProductImage to update.
     */
    where: ProductImageWhereUniqueInput
  }

  /**
   * ProductImage updateMany
   */
  export type ProductImageUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ProductImages.
     */
    data: XOR<ProductImageUpdateManyMutationInput, ProductImageUncheckedUpdateManyInput>
    /**
     * Filter which ProductImages to update
     */
    where?: ProductImageWhereInput
  }

  /**
   * ProductImage upsert
   */
  export type ProductImageUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductImage
     */
    select?: ProductImageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductImageInclude<ExtArgs> | null
    /**
     * The filter to search for the ProductImage to update in case it exists.
     */
    where: ProductImageWhereUniqueInput
    /**
     * In case the ProductImage found by the `where` argument doesn't exist, create a new ProductImage with this data.
     */
    create: XOR<ProductImageCreateInput, ProductImageUncheckedCreateInput>
    /**
     * In case the ProductImage was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ProductImageUpdateInput, ProductImageUncheckedUpdateInput>
  }

  /**
   * ProductImage delete
   */
  export type ProductImageDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductImage
     */
    select?: ProductImageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductImageInclude<ExtArgs> | null
    /**
     * Filter which ProductImage to delete.
     */
    where: ProductImageWhereUniqueInput
  }

  /**
   * ProductImage deleteMany
   */
  export type ProductImageDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ProductImages to delete
     */
    where?: ProductImageWhereInput
  }

  /**
   * ProductImage.variants
   */
  export type ProductImage$variantsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductVariant
     */
    select?: ProductVariantSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductVariantInclude<ExtArgs> | null
    where?: ProductVariantWhereInput
    orderBy?: ProductVariantOrderByWithRelationInput | ProductVariantOrderByWithRelationInput[]
    cursor?: ProductVariantWhereUniqueInput
    take?: number
    skip?: number
    distinct?: ProductVariantScalarFieldEnum | ProductVariantScalarFieldEnum[]
  }

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


  /**
   * Model ProductVariant
   */

  export type AggregateProductVariant = {
    _count: ProductVariantCountAggregateOutputType | null
    _avg: ProductVariantAvgAggregateOutputType | null
    _sum: ProductVariantSumAggregateOutputType | null
    _min: ProductVariantMinAggregateOutputType | null
    _max: ProductVariantMaxAggregateOutputType | null
  }

  export type ProductVariantAvgAggregateOutputType = {
    rashWeightGrams: Decimal | null
    defaultWagePercent: Decimal | null
    qty: number | null
  }

  export type ProductVariantSumAggregateOutputType = {
    rashWeightGrams: Decimal | null
    defaultWagePercent: Decimal | null
    qty: number | null
  }

  export type ProductVariantMinAggregateOutputType = {
    id: string | null
    productId: string | null
    title: string | null
    sku: string | null
    rashWeightGrams: Decimal | null
    defaultWagePercent: Decimal | null
    qty: number | null
    isPreOrder: boolean | null
    isActive: boolean | null
    imageId: string | null
  }

  export type ProductVariantMaxAggregateOutputType = {
    id: string | null
    productId: string | null
    title: string | null
    sku: string | null
    rashWeightGrams: Decimal | null
    defaultWagePercent: Decimal | null
    qty: number | null
    isPreOrder: boolean | null
    isActive: boolean | null
    imageId: string | null
  }

  export type ProductVariantCountAggregateOutputType = {
    id: number
    productId: number
    title: number
    sku: number
    rashWeightGrams: number
    defaultWagePercent: number
    qty: number
    isPreOrder: number
    isActive: number
    imageId: number
    _all: number
  }


  export type ProductVariantAvgAggregateInputType = {
    rashWeightGrams?: true
    defaultWagePercent?: true
    qty?: true
  }

  export type ProductVariantSumAggregateInputType = {
    rashWeightGrams?: true
    defaultWagePercent?: true
    qty?: true
  }

  export type ProductVariantMinAggregateInputType = {
    id?: true
    productId?: true
    title?: true
    sku?: true
    rashWeightGrams?: true
    defaultWagePercent?: true
    qty?: true
    isPreOrder?: true
    isActive?: true
    imageId?: true
  }

  export type ProductVariantMaxAggregateInputType = {
    id?: true
    productId?: true
    title?: true
    sku?: true
    rashWeightGrams?: true
    defaultWagePercent?: true
    qty?: true
    isPreOrder?: true
    isActive?: true
    imageId?: true
  }

  export type ProductVariantCountAggregateInputType = {
    id?: true
    productId?: true
    title?: true
    sku?: true
    rashWeightGrams?: true
    defaultWagePercent?: true
    qty?: true
    isPreOrder?: true
    isActive?: true
    imageId?: true
    _all?: true
  }

  export type ProductVariantAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ProductVariant to aggregate.
     */
    where?: ProductVariantWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of ProductVariants to fetch.
     */
    orderBy?: ProductVariantOrderByWithRelationInput | ProductVariantOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: ProductVariantWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` ProductVariants from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` ProductVariants.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned ProductVariants
    **/
    _count?: true | ProductVariantCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: ProductVariantAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: ProductVariantSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: ProductVariantMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: ProductVariantMaxAggregateInputType
  }

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




  export type ProductVariantGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: ProductVariantWhereInput
    orderBy?: ProductVariantOrderByWithAggregationInput | ProductVariantOrderByWithAggregationInput[]
    by: ProductVariantScalarFieldEnum[] | ProductVariantScalarFieldEnum
    having?: ProductVariantScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: ProductVariantCountAggregateInputType | true
    _avg?: ProductVariantAvgAggregateInputType
    _sum?: ProductVariantSumAggregateInputType
    _min?: ProductVariantMinAggregateInputType
    _max?: ProductVariantMaxAggregateInputType
  }

  export type ProductVariantGroupByOutputType = {
    id: string
    productId: string
    title: string
    sku: string | null
    rashWeightGrams: Decimal
    defaultWagePercent: Decimal
    qty: number
    isPreOrder: boolean
    isActive: boolean
    imageId: string | null
    _count: ProductVariantCountAggregateOutputType | null
    _avg: ProductVariantAvgAggregateOutputType | null
    _sum: ProductVariantSumAggregateOutputType | null
    _min: ProductVariantMinAggregateOutputType | null
    _max: ProductVariantMaxAggregateOutputType | null
  }

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


  export type ProductVariantSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    productId?: boolean
    title?: boolean
    sku?: boolean
    rashWeightGrams?: boolean
    defaultWagePercent?: boolean
    qty?: boolean
    isPreOrder?: boolean
    isActive?: boolean
    imageId?: boolean
    product?: boolean | ProductDefaultArgs<ExtArgs>
    image?: boolean | ProductVariant$imageArgs<ExtArgs>
    orderItems?: boolean | ProductVariant$orderItemsArgs<ExtArgs>
    _count?: boolean | ProductVariantCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["productVariant"]>

  export type ProductVariantSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    productId?: boolean
    title?: boolean
    sku?: boolean
    rashWeightGrams?: boolean
    defaultWagePercent?: boolean
    qty?: boolean
    isPreOrder?: boolean
    isActive?: boolean
    imageId?: boolean
    product?: boolean | ProductDefaultArgs<ExtArgs>
    image?: boolean | ProductVariant$imageArgs<ExtArgs>
  }, ExtArgs["result"]["productVariant"]>

  export type ProductVariantSelectScalar = {
    id?: boolean
    productId?: boolean
    title?: boolean
    sku?: boolean
    rashWeightGrams?: boolean
    defaultWagePercent?: boolean
    qty?: boolean
    isPreOrder?: boolean
    isActive?: boolean
    imageId?: boolean
  }

  export type ProductVariantInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    product?: boolean | ProductDefaultArgs<ExtArgs>
    image?: boolean | ProductVariant$imageArgs<ExtArgs>
    orderItems?: boolean | ProductVariant$orderItemsArgs<ExtArgs>
    _count?: boolean | ProductVariantCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type ProductVariantIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    product?: boolean | ProductDefaultArgs<ExtArgs>
    image?: boolean | ProductVariant$imageArgs<ExtArgs>
  }

  export type $ProductVariantPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "ProductVariant"
    objects: {
      product: Prisma.$ProductPayload<ExtArgs>
      image: Prisma.$ProductImagePayload<ExtArgs> | null
      orderItems: Prisma.$OrderItemPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      productId: string
      title: string
      sku: string | null
      /**
       * Base/raw weight before making charge ("rash weight").
       */
      rashWeightGrams: Prisma.Decimal
      /**
       * Default making-charge percentage applied on top of rash weight.
       */
      defaultWagePercent: Prisma.Decimal
      /**
       * Legacy ProductVariant.qty — on-hand stock. The cart refuses a variant with
       * qty 0 unless it is flagged pre-order, so both fields are required for that
       * guard to work (see apps/admin-panel/src/stores/cart.ts).
       */
      qty: number
      /**
       * Legacy is_pre_order: orderable even at zero stock.
       */
      isPreOrder: boolean
      isActive: boolean
      /**
       * The gallery image shown for this variant, picked from its own product's
       * images — never a re-uploaded copy. onDelete: SetNull because dropping an
       * image must never cascade into the variant: OrderItem rows reference
       * variants, so losing one would break order history.
       */
      imageId: string | null
    }, ExtArgs["result"]["productVariant"]>
    composites: {}
  }

  type ProductVariantGetPayload<S extends boolean | null | undefined | ProductVariantDefaultArgs> = $Result.GetResult<Prisma.$ProductVariantPayload, S>

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

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

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

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

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

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

    /**
     * Create a ProductVariant.
     * @param {ProductVariantCreateArgs} args - Arguments to create a ProductVariant.
     * @example
     * // Create one ProductVariant
     * const ProductVariant = await prisma.productVariant.create({
     *   data: {
     *     // ... data to create a ProductVariant
     *   }
     * })
     * 
     */
    create<T extends ProductVariantCreateArgs>(args: SelectSubset<T, ProductVariantCreateArgs<ExtArgs>>): Prisma__ProductVariantClient<$Result.GetResult<Prisma.$ProductVariantPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a ProductVariant.
     * @param {ProductVariantDeleteArgs} args - Arguments to delete one ProductVariant.
     * @example
     * // Delete one ProductVariant
     * const ProductVariant = await prisma.productVariant.delete({
     *   where: {
     *     // ... filter to delete one ProductVariant
     *   }
     * })
     * 
     */
    delete<T extends ProductVariantDeleteArgs>(args: SelectSubset<T, ProductVariantDeleteArgs<ExtArgs>>): Prisma__ProductVariantClient<$Result.GetResult<Prisma.$ProductVariantPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for ProductVariant.
   * 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__ProductVariantClient<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>
    image<T extends ProductVariant$imageArgs<ExtArgs> = {}>(args?: Subset<T, ProductVariant$imageArgs<ExtArgs>>): Prisma__ProductImageClient<$Result.GetResult<Prisma.$ProductImagePayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    orderItems<T extends ProductVariant$orderItemsArgs<ExtArgs> = {}>(args?: Subset<T, ProductVariant$orderItemsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$OrderItemPayload<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 ProductVariant model
   */ 
  interface ProductVariantFieldRefs {
    readonly id: FieldRef<"ProductVariant", 'String'>
    readonly productId: FieldRef<"ProductVariant", 'String'>
    readonly title: FieldRef<"ProductVariant", 'String'>
    readonly sku: FieldRef<"ProductVariant", 'String'>
    readonly rashWeightGrams: FieldRef<"ProductVariant", 'Decimal'>
    readonly defaultWagePercent: FieldRef<"ProductVariant", 'Decimal'>
    readonly qty: FieldRef<"ProductVariant", 'Int'>
    readonly isPreOrder: FieldRef<"ProductVariant", 'Boolean'>
    readonly isActive: FieldRef<"ProductVariant", 'Boolean'>
    readonly imageId: FieldRef<"ProductVariant", 'String'>
  }
    

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

  /**
   * ProductVariant findUniqueOrThrow
   */
  export type ProductVariantFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductVariant
     */
    select?: ProductVariantSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductVariantInclude<ExtArgs> | null
    /**
     * Filter, which ProductVariant to fetch.
     */
    where: ProductVariantWhereUniqueInput
  }

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

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

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

  /**
   * ProductVariant create
   */
  export type ProductVariantCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductVariant
     */
    select?: ProductVariantSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductVariantInclude<ExtArgs> | null
    /**
     * The data needed to create a ProductVariant.
     */
    data: XOR<ProductVariantCreateInput, ProductVariantUncheckedCreateInput>
  }

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

  /**
   * ProductVariant createManyAndReturn
   */
  export type ProductVariantCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductVariant
     */
    select?: ProductVariantSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many ProductVariants.
     */
    data: ProductVariantCreateManyInput | ProductVariantCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductVariantIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * ProductVariant update
   */
  export type ProductVariantUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductVariant
     */
    select?: ProductVariantSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductVariantInclude<ExtArgs> | null
    /**
     * The data needed to update a ProductVariant.
     */
    data: XOR<ProductVariantUpdateInput, ProductVariantUncheckedUpdateInput>
    /**
     * Choose, which ProductVariant to update.
     */
    where: ProductVariantWhereUniqueInput
  }

  /**
   * ProductVariant updateMany
   */
  export type ProductVariantUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update ProductVariants.
     */
    data: XOR<ProductVariantUpdateManyMutationInput, ProductVariantUncheckedUpdateManyInput>
    /**
     * Filter which ProductVariants to update
     */
    where?: ProductVariantWhereInput
  }

  /**
   * ProductVariant upsert
   */
  export type ProductVariantUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductVariant
     */
    select?: ProductVariantSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductVariantInclude<ExtArgs> | null
    /**
     * The filter to search for the ProductVariant to update in case it exists.
     */
    where: ProductVariantWhereUniqueInput
    /**
     * In case the ProductVariant found by the `where` argument doesn't exist, create a new ProductVariant with this data.
     */
    create: XOR<ProductVariantCreateInput, ProductVariantUncheckedCreateInput>
    /**
     * In case the ProductVariant was found with the provided `where` argument, update it with this data.
     */
    update: XOR<ProductVariantUpdateInput, ProductVariantUncheckedUpdateInput>
  }

  /**
   * ProductVariant delete
   */
  export type ProductVariantDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductVariant
     */
    select?: ProductVariantSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductVariantInclude<ExtArgs> | null
    /**
     * Filter which ProductVariant to delete.
     */
    where: ProductVariantWhereUniqueInput
  }

  /**
   * ProductVariant deleteMany
   */
  export type ProductVariantDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which ProductVariants to delete
     */
    where?: ProductVariantWhereInput
  }

  /**
   * ProductVariant.image
   */
  export type ProductVariant$imageArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the ProductImage
     */
    select?: ProductImageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: ProductImageInclude<ExtArgs> | null
    where?: ProductImageWhereInput
  }

  /**
   * ProductVariant.orderItems
   */
  export type ProductVariant$orderItemsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OrderItem
     */
    select?: OrderItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderItemInclude<ExtArgs> | null
    where?: OrderItemWhereInput
    orderBy?: OrderItemOrderByWithRelationInput | OrderItemOrderByWithRelationInput[]
    cursor?: OrderItemWhereUniqueInput
    take?: number
    skip?: number
    distinct?: OrderItemScalarFieldEnum | OrderItemScalarFieldEnum[]
  }

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


  /**
   * Model Order
   */

  export type AggregateOrder = {
    _count: OrderCountAggregateOutputType | null
    _avg: OrderAvgAggregateOutputType | null
    _sum: OrderSumAggregateOutputType | null
    _min: OrderMinAggregateOutputType | null
    _max: OrderMaxAggregateOutputType | null
  }

  export type OrderAvgAggregateOutputType = {
    totalGoldWeightGrams: Decimal | null
    wageWeightGrams: Decimal | null
    flatRialCharge: Decimal | null
  }

  export type OrderSumAggregateOutputType = {
    totalGoldWeightGrams: Decimal | null
    wageWeightGrams: Decimal | null
    flatRialCharge: Decimal | null
  }

  export type OrderMinAggregateOutputType = {
    id: string | null
    orderNumber: string | null
    customerId: string | null
    branchId: string | null
    channel: $Enums.OrderChannel | null
    status: $Enums.OrderStatus | null
    totalGoldWeightGrams: Decimal | null
    wageWeightGrams: Decimal | null
    flatRialCharge: Decimal | null
    isSuspendedOverCreditLimit: boolean | null
    deliveredAt: Date | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type OrderMaxAggregateOutputType = {
    id: string | null
    orderNumber: string | null
    customerId: string | null
    branchId: string | null
    channel: $Enums.OrderChannel | null
    status: $Enums.OrderStatus | null
    totalGoldWeightGrams: Decimal | null
    wageWeightGrams: Decimal | null
    flatRialCharge: Decimal | null
    isSuspendedOverCreditLimit: boolean | null
    deliveredAt: Date | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type OrderCountAggregateOutputType = {
    id: number
    orderNumber: number
    customerId: number
    branchId: number
    channel: number
    status: number
    totalGoldWeightGrams: number
    wageWeightGrams: number
    flatRialCharge: number
    isSuspendedOverCreditLimit: number
    deliveredAt: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type OrderAvgAggregateInputType = {
    totalGoldWeightGrams?: true
    wageWeightGrams?: true
    flatRialCharge?: true
  }

  export type OrderSumAggregateInputType = {
    totalGoldWeightGrams?: true
    wageWeightGrams?: true
    flatRialCharge?: true
  }

  export type OrderMinAggregateInputType = {
    id?: true
    orderNumber?: true
    customerId?: true
    branchId?: true
    channel?: true
    status?: true
    totalGoldWeightGrams?: true
    wageWeightGrams?: true
    flatRialCharge?: true
    isSuspendedOverCreditLimit?: true
    deliveredAt?: true
    createdAt?: true
    updatedAt?: true
  }

  export type OrderMaxAggregateInputType = {
    id?: true
    orderNumber?: true
    customerId?: true
    branchId?: true
    channel?: true
    status?: true
    totalGoldWeightGrams?: true
    wageWeightGrams?: true
    flatRialCharge?: true
    isSuspendedOverCreditLimit?: true
    deliveredAt?: true
    createdAt?: true
    updatedAt?: true
  }

  export type OrderCountAggregateInputType = {
    id?: true
    orderNumber?: true
    customerId?: true
    branchId?: true
    channel?: true
    status?: true
    totalGoldWeightGrams?: true
    wageWeightGrams?: true
    flatRialCharge?: true
    isSuspendedOverCreditLimit?: true
    deliveredAt?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type OrderAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Order to aggregate.
     */
    where?: OrderWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Orders to fetch.
     */
    orderBy?: OrderOrderByWithRelationInput | OrderOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: OrderWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Orders from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Orders.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Orders
    **/
    _count?: true | OrderCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: OrderAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: OrderSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: OrderMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: OrderMaxAggregateInputType
  }

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




  export type OrderGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: OrderWhereInput
    orderBy?: OrderOrderByWithAggregationInput | OrderOrderByWithAggregationInput[]
    by: OrderScalarFieldEnum[] | OrderScalarFieldEnum
    having?: OrderScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: OrderCountAggregateInputType | true
    _avg?: OrderAvgAggregateInputType
    _sum?: OrderSumAggregateInputType
    _min?: OrderMinAggregateInputType
    _max?: OrderMaxAggregateInputType
  }

  export type OrderGroupByOutputType = {
    id: string
    orderNumber: string
    customerId: string
    branchId: string | null
    channel: $Enums.OrderChannel
    status: $Enums.OrderStatus
    totalGoldWeightGrams: Decimal
    wageWeightGrams: Decimal
    flatRialCharge: Decimal
    isSuspendedOverCreditLimit: boolean
    deliveredAt: Date | null
    createdAt: Date
    updatedAt: Date
    _count: OrderCountAggregateOutputType | null
    _avg: OrderAvgAggregateOutputType | null
    _sum: OrderSumAggregateOutputType | null
    _min: OrderMinAggregateOutputType | null
    _max: OrderMaxAggregateOutputType | null
  }

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


  export type OrderSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    orderNumber?: boolean
    customerId?: boolean
    branchId?: boolean
    channel?: boolean
    status?: boolean
    totalGoldWeightGrams?: boolean
    wageWeightGrams?: boolean
    flatRialCharge?: boolean
    isSuspendedOverCreditLimit?: boolean
    deliveredAt?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
    branch?: boolean | Order$branchArgs<ExtArgs>
    items?: boolean | Order$itemsArgs<ExtArgs>
    statusEvents?: boolean | Order$statusEventsArgs<ExtArgs>
    ledgerEntries?: boolean | Order$ledgerEntriesArgs<ExtArgs>
    convertedFromPreOrder?: boolean | Order$convertedFromPreOrderArgs<ExtArgs>
    _count?: boolean | OrderCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["order"]>

  export type OrderSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    orderNumber?: boolean
    customerId?: boolean
    branchId?: boolean
    channel?: boolean
    status?: boolean
    totalGoldWeightGrams?: boolean
    wageWeightGrams?: boolean
    flatRialCharge?: boolean
    isSuspendedOverCreditLimit?: boolean
    deliveredAt?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
    branch?: boolean | Order$branchArgs<ExtArgs>
  }, ExtArgs["result"]["order"]>

  export type OrderSelectScalar = {
    id?: boolean
    orderNumber?: boolean
    customerId?: boolean
    branchId?: boolean
    channel?: boolean
    status?: boolean
    totalGoldWeightGrams?: boolean
    wageWeightGrams?: boolean
    flatRialCharge?: boolean
    isSuspendedOverCreditLimit?: boolean
    deliveredAt?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type OrderInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
    branch?: boolean | Order$branchArgs<ExtArgs>
    items?: boolean | Order$itemsArgs<ExtArgs>
    statusEvents?: boolean | Order$statusEventsArgs<ExtArgs>
    ledgerEntries?: boolean | Order$ledgerEntriesArgs<ExtArgs>
    convertedFromPreOrder?: boolean | Order$convertedFromPreOrderArgs<ExtArgs>
    _count?: boolean | OrderCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type OrderIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
    branch?: boolean | Order$branchArgs<ExtArgs>
  }

  export type $OrderPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Order"
    objects: {
      customer: Prisma.$CustomerPayload<ExtArgs>
      branch: Prisma.$BranchPayload<ExtArgs> | null
      items: Prisma.$OrderItemPayload<ExtArgs>[]
      statusEvents: Prisma.$OrderStatusEventPayload<ExtArgs>[]
      ledgerEntries: Prisma.$LedgerEntryPayload<ExtArgs>[]
      convertedFromPreOrder: Prisma.$PreOrderPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      orderNumber: string
      customerId: string
      branchId: string | null
      /**
       * Which sales channel placed this order — see OrderChannel.
       */
      channel: $Enums.OrderChannel
      status: $Enums.OrderStatus
      /**
       * Total gold weight incl. wage across all items ("allGram" / order.w).
       */
      totalGoldWeightGrams: Prisma.Decimal
      /**
       * Pure making-charge weight component (totalGoldWeightGrams minus raw weight sum).
       */
      wageWeightGrams: Prisma.Decimal
      /**
       * Flat Rial charge independent of gold price (e.g. stones) — legacy rial_input.
       */
      flatRialCharge: Prisma.Decimal
      isSuspendedOverCreditLimit: boolean
      deliveredAt: Date | null
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["order"]>
    composites: {}
  }

  type OrderGetPayload<S extends boolean | null | undefined | OrderDefaultArgs> = $Result.GetResult<Prisma.$OrderPayload, S>

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

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

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

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

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

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

    /**
     * Create a Order.
     * @param {OrderCreateArgs} args - Arguments to create a Order.
     * @example
     * // Create one Order
     * const Order = await prisma.order.create({
     *   data: {
     *     // ... data to create a Order
     *   }
     * })
     * 
     */
    create<T extends OrderCreateArgs>(args: SelectSubset<T, OrderCreateArgs<ExtArgs>>): Prisma__OrderClient<$Result.GetResult<Prisma.$OrderPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Order.
     * @param {OrderDeleteArgs} args - Arguments to delete one Order.
     * @example
     * // Delete one Order
     * const Order = await prisma.order.delete({
     *   where: {
     *     // ... filter to delete one Order
     *   }
     * })
     * 
     */
    delete<T extends OrderDeleteArgs>(args: SelectSubset<T, OrderDeleteArgs<ExtArgs>>): Prisma__OrderClient<$Result.GetResult<Prisma.$OrderPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Order.
   * 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__OrderClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    customer<T extends CustomerDefaultArgs<ExtArgs> = {}>(args?: Subset<T, CustomerDefaultArgs<ExtArgs>>): Prisma__CustomerClient<$Result.GetResult<Prisma.$CustomerPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    branch<T extends Order$branchArgs<ExtArgs> = {}>(args?: Subset<T, Order$branchArgs<ExtArgs>>): Prisma__BranchClient<$Result.GetResult<Prisma.$BranchPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    items<T extends Order$itemsArgs<ExtArgs> = {}>(args?: Subset<T, Order$itemsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$OrderItemPayload<ExtArgs>, T, "findMany"> | Null>
    statusEvents<T extends Order$statusEventsArgs<ExtArgs> = {}>(args?: Subset<T, Order$statusEventsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$OrderStatusEventPayload<ExtArgs>, T, "findMany"> | Null>
    ledgerEntries<T extends Order$ledgerEntriesArgs<ExtArgs> = {}>(args?: Subset<T, Order$ledgerEntriesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$LedgerEntryPayload<ExtArgs>, T, "findMany"> | Null>
    convertedFromPreOrder<T extends Order$convertedFromPreOrderArgs<ExtArgs> = {}>(args?: Subset<T, Order$convertedFromPreOrderArgs<ExtArgs>>): Prisma__PreOrderClient<$Result.GetResult<Prisma.$PreOrderPayload<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 Order model
   */ 
  interface OrderFieldRefs {
    readonly id: FieldRef<"Order", 'String'>
    readonly orderNumber: FieldRef<"Order", 'String'>
    readonly customerId: FieldRef<"Order", 'String'>
    readonly branchId: FieldRef<"Order", 'String'>
    readonly channel: FieldRef<"Order", 'OrderChannel'>
    readonly status: FieldRef<"Order", 'OrderStatus'>
    readonly totalGoldWeightGrams: FieldRef<"Order", 'Decimal'>
    readonly wageWeightGrams: FieldRef<"Order", 'Decimal'>
    readonly flatRialCharge: FieldRef<"Order", 'Decimal'>
    readonly isSuspendedOverCreditLimit: FieldRef<"Order", 'Boolean'>
    readonly deliveredAt: FieldRef<"Order", 'DateTime'>
    readonly createdAt: FieldRef<"Order", 'DateTime'>
    readonly updatedAt: FieldRef<"Order", 'DateTime'>
  }
    

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

  /**
   * Order findUniqueOrThrow
   */
  export type OrderFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Order
     */
    select?: OrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderInclude<ExtArgs> | null
    /**
     * Filter, which Order to fetch.
     */
    where: OrderWhereUniqueInput
  }

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

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

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

  /**
   * Order create
   */
  export type OrderCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Order
     */
    select?: OrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderInclude<ExtArgs> | null
    /**
     * The data needed to create a Order.
     */
    data: XOR<OrderCreateInput, OrderUncheckedCreateInput>
  }

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

  /**
   * Order createManyAndReturn
   */
  export type OrderCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Order
     */
    select?: OrderSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Orders.
     */
    data: OrderCreateManyInput | OrderCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Order update
   */
  export type OrderUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Order
     */
    select?: OrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderInclude<ExtArgs> | null
    /**
     * The data needed to update a Order.
     */
    data: XOR<OrderUpdateInput, OrderUncheckedUpdateInput>
    /**
     * Choose, which Order to update.
     */
    where: OrderWhereUniqueInput
  }

  /**
   * Order updateMany
   */
  export type OrderUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Orders.
     */
    data: XOR<OrderUpdateManyMutationInput, OrderUncheckedUpdateManyInput>
    /**
     * Filter which Orders to update
     */
    where?: OrderWhereInput
  }

  /**
   * Order upsert
   */
  export type OrderUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Order
     */
    select?: OrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderInclude<ExtArgs> | null
    /**
     * The filter to search for the Order to update in case it exists.
     */
    where: OrderWhereUniqueInput
    /**
     * In case the Order found by the `where` argument doesn't exist, create a new Order with this data.
     */
    create: XOR<OrderCreateInput, OrderUncheckedCreateInput>
    /**
     * In case the Order was found with the provided `where` argument, update it with this data.
     */
    update: XOR<OrderUpdateInput, OrderUncheckedUpdateInput>
  }

  /**
   * Order delete
   */
  export type OrderDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Order
     */
    select?: OrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderInclude<ExtArgs> | null
    /**
     * Filter which Order to delete.
     */
    where: OrderWhereUniqueInput
  }

  /**
   * Order deleteMany
   */
  export type OrderDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Orders to delete
     */
    where?: OrderWhereInput
  }

  /**
   * Order.branch
   */
  export type Order$branchArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Branch
     */
    select?: BranchSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchInclude<ExtArgs> | null
    where?: BranchWhereInput
  }

  /**
   * Order.items
   */
  export type Order$itemsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OrderItem
     */
    select?: OrderItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderItemInclude<ExtArgs> | null
    where?: OrderItemWhereInput
    orderBy?: OrderItemOrderByWithRelationInput | OrderItemOrderByWithRelationInput[]
    cursor?: OrderItemWhereUniqueInput
    take?: number
    skip?: number
    distinct?: OrderItemScalarFieldEnum | OrderItemScalarFieldEnum[]
  }

  /**
   * Order.statusEvents
   */
  export type Order$statusEventsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OrderStatusEvent
     */
    select?: OrderStatusEventSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderStatusEventInclude<ExtArgs> | null
    where?: OrderStatusEventWhereInput
    orderBy?: OrderStatusEventOrderByWithRelationInput | OrderStatusEventOrderByWithRelationInput[]
    cursor?: OrderStatusEventWhereUniqueInput
    take?: number
    skip?: number
    distinct?: OrderStatusEventScalarFieldEnum | OrderStatusEventScalarFieldEnum[]
  }

  /**
   * Order.ledgerEntries
   */
  export type Order$ledgerEntriesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LedgerEntry
     */
    select?: LedgerEntrySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LedgerEntryInclude<ExtArgs> | null
    where?: LedgerEntryWhereInput
    orderBy?: LedgerEntryOrderByWithRelationInput | LedgerEntryOrderByWithRelationInput[]
    cursor?: LedgerEntryWhereUniqueInput
    take?: number
    skip?: number
    distinct?: LedgerEntryScalarFieldEnum | LedgerEntryScalarFieldEnum[]
  }

  /**
   * Order.convertedFromPreOrder
   */
  export type Order$convertedFromPreOrderArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PreOrder
     */
    select?: PreOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PreOrderInclude<ExtArgs> | null
    where?: PreOrderWhereInput
  }

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


  /**
   * Model OrderItem
   */

  export type AggregateOrderItem = {
    _count: OrderItemCountAggregateOutputType | null
    _avg: OrderItemAvgAggregateOutputType | null
    _sum: OrderItemSumAggregateOutputType | null
    _min: OrderItemMinAggregateOutputType | null
    _max: OrderItemMaxAggregateOutputType | null
  }

  export type OrderItemAvgAggregateOutputType = {
    quantity: number | null
    rashWeightGramsSnapshot: Decimal | null
    wagePercentSnapshot: Decimal | null
    discountPercentSnapshot: Decimal | null
    computedWeightGrams: Decimal | null
    flatRialCharge: Decimal | null
  }

  export type OrderItemSumAggregateOutputType = {
    quantity: number | null
    rashWeightGramsSnapshot: Decimal | null
    wagePercentSnapshot: Decimal | null
    discountPercentSnapshot: Decimal | null
    computedWeightGrams: Decimal | null
    flatRialCharge: Decimal | null
  }

  export type OrderItemMinAggregateOutputType = {
    id: string | null
    orderId: string | null
    productVariantId: string | null
    quantity: number | null
    rashWeightGramsSnapshot: Decimal | null
    wagePercentSnapshot: Decimal | null
    discountPercentSnapshot: Decimal | null
    computedWeightGrams: Decimal | null
    flatRialCharge: Decimal | null
  }

  export type OrderItemMaxAggregateOutputType = {
    id: string | null
    orderId: string | null
    productVariantId: string | null
    quantity: number | null
    rashWeightGramsSnapshot: Decimal | null
    wagePercentSnapshot: Decimal | null
    discountPercentSnapshot: Decimal | null
    computedWeightGrams: Decimal | null
    flatRialCharge: Decimal | null
  }

  export type OrderItemCountAggregateOutputType = {
    id: number
    orderId: number
    productVariantId: number
    quantity: number
    rashWeightGramsSnapshot: number
    wagePercentSnapshot: number
    discountPercentSnapshot: number
    computedWeightGrams: number
    flatRialCharge: number
    _all: number
  }


  export type OrderItemAvgAggregateInputType = {
    quantity?: true
    rashWeightGramsSnapshot?: true
    wagePercentSnapshot?: true
    discountPercentSnapshot?: true
    computedWeightGrams?: true
    flatRialCharge?: true
  }

  export type OrderItemSumAggregateInputType = {
    quantity?: true
    rashWeightGramsSnapshot?: true
    wagePercentSnapshot?: true
    discountPercentSnapshot?: true
    computedWeightGrams?: true
    flatRialCharge?: true
  }

  export type OrderItemMinAggregateInputType = {
    id?: true
    orderId?: true
    productVariantId?: true
    quantity?: true
    rashWeightGramsSnapshot?: true
    wagePercentSnapshot?: true
    discountPercentSnapshot?: true
    computedWeightGrams?: true
    flatRialCharge?: true
  }

  export type OrderItemMaxAggregateInputType = {
    id?: true
    orderId?: true
    productVariantId?: true
    quantity?: true
    rashWeightGramsSnapshot?: true
    wagePercentSnapshot?: true
    discountPercentSnapshot?: true
    computedWeightGrams?: true
    flatRialCharge?: true
  }

  export type OrderItemCountAggregateInputType = {
    id?: true
    orderId?: true
    productVariantId?: true
    quantity?: true
    rashWeightGramsSnapshot?: true
    wagePercentSnapshot?: true
    discountPercentSnapshot?: true
    computedWeightGrams?: true
    flatRialCharge?: true
    _all?: true
  }

  export type OrderItemAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which OrderItem to aggregate.
     */
    where?: OrderItemWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of OrderItems to fetch.
     */
    orderBy?: OrderItemOrderByWithRelationInput | OrderItemOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: OrderItemWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` OrderItems from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` OrderItems.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned OrderItems
    **/
    _count?: true | OrderItemCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: OrderItemAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: OrderItemSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: OrderItemMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: OrderItemMaxAggregateInputType
  }

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




  export type OrderItemGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: OrderItemWhereInput
    orderBy?: OrderItemOrderByWithAggregationInput | OrderItemOrderByWithAggregationInput[]
    by: OrderItemScalarFieldEnum[] | OrderItemScalarFieldEnum
    having?: OrderItemScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: OrderItemCountAggregateInputType | true
    _avg?: OrderItemAvgAggregateInputType
    _sum?: OrderItemSumAggregateInputType
    _min?: OrderItemMinAggregateInputType
    _max?: OrderItemMaxAggregateInputType
  }

  export type OrderItemGroupByOutputType = {
    id: string
    orderId: string
    productVariantId: string
    quantity: number
    rashWeightGramsSnapshot: Decimal
    wagePercentSnapshot: Decimal
    discountPercentSnapshot: Decimal
    computedWeightGrams: Decimal
    flatRialCharge: Decimal
    _count: OrderItemCountAggregateOutputType | null
    _avg: OrderItemAvgAggregateOutputType | null
    _sum: OrderItemSumAggregateOutputType | null
    _min: OrderItemMinAggregateOutputType | null
    _max: OrderItemMaxAggregateOutputType | null
  }

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


  export type OrderItemSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    orderId?: boolean
    productVariantId?: boolean
    quantity?: boolean
    rashWeightGramsSnapshot?: boolean
    wagePercentSnapshot?: boolean
    discountPercentSnapshot?: boolean
    computedWeightGrams?: boolean
    flatRialCharge?: boolean
    order?: boolean | OrderDefaultArgs<ExtArgs>
    productVariant?: boolean | ProductVariantDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["orderItem"]>

  export type OrderItemSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    orderId?: boolean
    productVariantId?: boolean
    quantity?: boolean
    rashWeightGramsSnapshot?: boolean
    wagePercentSnapshot?: boolean
    discountPercentSnapshot?: boolean
    computedWeightGrams?: boolean
    flatRialCharge?: boolean
    order?: boolean | OrderDefaultArgs<ExtArgs>
    productVariant?: boolean | ProductVariantDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["orderItem"]>

  export type OrderItemSelectScalar = {
    id?: boolean
    orderId?: boolean
    productVariantId?: boolean
    quantity?: boolean
    rashWeightGramsSnapshot?: boolean
    wagePercentSnapshot?: boolean
    discountPercentSnapshot?: boolean
    computedWeightGrams?: boolean
    flatRialCharge?: boolean
  }

  export type OrderItemInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    order?: boolean | OrderDefaultArgs<ExtArgs>
    productVariant?: boolean | ProductVariantDefaultArgs<ExtArgs>
  }
  export type OrderItemIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    order?: boolean | OrderDefaultArgs<ExtArgs>
    productVariant?: boolean | ProductVariantDefaultArgs<ExtArgs>
  }

  export type $OrderItemPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "OrderItem"
    objects: {
      order: Prisma.$OrderPayload<ExtArgs>
      productVariant: Prisma.$ProductVariantPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      orderId: string
      productVariantId: string
      quantity: number
      rashWeightGramsSnapshot: Prisma.Decimal
      wagePercentSnapshot: Prisma.Decimal
      discountPercentSnapshot: Prisma.Decimal
      /**
       * computed: rash*(1 + (wagePercent-discount)/100)
       */
      computedWeightGrams: Prisma.Decimal
      flatRialCharge: Prisma.Decimal
    }, ExtArgs["result"]["orderItem"]>
    composites: {}
  }

  type OrderItemGetPayload<S extends boolean | null | undefined | OrderItemDefaultArgs> = $Result.GetResult<Prisma.$OrderItemPayload, S>

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

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

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

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

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

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

    /**
     * Create a OrderItem.
     * @param {OrderItemCreateArgs} args - Arguments to create a OrderItem.
     * @example
     * // Create one OrderItem
     * const OrderItem = await prisma.orderItem.create({
     *   data: {
     *     // ... data to create a OrderItem
     *   }
     * })
     * 
     */
    create<T extends OrderItemCreateArgs>(args: SelectSubset<T, OrderItemCreateArgs<ExtArgs>>): Prisma__OrderItemClient<$Result.GetResult<Prisma.$OrderItemPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a OrderItem.
     * @param {OrderItemDeleteArgs} args - Arguments to delete one OrderItem.
     * @example
     * // Delete one OrderItem
     * const OrderItem = await prisma.orderItem.delete({
     *   where: {
     *     // ... filter to delete one OrderItem
     *   }
     * })
     * 
     */
    delete<T extends OrderItemDeleteArgs>(args: SelectSubset<T, OrderItemDeleteArgs<ExtArgs>>): Prisma__OrderItemClient<$Result.GetResult<Prisma.$OrderItemPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for OrderItem.
   * 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__OrderItemClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    order<T extends OrderDefaultArgs<ExtArgs> = {}>(args?: Subset<T, OrderDefaultArgs<ExtArgs>>): Prisma__OrderClient<$Result.GetResult<Prisma.$OrderPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    productVariant<T extends ProductVariantDefaultArgs<ExtArgs> = {}>(args?: Subset<T, ProductVariantDefaultArgs<ExtArgs>>): Prisma__ProductVariantClient<$Result.GetResult<Prisma.$ProductVariantPayload<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 OrderItem model
   */ 
  interface OrderItemFieldRefs {
    readonly id: FieldRef<"OrderItem", 'String'>
    readonly orderId: FieldRef<"OrderItem", 'String'>
    readonly productVariantId: FieldRef<"OrderItem", 'String'>
    readonly quantity: FieldRef<"OrderItem", 'Int'>
    readonly rashWeightGramsSnapshot: FieldRef<"OrderItem", 'Decimal'>
    readonly wagePercentSnapshot: FieldRef<"OrderItem", 'Decimal'>
    readonly discountPercentSnapshot: FieldRef<"OrderItem", 'Decimal'>
    readonly computedWeightGrams: FieldRef<"OrderItem", 'Decimal'>
    readonly flatRialCharge: FieldRef<"OrderItem", 'Decimal'>
  }
    

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

  /**
   * OrderItem findUniqueOrThrow
   */
  export type OrderItemFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OrderItem
     */
    select?: OrderItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderItemInclude<ExtArgs> | null
    /**
     * Filter, which OrderItem to fetch.
     */
    where: OrderItemWhereUniqueInput
  }

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

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

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

  /**
   * OrderItem create
   */
  export type OrderItemCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OrderItem
     */
    select?: OrderItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderItemInclude<ExtArgs> | null
    /**
     * The data needed to create a OrderItem.
     */
    data: XOR<OrderItemCreateInput, OrderItemUncheckedCreateInput>
  }

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

  /**
   * OrderItem createManyAndReturn
   */
  export type OrderItemCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OrderItem
     */
    select?: OrderItemSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many OrderItems.
     */
    data: OrderItemCreateManyInput | OrderItemCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderItemIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * OrderItem update
   */
  export type OrderItemUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OrderItem
     */
    select?: OrderItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderItemInclude<ExtArgs> | null
    /**
     * The data needed to update a OrderItem.
     */
    data: XOR<OrderItemUpdateInput, OrderItemUncheckedUpdateInput>
    /**
     * Choose, which OrderItem to update.
     */
    where: OrderItemWhereUniqueInput
  }

  /**
   * OrderItem updateMany
   */
  export type OrderItemUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update OrderItems.
     */
    data: XOR<OrderItemUpdateManyMutationInput, OrderItemUncheckedUpdateManyInput>
    /**
     * Filter which OrderItems to update
     */
    where?: OrderItemWhereInput
  }

  /**
   * OrderItem upsert
   */
  export type OrderItemUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OrderItem
     */
    select?: OrderItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderItemInclude<ExtArgs> | null
    /**
     * The filter to search for the OrderItem to update in case it exists.
     */
    where: OrderItemWhereUniqueInput
    /**
     * In case the OrderItem found by the `where` argument doesn't exist, create a new OrderItem with this data.
     */
    create: XOR<OrderItemCreateInput, OrderItemUncheckedCreateInput>
    /**
     * In case the OrderItem was found with the provided `where` argument, update it with this data.
     */
    update: XOR<OrderItemUpdateInput, OrderItemUncheckedUpdateInput>
  }

  /**
   * OrderItem delete
   */
  export type OrderItemDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OrderItem
     */
    select?: OrderItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderItemInclude<ExtArgs> | null
    /**
     * Filter which OrderItem to delete.
     */
    where: OrderItemWhereUniqueInput
  }

  /**
   * OrderItem deleteMany
   */
  export type OrderItemDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which OrderItems to delete
     */
    where?: OrderItemWhereInput
  }

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


  /**
   * Model OrderStatusEvent
   */

  export type AggregateOrderStatusEvent = {
    _count: OrderStatusEventCountAggregateOutputType | null
    _min: OrderStatusEventMinAggregateOutputType | null
    _max: OrderStatusEventMaxAggregateOutputType | null
  }

  export type OrderStatusEventMinAggregateOutputType = {
    id: string | null
    orderId: string | null
    fromStatus: $Enums.OrderStatus | null
    toStatus: $Enums.OrderStatus | null
    note: string | null
    actorAdminUserId: string | null
    createdAt: Date | null
  }

  export type OrderStatusEventMaxAggregateOutputType = {
    id: string | null
    orderId: string | null
    fromStatus: $Enums.OrderStatus | null
    toStatus: $Enums.OrderStatus | null
    note: string | null
    actorAdminUserId: string | null
    createdAt: Date | null
  }

  export type OrderStatusEventCountAggregateOutputType = {
    id: number
    orderId: number
    fromStatus: number
    toStatus: number
    note: number
    actorAdminUserId: number
    createdAt: number
    _all: number
  }


  export type OrderStatusEventMinAggregateInputType = {
    id?: true
    orderId?: true
    fromStatus?: true
    toStatus?: true
    note?: true
    actorAdminUserId?: true
    createdAt?: true
  }

  export type OrderStatusEventMaxAggregateInputType = {
    id?: true
    orderId?: true
    fromStatus?: true
    toStatus?: true
    note?: true
    actorAdminUserId?: true
    createdAt?: true
  }

  export type OrderStatusEventCountAggregateInputType = {
    id?: true
    orderId?: true
    fromStatus?: true
    toStatus?: true
    note?: true
    actorAdminUserId?: true
    createdAt?: true
    _all?: true
  }

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

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




  export type OrderStatusEventGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: OrderStatusEventWhereInput
    orderBy?: OrderStatusEventOrderByWithAggregationInput | OrderStatusEventOrderByWithAggregationInput[]
    by: OrderStatusEventScalarFieldEnum[] | OrderStatusEventScalarFieldEnum
    having?: OrderStatusEventScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: OrderStatusEventCountAggregateInputType | true
    _min?: OrderStatusEventMinAggregateInputType
    _max?: OrderStatusEventMaxAggregateInputType
  }

  export type OrderStatusEventGroupByOutputType = {
    id: string
    orderId: string
    fromStatus: $Enums.OrderStatus | null
    toStatus: $Enums.OrderStatus
    note: string | null
    actorAdminUserId: string | null
    createdAt: Date
    _count: OrderStatusEventCountAggregateOutputType | null
    _min: OrderStatusEventMinAggregateOutputType | null
    _max: OrderStatusEventMaxAggregateOutputType | null
  }

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


  export type OrderStatusEventSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    orderId?: boolean
    fromStatus?: boolean
    toStatus?: boolean
    note?: boolean
    actorAdminUserId?: boolean
    createdAt?: boolean
    order?: boolean | OrderDefaultArgs<ExtArgs>
    actorAdminUser?: boolean | OrderStatusEvent$actorAdminUserArgs<ExtArgs>
  }, ExtArgs["result"]["orderStatusEvent"]>

  export type OrderStatusEventSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    orderId?: boolean
    fromStatus?: boolean
    toStatus?: boolean
    note?: boolean
    actorAdminUserId?: boolean
    createdAt?: boolean
    order?: boolean | OrderDefaultArgs<ExtArgs>
    actorAdminUser?: boolean | OrderStatusEvent$actorAdminUserArgs<ExtArgs>
  }, ExtArgs["result"]["orderStatusEvent"]>

  export type OrderStatusEventSelectScalar = {
    id?: boolean
    orderId?: boolean
    fromStatus?: boolean
    toStatus?: boolean
    note?: boolean
    actorAdminUserId?: boolean
    createdAt?: boolean
  }

  export type OrderStatusEventInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    order?: boolean | OrderDefaultArgs<ExtArgs>
    actorAdminUser?: boolean | OrderStatusEvent$actorAdminUserArgs<ExtArgs>
  }
  export type OrderStatusEventIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    order?: boolean | OrderDefaultArgs<ExtArgs>
    actorAdminUser?: boolean | OrderStatusEvent$actorAdminUserArgs<ExtArgs>
  }

  export type $OrderStatusEventPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "OrderStatusEvent"
    objects: {
      order: Prisma.$OrderPayload<ExtArgs>
      actorAdminUser: Prisma.$AdminUserPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      orderId: string
      fromStatus: $Enums.OrderStatus | null
      toStatus: $Enums.OrderStatus
      note: string | null
      actorAdminUserId: string | null
      createdAt: Date
    }, ExtArgs["result"]["orderStatusEvent"]>
    composites: {}
  }

  type OrderStatusEventGetPayload<S extends boolean | null | undefined | OrderStatusEventDefaultArgs> = $Result.GetResult<Prisma.$OrderStatusEventPayload, S>

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

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

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

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

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

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

    /**
     * Create a OrderStatusEvent.
     * @param {OrderStatusEventCreateArgs} args - Arguments to create a OrderStatusEvent.
     * @example
     * // Create one OrderStatusEvent
     * const OrderStatusEvent = await prisma.orderStatusEvent.create({
     *   data: {
     *     // ... data to create a OrderStatusEvent
     *   }
     * })
     * 
     */
    create<T extends OrderStatusEventCreateArgs>(args: SelectSubset<T, OrderStatusEventCreateArgs<ExtArgs>>): Prisma__OrderStatusEventClient<$Result.GetResult<Prisma.$OrderStatusEventPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a OrderStatusEvent.
     * @param {OrderStatusEventDeleteArgs} args - Arguments to delete one OrderStatusEvent.
     * @example
     * // Delete one OrderStatusEvent
     * const OrderStatusEvent = await prisma.orderStatusEvent.delete({
     *   where: {
     *     // ... filter to delete one OrderStatusEvent
     *   }
     * })
     * 
     */
    delete<T extends OrderStatusEventDeleteArgs>(args: SelectSubset<T, OrderStatusEventDeleteArgs<ExtArgs>>): Prisma__OrderStatusEventClient<$Result.GetResult<Prisma.$OrderStatusEventPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for OrderStatusEvent.
   * 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__OrderStatusEventClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    order<T extends OrderDefaultArgs<ExtArgs> = {}>(args?: Subset<T, OrderDefaultArgs<ExtArgs>>): Prisma__OrderClient<$Result.GetResult<Prisma.$OrderPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    actorAdminUser<T extends OrderStatusEvent$actorAdminUserArgs<ExtArgs> = {}>(args?: Subset<T, OrderStatusEvent$actorAdminUserArgs<ExtArgs>>): Prisma__AdminUserClient<$Result.GetResult<Prisma.$AdminUserPayload<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 OrderStatusEvent model
   */ 
  interface OrderStatusEventFieldRefs {
    readonly id: FieldRef<"OrderStatusEvent", 'String'>
    readonly orderId: FieldRef<"OrderStatusEvent", 'String'>
    readonly fromStatus: FieldRef<"OrderStatusEvent", 'OrderStatus'>
    readonly toStatus: FieldRef<"OrderStatusEvent", 'OrderStatus'>
    readonly note: FieldRef<"OrderStatusEvent", 'String'>
    readonly actorAdminUserId: FieldRef<"OrderStatusEvent", 'String'>
    readonly createdAt: FieldRef<"OrderStatusEvent", 'DateTime'>
  }
    

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

  /**
   * OrderStatusEvent findUniqueOrThrow
   */
  export type OrderStatusEventFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OrderStatusEvent
     */
    select?: OrderStatusEventSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderStatusEventInclude<ExtArgs> | null
    /**
     * Filter, which OrderStatusEvent to fetch.
     */
    where: OrderStatusEventWhereUniqueInput
  }

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

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

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

  /**
   * OrderStatusEvent create
   */
  export type OrderStatusEventCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OrderStatusEvent
     */
    select?: OrderStatusEventSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderStatusEventInclude<ExtArgs> | null
    /**
     * The data needed to create a OrderStatusEvent.
     */
    data: XOR<OrderStatusEventCreateInput, OrderStatusEventUncheckedCreateInput>
  }

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

  /**
   * OrderStatusEvent createManyAndReturn
   */
  export type OrderStatusEventCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OrderStatusEvent
     */
    select?: OrderStatusEventSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many OrderStatusEvents.
     */
    data: OrderStatusEventCreateManyInput | OrderStatusEventCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderStatusEventIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * OrderStatusEvent update
   */
  export type OrderStatusEventUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OrderStatusEvent
     */
    select?: OrderStatusEventSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderStatusEventInclude<ExtArgs> | null
    /**
     * The data needed to update a OrderStatusEvent.
     */
    data: XOR<OrderStatusEventUpdateInput, OrderStatusEventUncheckedUpdateInput>
    /**
     * Choose, which OrderStatusEvent to update.
     */
    where: OrderStatusEventWhereUniqueInput
  }

  /**
   * OrderStatusEvent updateMany
   */
  export type OrderStatusEventUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update OrderStatusEvents.
     */
    data: XOR<OrderStatusEventUpdateManyMutationInput, OrderStatusEventUncheckedUpdateManyInput>
    /**
     * Filter which OrderStatusEvents to update
     */
    where?: OrderStatusEventWhereInput
  }

  /**
   * OrderStatusEvent upsert
   */
  export type OrderStatusEventUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OrderStatusEvent
     */
    select?: OrderStatusEventSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderStatusEventInclude<ExtArgs> | null
    /**
     * The filter to search for the OrderStatusEvent to update in case it exists.
     */
    where: OrderStatusEventWhereUniqueInput
    /**
     * In case the OrderStatusEvent found by the `where` argument doesn't exist, create a new OrderStatusEvent with this data.
     */
    create: XOR<OrderStatusEventCreateInput, OrderStatusEventUncheckedCreateInput>
    /**
     * In case the OrderStatusEvent was found with the provided `where` argument, update it with this data.
     */
    update: XOR<OrderStatusEventUpdateInput, OrderStatusEventUncheckedUpdateInput>
  }

  /**
   * OrderStatusEvent delete
   */
  export type OrderStatusEventDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the OrderStatusEvent
     */
    select?: OrderStatusEventSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderStatusEventInclude<ExtArgs> | null
    /**
     * Filter which OrderStatusEvent to delete.
     */
    where: OrderStatusEventWhereUniqueInput
  }

  /**
   * OrderStatusEvent deleteMany
   */
  export type OrderStatusEventDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which OrderStatusEvents to delete
     */
    where?: OrderStatusEventWhereInput
  }

  /**
   * OrderStatusEvent.actorAdminUser
   */
  export type OrderStatusEvent$actorAdminUserArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AdminUser
     */
    select?: AdminUserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AdminUserInclude<ExtArgs> | null
    where?: AdminUserWhereInput
  }

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


  /**
   * Model PreOrder
   */

  export type AggregatePreOrder = {
    _count: PreOrderCountAggregateOutputType | null
    _avg: PreOrderAvgAggregateOutputType | null
    _sum: PreOrderSumAggregateOutputType | null
    _min: PreOrderMinAggregateOutputType | null
    _max: PreOrderMaxAggregateOutputType | null
  }

  export type PreOrderAvgAggregateOutputType = {
    estimatedWeightGrams: Decimal | null
    estimatedPriceRial: Decimal | null
  }

  export type PreOrderSumAggregateOutputType = {
    estimatedWeightGrams: Decimal | null
    estimatedPriceRial: Decimal | null
  }

  export type PreOrderMinAggregateOutputType = {
    id: string | null
    customerId: string | null
    cityId: string | null
    workshopId: string | null
    status: $Enums.PreOrderStatus | null
    designImageUrl: string | null
    colorName: string | null
    sizeSpec: string | null
    stoneColor: string | null
    minaColor: string | null
    estimatedWeightGrams: Decimal | null
    estimatedPriceRial: Decimal | null
    description: string | null
    convertedOrderId: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type PreOrderMaxAggregateOutputType = {
    id: string | null
    customerId: string | null
    cityId: string | null
    workshopId: string | null
    status: $Enums.PreOrderStatus | null
    designImageUrl: string | null
    colorName: string | null
    sizeSpec: string | null
    stoneColor: string | null
    minaColor: string | null
    estimatedWeightGrams: Decimal | null
    estimatedPriceRial: Decimal | null
    description: string | null
    convertedOrderId: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type PreOrderCountAggregateOutputType = {
    id: number
    customerId: number
    cityId: number
    workshopId: number
    status: number
    designImageUrl: number
    colorName: number
    sizeSpec: number
    stoneColor: number
    minaColor: number
    estimatedWeightGrams: number
    estimatedPriceRial: number
    description: number
    convertedOrderId: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type PreOrderAvgAggregateInputType = {
    estimatedWeightGrams?: true
    estimatedPriceRial?: true
  }

  export type PreOrderSumAggregateInputType = {
    estimatedWeightGrams?: true
    estimatedPriceRial?: true
  }

  export type PreOrderMinAggregateInputType = {
    id?: true
    customerId?: true
    cityId?: true
    workshopId?: true
    status?: true
    designImageUrl?: true
    colorName?: true
    sizeSpec?: true
    stoneColor?: true
    minaColor?: true
    estimatedWeightGrams?: true
    estimatedPriceRial?: true
    description?: true
    convertedOrderId?: true
    createdAt?: true
    updatedAt?: true
  }

  export type PreOrderMaxAggregateInputType = {
    id?: true
    customerId?: true
    cityId?: true
    workshopId?: true
    status?: true
    designImageUrl?: true
    colorName?: true
    sizeSpec?: true
    stoneColor?: true
    minaColor?: true
    estimatedWeightGrams?: true
    estimatedPriceRial?: true
    description?: true
    convertedOrderId?: true
    createdAt?: true
    updatedAt?: true
  }

  export type PreOrderCountAggregateInputType = {
    id?: true
    customerId?: true
    cityId?: true
    workshopId?: true
    status?: true
    designImageUrl?: true
    colorName?: true
    sizeSpec?: true
    stoneColor?: true
    minaColor?: true
    estimatedWeightGrams?: true
    estimatedPriceRial?: true
    description?: true
    convertedOrderId?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type PreOrderAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which PreOrder to aggregate.
     */
    where?: PreOrderWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PreOrders to fetch.
     */
    orderBy?: PreOrderOrderByWithRelationInput | PreOrderOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: PreOrderWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PreOrders from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` PreOrders.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned PreOrders
    **/
    _count?: true | PreOrderCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: PreOrderAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: PreOrderSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: PreOrderMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: PreOrderMaxAggregateInputType
  }

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




  export type PreOrderGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PreOrderWhereInput
    orderBy?: PreOrderOrderByWithAggregationInput | PreOrderOrderByWithAggregationInput[]
    by: PreOrderScalarFieldEnum[] | PreOrderScalarFieldEnum
    having?: PreOrderScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: PreOrderCountAggregateInputType | true
    _avg?: PreOrderAvgAggregateInputType
    _sum?: PreOrderSumAggregateInputType
    _min?: PreOrderMinAggregateInputType
    _max?: PreOrderMaxAggregateInputType
  }

  export type PreOrderGroupByOutputType = {
    id: string
    customerId: string
    cityId: string | null
    workshopId: string | null
    status: $Enums.PreOrderStatus
    designImageUrl: string | null
    colorName: string | null
    sizeSpec: string | null
    stoneColor: string | null
    minaColor: string | null
    estimatedWeightGrams: Decimal | null
    estimatedPriceRial: Decimal | null
    description: string | null
    convertedOrderId: string | null
    createdAt: Date
    updatedAt: Date
    _count: PreOrderCountAggregateOutputType | null
    _avg: PreOrderAvgAggregateOutputType | null
    _sum: PreOrderSumAggregateOutputType | null
    _min: PreOrderMinAggregateOutputType | null
    _max: PreOrderMaxAggregateOutputType | null
  }

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


  export type PreOrderSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    customerId?: boolean
    cityId?: boolean
    workshopId?: boolean
    status?: boolean
    designImageUrl?: boolean
    colorName?: boolean
    sizeSpec?: boolean
    stoneColor?: boolean
    minaColor?: boolean
    estimatedWeightGrams?: boolean
    estimatedPriceRial?: boolean
    description?: boolean
    convertedOrderId?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
    city?: boolean | PreOrder$cityArgs<ExtArgs>
    workshop?: boolean | PreOrder$workshopArgs<ExtArgs>
    convertedOrder?: boolean | PreOrder$convertedOrderArgs<ExtArgs>
    statusEvents?: boolean | PreOrder$statusEventsArgs<ExtArgs>
    _count?: boolean | PreOrderCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["preOrder"]>

  export type PreOrderSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    customerId?: boolean
    cityId?: boolean
    workshopId?: boolean
    status?: boolean
    designImageUrl?: boolean
    colorName?: boolean
    sizeSpec?: boolean
    stoneColor?: boolean
    minaColor?: boolean
    estimatedWeightGrams?: boolean
    estimatedPriceRial?: boolean
    description?: boolean
    convertedOrderId?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
    city?: boolean | PreOrder$cityArgs<ExtArgs>
    workshop?: boolean | PreOrder$workshopArgs<ExtArgs>
    convertedOrder?: boolean | PreOrder$convertedOrderArgs<ExtArgs>
  }, ExtArgs["result"]["preOrder"]>

  export type PreOrderSelectScalar = {
    id?: boolean
    customerId?: boolean
    cityId?: boolean
    workshopId?: boolean
    status?: boolean
    designImageUrl?: boolean
    colorName?: boolean
    sizeSpec?: boolean
    stoneColor?: boolean
    minaColor?: boolean
    estimatedWeightGrams?: boolean
    estimatedPriceRial?: boolean
    description?: boolean
    convertedOrderId?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type PreOrderInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
    city?: boolean | PreOrder$cityArgs<ExtArgs>
    workshop?: boolean | PreOrder$workshopArgs<ExtArgs>
    convertedOrder?: boolean | PreOrder$convertedOrderArgs<ExtArgs>
    statusEvents?: boolean | PreOrder$statusEventsArgs<ExtArgs>
    _count?: boolean | PreOrderCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type PreOrderIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
    city?: boolean | PreOrder$cityArgs<ExtArgs>
    workshop?: boolean | PreOrder$workshopArgs<ExtArgs>
    convertedOrder?: boolean | PreOrder$convertedOrderArgs<ExtArgs>
  }

  export type $PreOrderPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "PreOrder"
    objects: {
      customer: Prisma.$CustomerPayload<ExtArgs>
      city: Prisma.$CityPayload<ExtArgs> | null
      workshop: Prisma.$WorkshopPayload<ExtArgs> | null
      convertedOrder: Prisma.$OrderPayload<ExtArgs> | null
      statusEvents: Prisma.$PreOrderStatusEventPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      customerId: string
      cityId: string | null
      workshopId: string | null
      status: $Enums.PreOrderStatus
      designImageUrl: string | null
      colorName: string | null
      sizeSpec: string | null
      stoneColor: string | null
      minaColor: string | null
      estimatedWeightGrams: Prisma.Decimal | null
      estimatedPriceRial: Prisma.Decimal | null
      description: string | null
      /**
       * Once priced, an admin converts this into a real (debt-bearing) Order.
       */
      convertedOrderId: string | null
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["preOrder"]>
    composites: {}
  }

  type PreOrderGetPayload<S extends boolean | null | undefined | PreOrderDefaultArgs> = $Result.GetResult<Prisma.$PreOrderPayload, S>

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

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

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

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

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

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

    /**
     * Create a PreOrder.
     * @param {PreOrderCreateArgs} args - Arguments to create a PreOrder.
     * @example
     * // Create one PreOrder
     * const PreOrder = await prisma.preOrder.create({
     *   data: {
     *     // ... data to create a PreOrder
     *   }
     * })
     * 
     */
    create<T extends PreOrderCreateArgs>(args: SelectSubset<T, PreOrderCreateArgs<ExtArgs>>): Prisma__PreOrderClient<$Result.GetResult<Prisma.$PreOrderPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a PreOrder.
     * @param {PreOrderDeleteArgs} args - Arguments to delete one PreOrder.
     * @example
     * // Delete one PreOrder
     * const PreOrder = await prisma.preOrder.delete({
     *   where: {
     *     // ... filter to delete one PreOrder
     *   }
     * })
     * 
     */
    delete<T extends PreOrderDeleteArgs>(args: SelectSubset<T, PreOrderDeleteArgs<ExtArgs>>): Prisma__PreOrderClient<$Result.GetResult<Prisma.$PreOrderPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for PreOrder.
   * 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__PreOrderClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    customer<T extends CustomerDefaultArgs<ExtArgs> = {}>(args?: Subset<T, CustomerDefaultArgs<ExtArgs>>): Prisma__CustomerClient<$Result.GetResult<Prisma.$CustomerPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    city<T extends PreOrder$cityArgs<ExtArgs> = {}>(args?: Subset<T, PreOrder$cityArgs<ExtArgs>>): Prisma__CityClient<$Result.GetResult<Prisma.$CityPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    workshop<T extends PreOrder$workshopArgs<ExtArgs> = {}>(args?: Subset<T, PreOrder$workshopArgs<ExtArgs>>): Prisma__WorkshopClient<$Result.GetResult<Prisma.$WorkshopPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    convertedOrder<T extends PreOrder$convertedOrderArgs<ExtArgs> = {}>(args?: Subset<T, PreOrder$convertedOrderArgs<ExtArgs>>): Prisma__OrderClient<$Result.GetResult<Prisma.$OrderPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    statusEvents<T extends PreOrder$statusEventsArgs<ExtArgs> = {}>(args?: Subset<T, PreOrder$statusEventsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PreOrderStatusEventPayload<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 PreOrder model
   */ 
  interface PreOrderFieldRefs {
    readonly id: FieldRef<"PreOrder", 'String'>
    readonly customerId: FieldRef<"PreOrder", 'String'>
    readonly cityId: FieldRef<"PreOrder", 'String'>
    readonly workshopId: FieldRef<"PreOrder", 'String'>
    readonly status: FieldRef<"PreOrder", 'PreOrderStatus'>
    readonly designImageUrl: FieldRef<"PreOrder", 'String'>
    readonly colorName: FieldRef<"PreOrder", 'String'>
    readonly sizeSpec: FieldRef<"PreOrder", 'String'>
    readonly stoneColor: FieldRef<"PreOrder", 'String'>
    readonly minaColor: FieldRef<"PreOrder", 'String'>
    readonly estimatedWeightGrams: FieldRef<"PreOrder", 'Decimal'>
    readonly estimatedPriceRial: FieldRef<"PreOrder", 'Decimal'>
    readonly description: FieldRef<"PreOrder", 'String'>
    readonly convertedOrderId: FieldRef<"PreOrder", 'String'>
    readonly createdAt: FieldRef<"PreOrder", 'DateTime'>
    readonly updatedAt: FieldRef<"PreOrder", 'DateTime'>
  }
    

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

  /**
   * PreOrder findUniqueOrThrow
   */
  export type PreOrderFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PreOrder
     */
    select?: PreOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PreOrderInclude<ExtArgs> | null
    /**
     * Filter, which PreOrder to fetch.
     */
    where: PreOrderWhereUniqueInput
  }

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

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

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

  /**
   * PreOrder create
   */
  export type PreOrderCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PreOrder
     */
    select?: PreOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PreOrderInclude<ExtArgs> | null
    /**
     * The data needed to create a PreOrder.
     */
    data: XOR<PreOrderCreateInput, PreOrderUncheckedCreateInput>
  }

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

  /**
   * PreOrder createManyAndReturn
   */
  export type PreOrderCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PreOrder
     */
    select?: PreOrderSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many PreOrders.
     */
    data: PreOrderCreateManyInput | PreOrderCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PreOrderIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * PreOrder update
   */
  export type PreOrderUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PreOrder
     */
    select?: PreOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PreOrderInclude<ExtArgs> | null
    /**
     * The data needed to update a PreOrder.
     */
    data: XOR<PreOrderUpdateInput, PreOrderUncheckedUpdateInput>
    /**
     * Choose, which PreOrder to update.
     */
    where: PreOrderWhereUniqueInput
  }

  /**
   * PreOrder updateMany
   */
  export type PreOrderUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update PreOrders.
     */
    data: XOR<PreOrderUpdateManyMutationInput, PreOrderUncheckedUpdateManyInput>
    /**
     * Filter which PreOrders to update
     */
    where?: PreOrderWhereInput
  }

  /**
   * PreOrder upsert
   */
  export type PreOrderUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PreOrder
     */
    select?: PreOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PreOrderInclude<ExtArgs> | null
    /**
     * The filter to search for the PreOrder to update in case it exists.
     */
    where: PreOrderWhereUniqueInput
    /**
     * In case the PreOrder found by the `where` argument doesn't exist, create a new PreOrder with this data.
     */
    create: XOR<PreOrderCreateInput, PreOrderUncheckedCreateInput>
    /**
     * In case the PreOrder was found with the provided `where` argument, update it with this data.
     */
    update: XOR<PreOrderUpdateInput, PreOrderUncheckedUpdateInput>
  }

  /**
   * PreOrder delete
   */
  export type PreOrderDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PreOrder
     */
    select?: PreOrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PreOrderInclude<ExtArgs> | null
    /**
     * Filter which PreOrder to delete.
     */
    where: PreOrderWhereUniqueInput
  }

  /**
   * PreOrder deleteMany
   */
  export type PreOrderDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which PreOrders to delete
     */
    where?: PreOrderWhereInput
  }

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

  /**
   * PreOrder.workshop
   */
  export type PreOrder$workshopArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Workshop
     */
    select?: WorkshopSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WorkshopInclude<ExtArgs> | null
    where?: WorkshopWhereInput
  }

  /**
   * PreOrder.convertedOrder
   */
  export type PreOrder$convertedOrderArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Order
     */
    select?: OrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderInclude<ExtArgs> | null
    where?: OrderWhereInput
  }

  /**
   * PreOrder.statusEvents
   */
  export type PreOrder$statusEventsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PreOrderStatusEvent
     */
    select?: PreOrderStatusEventSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PreOrderStatusEventInclude<ExtArgs> | null
    where?: PreOrderStatusEventWhereInput
    orderBy?: PreOrderStatusEventOrderByWithRelationInput | PreOrderStatusEventOrderByWithRelationInput[]
    cursor?: PreOrderStatusEventWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PreOrderStatusEventScalarFieldEnum | PreOrderStatusEventScalarFieldEnum[]
  }

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


  /**
   * Model PreOrderStatusEvent
   */

  export type AggregatePreOrderStatusEvent = {
    _count: PreOrderStatusEventCountAggregateOutputType | null
    _min: PreOrderStatusEventMinAggregateOutputType | null
    _max: PreOrderStatusEventMaxAggregateOutputType | null
  }

  export type PreOrderStatusEventMinAggregateOutputType = {
    id: string | null
    preOrderId: string | null
    actorAdminUserId: string | null
    ipAddress: string | null
    createdAt: Date | null
  }

  export type PreOrderStatusEventMaxAggregateOutputType = {
    id: string | null
    preOrderId: string | null
    actorAdminUserId: string | null
    ipAddress: string | null
    createdAt: Date | null
  }

  export type PreOrderStatusEventCountAggregateOutputType = {
    id: number
    preOrderId: number
    changes: number
    actorAdminUserId: number
    ipAddress: number
    createdAt: number
    _all: number
  }


  export type PreOrderStatusEventMinAggregateInputType = {
    id?: true
    preOrderId?: true
    actorAdminUserId?: true
    ipAddress?: true
    createdAt?: true
  }

  export type PreOrderStatusEventMaxAggregateInputType = {
    id?: true
    preOrderId?: true
    actorAdminUserId?: true
    ipAddress?: true
    createdAt?: true
  }

  export type PreOrderStatusEventCountAggregateInputType = {
    id?: true
    preOrderId?: true
    changes?: true
    actorAdminUserId?: true
    ipAddress?: true
    createdAt?: true
    _all?: true
  }

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

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




  export type PreOrderStatusEventGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PreOrderStatusEventWhereInput
    orderBy?: PreOrderStatusEventOrderByWithAggregationInput | PreOrderStatusEventOrderByWithAggregationInput[]
    by: PreOrderStatusEventScalarFieldEnum[] | PreOrderStatusEventScalarFieldEnum
    having?: PreOrderStatusEventScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: PreOrderStatusEventCountAggregateInputType | true
    _min?: PreOrderStatusEventMinAggregateInputType
    _max?: PreOrderStatusEventMaxAggregateInputType
  }

  export type PreOrderStatusEventGroupByOutputType = {
    id: string
    preOrderId: string
    changes: JsonValue
    actorAdminUserId: string | null
    ipAddress: string | null
    createdAt: Date
    _count: PreOrderStatusEventCountAggregateOutputType | null
    _min: PreOrderStatusEventMinAggregateOutputType | null
    _max: PreOrderStatusEventMaxAggregateOutputType | null
  }

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


  export type PreOrderStatusEventSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    preOrderId?: boolean
    changes?: boolean
    actorAdminUserId?: boolean
    ipAddress?: boolean
    createdAt?: boolean
    preOrder?: boolean | PreOrderDefaultArgs<ExtArgs>
    actorAdminUser?: boolean | PreOrderStatusEvent$actorAdminUserArgs<ExtArgs>
  }, ExtArgs["result"]["preOrderStatusEvent"]>

  export type PreOrderStatusEventSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    preOrderId?: boolean
    changes?: boolean
    actorAdminUserId?: boolean
    ipAddress?: boolean
    createdAt?: boolean
    preOrder?: boolean | PreOrderDefaultArgs<ExtArgs>
    actorAdminUser?: boolean | PreOrderStatusEvent$actorAdminUserArgs<ExtArgs>
  }, ExtArgs["result"]["preOrderStatusEvent"]>

  export type PreOrderStatusEventSelectScalar = {
    id?: boolean
    preOrderId?: boolean
    changes?: boolean
    actorAdminUserId?: boolean
    ipAddress?: boolean
    createdAt?: boolean
  }

  export type PreOrderStatusEventInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    preOrder?: boolean | PreOrderDefaultArgs<ExtArgs>
    actorAdminUser?: boolean | PreOrderStatusEvent$actorAdminUserArgs<ExtArgs>
  }
  export type PreOrderStatusEventIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    preOrder?: boolean | PreOrderDefaultArgs<ExtArgs>
    actorAdminUser?: boolean | PreOrderStatusEvent$actorAdminUserArgs<ExtArgs>
  }

  export type $PreOrderStatusEventPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "PreOrderStatusEvent"
    objects: {
      preOrder: Prisma.$PreOrderPayload<ExtArgs>
      actorAdminUser: Prisma.$AdminUserPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      preOrderId: string
      /**
       * Field-level diff, e.g. {"status": {"old": "PLACED", "new": "ADMIN_APPROVED"}}
       */
      changes: Prisma.JsonValue
      actorAdminUserId: string | null
      ipAddress: string | null
      createdAt: Date
    }, ExtArgs["result"]["preOrderStatusEvent"]>
    composites: {}
  }

  type PreOrderStatusEventGetPayload<S extends boolean | null | undefined | PreOrderStatusEventDefaultArgs> = $Result.GetResult<Prisma.$PreOrderStatusEventPayload, S>

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

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

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

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

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

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

    /**
     * Create a PreOrderStatusEvent.
     * @param {PreOrderStatusEventCreateArgs} args - Arguments to create a PreOrderStatusEvent.
     * @example
     * // Create one PreOrderStatusEvent
     * const PreOrderStatusEvent = await prisma.preOrderStatusEvent.create({
     *   data: {
     *     // ... data to create a PreOrderStatusEvent
     *   }
     * })
     * 
     */
    create<T extends PreOrderStatusEventCreateArgs>(args: SelectSubset<T, PreOrderStatusEventCreateArgs<ExtArgs>>): Prisma__PreOrderStatusEventClient<$Result.GetResult<Prisma.$PreOrderStatusEventPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a PreOrderStatusEvent.
     * @param {PreOrderStatusEventDeleteArgs} args - Arguments to delete one PreOrderStatusEvent.
     * @example
     * // Delete one PreOrderStatusEvent
     * const PreOrderStatusEvent = await prisma.preOrderStatusEvent.delete({
     *   where: {
     *     // ... filter to delete one PreOrderStatusEvent
     *   }
     * })
     * 
     */
    delete<T extends PreOrderStatusEventDeleteArgs>(args: SelectSubset<T, PreOrderStatusEventDeleteArgs<ExtArgs>>): Prisma__PreOrderStatusEventClient<$Result.GetResult<Prisma.$PreOrderStatusEventPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for PreOrderStatusEvent.
   * 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__PreOrderStatusEventClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    preOrder<T extends PreOrderDefaultArgs<ExtArgs> = {}>(args?: Subset<T, PreOrderDefaultArgs<ExtArgs>>): Prisma__PreOrderClient<$Result.GetResult<Prisma.$PreOrderPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    actorAdminUser<T extends PreOrderStatusEvent$actorAdminUserArgs<ExtArgs> = {}>(args?: Subset<T, PreOrderStatusEvent$actorAdminUserArgs<ExtArgs>>): Prisma__AdminUserClient<$Result.GetResult<Prisma.$AdminUserPayload<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 PreOrderStatusEvent model
   */ 
  interface PreOrderStatusEventFieldRefs {
    readonly id: FieldRef<"PreOrderStatusEvent", 'String'>
    readonly preOrderId: FieldRef<"PreOrderStatusEvent", 'String'>
    readonly changes: FieldRef<"PreOrderStatusEvent", 'Json'>
    readonly actorAdminUserId: FieldRef<"PreOrderStatusEvent", 'String'>
    readonly ipAddress: FieldRef<"PreOrderStatusEvent", 'String'>
    readonly createdAt: FieldRef<"PreOrderStatusEvent", 'DateTime'>
  }
    

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

  /**
   * PreOrderStatusEvent findUniqueOrThrow
   */
  export type PreOrderStatusEventFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PreOrderStatusEvent
     */
    select?: PreOrderStatusEventSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PreOrderStatusEventInclude<ExtArgs> | null
    /**
     * Filter, which PreOrderStatusEvent to fetch.
     */
    where: PreOrderStatusEventWhereUniqueInput
  }

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

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

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

  /**
   * PreOrderStatusEvent create
   */
  export type PreOrderStatusEventCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PreOrderStatusEvent
     */
    select?: PreOrderStatusEventSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PreOrderStatusEventInclude<ExtArgs> | null
    /**
     * The data needed to create a PreOrderStatusEvent.
     */
    data: XOR<PreOrderStatusEventCreateInput, PreOrderStatusEventUncheckedCreateInput>
  }

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

  /**
   * PreOrderStatusEvent createManyAndReturn
   */
  export type PreOrderStatusEventCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PreOrderStatusEvent
     */
    select?: PreOrderStatusEventSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many PreOrderStatusEvents.
     */
    data: PreOrderStatusEventCreateManyInput | PreOrderStatusEventCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PreOrderStatusEventIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * PreOrderStatusEvent update
   */
  export type PreOrderStatusEventUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PreOrderStatusEvent
     */
    select?: PreOrderStatusEventSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PreOrderStatusEventInclude<ExtArgs> | null
    /**
     * The data needed to update a PreOrderStatusEvent.
     */
    data: XOR<PreOrderStatusEventUpdateInput, PreOrderStatusEventUncheckedUpdateInput>
    /**
     * Choose, which PreOrderStatusEvent to update.
     */
    where: PreOrderStatusEventWhereUniqueInput
  }

  /**
   * PreOrderStatusEvent updateMany
   */
  export type PreOrderStatusEventUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update PreOrderStatusEvents.
     */
    data: XOR<PreOrderStatusEventUpdateManyMutationInput, PreOrderStatusEventUncheckedUpdateManyInput>
    /**
     * Filter which PreOrderStatusEvents to update
     */
    where?: PreOrderStatusEventWhereInput
  }

  /**
   * PreOrderStatusEvent upsert
   */
  export type PreOrderStatusEventUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PreOrderStatusEvent
     */
    select?: PreOrderStatusEventSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PreOrderStatusEventInclude<ExtArgs> | null
    /**
     * The filter to search for the PreOrderStatusEvent to update in case it exists.
     */
    where: PreOrderStatusEventWhereUniqueInput
    /**
     * In case the PreOrderStatusEvent found by the `where` argument doesn't exist, create a new PreOrderStatusEvent with this data.
     */
    create: XOR<PreOrderStatusEventCreateInput, PreOrderStatusEventUncheckedCreateInput>
    /**
     * In case the PreOrderStatusEvent was found with the provided `where` argument, update it with this data.
     */
    update: XOR<PreOrderStatusEventUpdateInput, PreOrderStatusEventUncheckedUpdateInput>
  }

  /**
   * PreOrderStatusEvent delete
   */
  export type PreOrderStatusEventDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PreOrderStatusEvent
     */
    select?: PreOrderStatusEventSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PreOrderStatusEventInclude<ExtArgs> | null
    /**
     * Filter which PreOrderStatusEvent to delete.
     */
    where: PreOrderStatusEventWhereUniqueInput
  }

  /**
   * PreOrderStatusEvent deleteMany
   */
  export type PreOrderStatusEventDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which PreOrderStatusEvents to delete
     */
    where?: PreOrderStatusEventWhereInput
  }

  /**
   * PreOrderStatusEvent.actorAdminUser
   */
  export type PreOrderStatusEvent$actorAdminUserArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AdminUser
     */
    select?: AdminUserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AdminUserInclude<ExtArgs> | null
    where?: AdminUserWhereInput
  }

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


  /**
   * Model LedgerEntry
   */

  export type AggregateLedgerEntry = {
    _count: LedgerEntryCountAggregateOutputType | null
    _avg: LedgerEntryAvgAggregateOutputType | null
    _sum: LedgerEntrySumAggregateOutputType | null
    _min: LedgerEntryMinAggregateOutputType | null
    _max: LedgerEntryMaxAggregateOutputType | null
  }

  export type LedgerEntryAvgAggregateOutputType = {
    amount: Decimal | null
    karatPerMille: number | null
    pricePerGramRialAtEntry: Decimal | null
    originalValue: Decimal | null
    priceRial: Decimal | null
  }

  export type LedgerEntrySumAggregateOutputType = {
    amount: Decimal | null
    karatPerMille: number | null
    pricePerGramRialAtEntry: Decimal | null
    originalValue: Decimal | null
    priceRial: Decimal | null
  }

  export type LedgerEntryMinAggregateOutputType = {
    id: string | null
    customerId: string | null
    currency: $Enums.LedgerCurrency | null
    direction: $Enums.LedgerDirection | null
    sourceType: $Enums.LedgerSourceType | null
    amount: Decimal | null
    karatPerMille: number | null
    pricePerGramRialAtEntry: Decimal | null
    orderId: string | null
    confirmed: boolean | null
    confirmedAt: Date | null
    postedByAdminUserId: string | null
    labName: string | null
    hallmark: string | null
    accountName: string | null
    bankName: string | null
    transferTo: string | null
    originalValue: Decimal | null
    priceRial: Decimal | null
    receivedAt: Date | null
    note: string | null
    createdAt: Date | null
  }

  export type LedgerEntryMaxAggregateOutputType = {
    id: string | null
    customerId: string | null
    currency: $Enums.LedgerCurrency | null
    direction: $Enums.LedgerDirection | null
    sourceType: $Enums.LedgerSourceType | null
    amount: Decimal | null
    karatPerMille: number | null
    pricePerGramRialAtEntry: Decimal | null
    orderId: string | null
    confirmed: boolean | null
    confirmedAt: Date | null
    postedByAdminUserId: string | null
    labName: string | null
    hallmark: string | null
    accountName: string | null
    bankName: string | null
    transferTo: string | null
    originalValue: Decimal | null
    priceRial: Decimal | null
    receivedAt: Date | null
    note: string | null
    createdAt: Date | null
  }

  export type LedgerEntryCountAggregateOutputType = {
    id: number
    customerId: number
    currency: number
    direction: number
    sourceType: number
    amount: number
    karatPerMille: number
    pricePerGramRialAtEntry: number
    orderId: number
    confirmed: number
    confirmedAt: number
    postedByAdminUserId: number
    labName: number
    hallmark: number
    accountName: number
    bankName: number
    transferTo: number
    originalValue: number
    priceRial: number
    receivedAt: number
    note: number
    createdAt: number
    _all: number
  }


  export type LedgerEntryAvgAggregateInputType = {
    amount?: true
    karatPerMille?: true
    pricePerGramRialAtEntry?: true
    originalValue?: true
    priceRial?: true
  }

  export type LedgerEntrySumAggregateInputType = {
    amount?: true
    karatPerMille?: true
    pricePerGramRialAtEntry?: true
    originalValue?: true
    priceRial?: true
  }

  export type LedgerEntryMinAggregateInputType = {
    id?: true
    customerId?: true
    currency?: true
    direction?: true
    sourceType?: true
    amount?: true
    karatPerMille?: true
    pricePerGramRialAtEntry?: true
    orderId?: true
    confirmed?: true
    confirmedAt?: true
    postedByAdminUserId?: true
    labName?: true
    hallmark?: true
    accountName?: true
    bankName?: true
    transferTo?: true
    originalValue?: true
    priceRial?: true
    receivedAt?: true
    note?: true
    createdAt?: true
  }

  export type LedgerEntryMaxAggregateInputType = {
    id?: true
    customerId?: true
    currency?: true
    direction?: true
    sourceType?: true
    amount?: true
    karatPerMille?: true
    pricePerGramRialAtEntry?: true
    orderId?: true
    confirmed?: true
    confirmedAt?: true
    postedByAdminUserId?: true
    labName?: true
    hallmark?: true
    accountName?: true
    bankName?: true
    transferTo?: true
    originalValue?: true
    priceRial?: true
    receivedAt?: true
    note?: true
    createdAt?: true
  }

  export type LedgerEntryCountAggregateInputType = {
    id?: true
    customerId?: true
    currency?: true
    direction?: true
    sourceType?: true
    amount?: true
    karatPerMille?: true
    pricePerGramRialAtEntry?: true
    orderId?: true
    confirmed?: true
    confirmedAt?: true
    postedByAdminUserId?: true
    labName?: true
    hallmark?: true
    accountName?: true
    bankName?: true
    transferTo?: true
    originalValue?: true
    priceRial?: true
    receivedAt?: true
    note?: true
    createdAt?: true
    _all?: true
  }

  export type LedgerEntryAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which LedgerEntry to aggregate.
     */
    where?: LedgerEntryWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of LedgerEntries to fetch.
     */
    orderBy?: LedgerEntryOrderByWithRelationInput | LedgerEntryOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: LedgerEntryWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` LedgerEntries from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` LedgerEntries.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned LedgerEntries
    **/
    _count?: true | LedgerEntryCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: LedgerEntryAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: LedgerEntrySumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: LedgerEntryMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: LedgerEntryMaxAggregateInputType
  }

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




  export type LedgerEntryGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: LedgerEntryWhereInput
    orderBy?: LedgerEntryOrderByWithAggregationInput | LedgerEntryOrderByWithAggregationInput[]
    by: LedgerEntryScalarFieldEnum[] | LedgerEntryScalarFieldEnum
    having?: LedgerEntryScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: LedgerEntryCountAggregateInputType | true
    _avg?: LedgerEntryAvgAggregateInputType
    _sum?: LedgerEntrySumAggregateInputType
    _min?: LedgerEntryMinAggregateInputType
    _max?: LedgerEntryMaxAggregateInputType
  }

  export type LedgerEntryGroupByOutputType = {
    id: string
    customerId: string
    currency: $Enums.LedgerCurrency
    direction: $Enums.LedgerDirection
    sourceType: $Enums.LedgerSourceType
    amount: Decimal
    karatPerMille: number | null
    pricePerGramRialAtEntry: Decimal | null
    orderId: string | null
    confirmed: boolean
    confirmedAt: Date | null
    postedByAdminUserId: string | null
    labName: string | null
    hallmark: string | null
    accountName: string | null
    bankName: string | null
    transferTo: string | null
    originalValue: Decimal | null
    priceRial: Decimal | null
    receivedAt: Date | null
    note: string | null
    createdAt: Date
    _count: LedgerEntryCountAggregateOutputType | null
    _avg: LedgerEntryAvgAggregateOutputType | null
    _sum: LedgerEntrySumAggregateOutputType | null
    _min: LedgerEntryMinAggregateOutputType | null
    _max: LedgerEntryMaxAggregateOutputType | null
  }

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


  export type LedgerEntrySelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    customerId?: boolean
    currency?: boolean
    direction?: boolean
    sourceType?: boolean
    amount?: boolean
    karatPerMille?: boolean
    pricePerGramRialAtEntry?: boolean
    orderId?: boolean
    confirmed?: boolean
    confirmedAt?: boolean
    postedByAdminUserId?: boolean
    labName?: boolean
    hallmark?: boolean
    accountName?: boolean
    bankName?: boolean
    transferTo?: boolean
    originalValue?: boolean
    priceRial?: boolean
    receivedAt?: boolean
    note?: boolean
    createdAt?: boolean
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
    order?: boolean | LedgerEntry$orderArgs<ExtArgs>
    postedByAdminUser?: boolean | LedgerEntry$postedByAdminUserArgs<ExtArgs>
  }, ExtArgs["result"]["ledgerEntry"]>

  export type LedgerEntrySelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    customerId?: boolean
    currency?: boolean
    direction?: boolean
    sourceType?: boolean
    amount?: boolean
    karatPerMille?: boolean
    pricePerGramRialAtEntry?: boolean
    orderId?: boolean
    confirmed?: boolean
    confirmedAt?: boolean
    postedByAdminUserId?: boolean
    labName?: boolean
    hallmark?: boolean
    accountName?: boolean
    bankName?: boolean
    transferTo?: boolean
    originalValue?: boolean
    priceRial?: boolean
    receivedAt?: boolean
    note?: boolean
    createdAt?: boolean
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
    order?: boolean | LedgerEntry$orderArgs<ExtArgs>
    postedByAdminUser?: boolean | LedgerEntry$postedByAdminUserArgs<ExtArgs>
  }, ExtArgs["result"]["ledgerEntry"]>

  export type LedgerEntrySelectScalar = {
    id?: boolean
    customerId?: boolean
    currency?: boolean
    direction?: boolean
    sourceType?: boolean
    amount?: boolean
    karatPerMille?: boolean
    pricePerGramRialAtEntry?: boolean
    orderId?: boolean
    confirmed?: boolean
    confirmedAt?: boolean
    postedByAdminUserId?: boolean
    labName?: boolean
    hallmark?: boolean
    accountName?: boolean
    bankName?: boolean
    transferTo?: boolean
    originalValue?: boolean
    priceRial?: boolean
    receivedAt?: boolean
    note?: boolean
    createdAt?: boolean
  }

  export type LedgerEntryInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
    order?: boolean | LedgerEntry$orderArgs<ExtArgs>
    postedByAdminUser?: boolean | LedgerEntry$postedByAdminUserArgs<ExtArgs>
  }
  export type LedgerEntryIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
    order?: boolean | LedgerEntry$orderArgs<ExtArgs>
    postedByAdminUser?: boolean | LedgerEntry$postedByAdminUserArgs<ExtArgs>
  }

  export type $LedgerEntryPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "LedgerEntry"
    objects: {
      customer: Prisma.$CustomerPayload<ExtArgs>
      order: Prisma.$OrderPayload<ExtArgs> | null
      postedByAdminUser: Prisma.$AdminUserPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      customerId: string
      currency: $Enums.LedgerCurrency
      direction: $Enums.LedgerDirection
      sourceType: $Enums.LedgerSourceType
      /**
       * Always positive; direction determines the sign applied to the customer balance.
       */
      amount: Prisma.Decimal
      /**
       * Purity of the physical instrument, for REPAYMENT_MELTED_GOLD (e.g. 750, 916).
       */
      karatPerMille: number | null
      /**
       * Gold price/gram at conversion time, for REPAYMENT_CASH.
       */
      pricePerGramRialAtEntry: Prisma.Decimal | null
      orderId: string | null
      /**
       * Pending entries don't count toward the cached customer balance until confirmed.
       */
      confirmed: boolean
      confirmedAt: Date | null
      postedByAdminUserId: string | null
      /**
       * Instrument metadata from the legacy "cash" document form. Which fields are
       * filled depends on sourceType: a melted-gold receipt carries lab/hallmark and
       * the pre-normalization weight, a cheque carries the account and bank, and a
       * transfer carries its destination.
       * Legacy columns: lab, ang, account_name, bank_name, to, original_value, recive_date.
       */
      labName: string | null
      hallmark: string | null
      accountName: string | null
      bankName: string | null
      transferTo: string | null
      /**
       * Weight as handed over, BEFORE karat normalization (legacy original_value).
       */
      originalValue: Prisma.Decimal | null
      /**
       * Rial amount for cash/cheque documents (legacy price).
       */
      priceRial: Prisma.Decimal | null
      receivedAt: Date | null
      note: string | null
      createdAt: Date
    }, ExtArgs["result"]["ledgerEntry"]>
    composites: {}
  }

  type LedgerEntryGetPayload<S extends boolean | null | undefined | LedgerEntryDefaultArgs> = $Result.GetResult<Prisma.$LedgerEntryPayload, S>

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

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

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

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

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

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

    /**
     * Create a LedgerEntry.
     * @param {LedgerEntryCreateArgs} args - Arguments to create a LedgerEntry.
     * @example
     * // Create one LedgerEntry
     * const LedgerEntry = await prisma.ledgerEntry.create({
     *   data: {
     *     // ... data to create a LedgerEntry
     *   }
     * })
     * 
     */
    create<T extends LedgerEntryCreateArgs>(args: SelectSubset<T, LedgerEntryCreateArgs<ExtArgs>>): Prisma__LedgerEntryClient<$Result.GetResult<Prisma.$LedgerEntryPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a LedgerEntry.
     * @param {LedgerEntryDeleteArgs} args - Arguments to delete one LedgerEntry.
     * @example
     * // Delete one LedgerEntry
     * const LedgerEntry = await prisma.ledgerEntry.delete({
     *   where: {
     *     // ... filter to delete one LedgerEntry
     *   }
     * })
     * 
     */
    delete<T extends LedgerEntryDeleteArgs>(args: SelectSubset<T, LedgerEntryDeleteArgs<ExtArgs>>): Prisma__LedgerEntryClient<$Result.GetResult<Prisma.$LedgerEntryPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for LedgerEntry.
   * 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__LedgerEntryClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    customer<T extends CustomerDefaultArgs<ExtArgs> = {}>(args?: Subset<T, CustomerDefaultArgs<ExtArgs>>): Prisma__CustomerClient<$Result.GetResult<Prisma.$CustomerPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    order<T extends LedgerEntry$orderArgs<ExtArgs> = {}>(args?: Subset<T, LedgerEntry$orderArgs<ExtArgs>>): Prisma__OrderClient<$Result.GetResult<Prisma.$OrderPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    postedByAdminUser<T extends LedgerEntry$postedByAdminUserArgs<ExtArgs> = {}>(args?: Subset<T, LedgerEntry$postedByAdminUserArgs<ExtArgs>>): Prisma__AdminUserClient<$Result.GetResult<Prisma.$AdminUserPayload<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 LedgerEntry model
   */ 
  interface LedgerEntryFieldRefs {
    readonly id: FieldRef<"LedgerEntry", 'String'>
    readonly customerId: FieldRef<"LedgerEntry", 'String'>
    readonly currency: FieldRef<"LedgerEntry", 'LedgerCurrency'>
    readonly direction: FieldRef<"LedgerEntry", 'LedgerDirection'>
    readonly sourceType: FieldRef<"LedgerEntry", 'LedgerSourceType'>
    readonly amount: FieldRef<"LedgerEntry", 'Decimal'>
    readonly karatPerMille: FieldRef<"LedgerEntry", 'Int'>
    readonly pricePerGramRialAtEntry: FieldRef<"LedgerEntry", 'Decimal'>
    readonly orderId: FieldRef<"LedgerEntry", 'String'>
    readonly confirmed: FieldRef<"LedgerEntry", 'Boolean'>
    readonly confirmedAt: FieldRef<"LedgerEntry", 'DateTime'>
    readonly postedByAdminUserId: FieldRef<"LedgerEntry", 'String'>
    readonly labName: FieldRef<"LedgerEntry", 'String'>
    readonly hallmark: FieldRef<"LedgerEntry", 'String'>
    readonly accountName: FieldRef<"LedgerEntry", 'String'>
    readonly bankName: FieldRef<"LedgerEntry", 'String'>
    readonly transferTo: FieldRef<"LedgerEntry", 'String'>
    readonly originalValue: FieldRef<"LedgerEntry", 'Decimal'>
    readonly priceRial: FieldRef<"LedgerEntry", 'Decimal'>
    readonly receivedAt: FieldRef<"LedgerEntry", 'DateTime'>
    readonly note: FieldRef<"LedgerEntry", 'String'>
    readonly createdAt: FieldRef<"LedgerEntry", 'DateTime'>
  }
    

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

  /**
   * LedgerEntry findUniqueOrThrow
   */
  export type LedgerEntryFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LedgerEntry
     */
    select?: LedgerEntrySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LedgerEntryInclude<ExtArgs> | null
    /**
     * Filter, which LedgerEntry to fetch.
     */
    where: LedgerEntryWhereUniqueInput
  }

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

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

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

  /**
   * LedgerEntry create
   */
  export type LedgerEntryCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LedgerEntry
     */
    select?: LedgerEntrySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LedgerEntryInclude<ExtArgs> | null
    /**
     * The data needed to create a LedgerEntry.
     */
    data: XOR<LedgerEntryCreateInput, LedgerEntryUncheckedCreateInput>
  }

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

  /**
   * LedgerEntry createManyAndReturn
   */
  export type LedgerEntryCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LedgerEntry
     */
    select?: LedgerEntrySelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many LedgerEntries.
     */
    data: LedgerEntryCreateManyInput | LedgerEntryCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LedgerEntryIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * LedgerEntry update
   */
  export type LedgerEntryUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LedgerEntry
     */
    select?: LedgerEntrySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LedgerEntryInclude<ExtArgs> | null
    /**
     * The data needed to update a LedgerEntry.
     */
    data: XOR<LedgerEntryUpdateInput, LedgerEntryUncheckedUpdateInput>
    /**
     * Choose, which LedgerEntry to update.
     */
    where: LedgerEntryWhereUniqueInput
  }

  /**
   * LedgerEntry updateMany
   */
  export type LedgerEntryUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update LedgerEntries.
     */
    data: XOR<LedgerEntryUpdateManyMutationInput, LedgerEntryUncheckedUpdateManyInput>
    /**
     * Filter which LedgerEntries to update
     */
    where?: LedgerEntryWhereInput
  }

  /**
   * LedgerEntry upsert
   */
  export type LedgerEntryUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LedgerEntry
     */
    select?: LedgerEntrySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LedgerEntryInclude<ExtArgs> | null
    /**
     * The filter to search for the LedgerEntry to update in case it exists.
     */
    where: LedgerEntryWhereUniqueInput
    /**
     * In case the LedgerEntry found by the `where` argument doesn't exist, create a new LedgerEntry with this data.
     */
    create: XOR<LedgerEntryCreateInput, LedgerEntryUncheckedCreateInput>
    /**
     * In case the LedgerEntry was found with the provided `where` argument, update it with this data.
     */
    update: XOR<LedgerEntryUpdateInput, LedgerEntryUncheckedUpdateInput>
  }

  /**
   * LedgerEntry delete
   */
  export type LedgerEntryDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the LedgerEntry
     */
    select?: LedgerEntrySelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: LedgerEntryInclude<ExtArgs> | null
    /**
     * Filter which LedgerEntry to delete.
     */
    where: LedgerEntryWhereUniqueInput
  }

  /**
   * LedgerEntry deleteMany
   */
  export type LedgerEntryDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which LedgerEntries to delete
     */
    where?: LedgerEntryWhereInput
  }

  /**
   * LedgerEntry.order
   */
  export type LedgerEntry$orderArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Order
     */
    select?: OrderSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: OrderInclude<ExtArgs> | null
    where?: OrderWhereInput
  }

  /**
   * LedgerEntry.postedByAdminUser
   */
  export type LedgerEntry$postedByAdminUserArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AdminUser
     */
    select?: AdminUserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AdminUserInclude<ExtArgs> | null
    where?: AdminUserWhereInput
  }

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


  /**
   * Model GoldPriceQuote
   */

  export type AggregateGoldPriceQuote = {
    _count: GoldPriceQuoteCountAggregateOutputType | null
    _avg: GoldPriceQuoteAvgAggregateOutputType | null
    _sum: GoldPriceQuoteSumAggregateOutputType | null
    _min: GoldPriceQuoteMinAggregateOutputType | null
    _max: GoldPriceQuoteMaxAggregateOutputType | null
  }

  export type GoldPriceQuoteAvgAggregateOutputType = {
    karatPerMille: number | null
    pricePerGramRial: Decimal | null
  }

  export type GoldPriceQuoteSumAggregateOutputType = {
    karatPerMille: number | null
    pricePerGramRial: Decimal | null
  }

  export type GoldPriceQuoteMinAggregateOutputType = {
    id: string | null
    karatPerMille: number | null
    pricePerGramRial: Decimal | null
    source: string | null
    quotedAt: Date | null
  }

  export type GoldPriceQuoteMaxAggregateOutputType = {
    id: string | null
    karatPerMille: number | null
    pricePerGramRial: Decimal | null
    source: string | null
    quotedAt: Date | null
  }

  export type GoldPriceQuoteCountAggregateOutputType = {
    id: number
    karatPerMille: number
    pricePerGramRial: number
    source: number
    quotedAt: number
    _all: number
  }


  export type GoldPriceQuoteAvgAggregateInputType = {
    karatPerMille?: true
    pricePerGramRial?: true
  }

  export type GoldPriceQuoteSumAggregateInputType = {
    karatPerMille?: true
    pricePerGramRial?: true
  }

  export type GoldPriceQuoteMinAggregateInputType = {
    id?: true
    karatPerMille?: true
    pricePerGramRial?: true
    source?: true
    quotedAt?: true
  }

  export type GoldPriceQuoteMaxAggregateInputType = {
    id?: true
    karatPerMille?: true
    pricePerGramRial?: true
    source?: true
    quotedAt?: true
  }

  export type GoldPriceQuoteCountAggregateInputType = {
    id?: true
    karatPerMille?: true
    pricePerGramRial?: true
    source?: true
    quotedAt?: true
    _all?: true
  }

  export type GoldPriceQuoteAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which GoldPriceQuote to aggregate.
     */
    where?: GoldPriceQuoteWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of GoldPriceQuotes to fetch.
     */
    orderBy?: GoldPriceQuoteOrderByWithRelationInput | GoldPriceQuoteOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: GoldPriceQuoteWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` GoldPriceQuotes from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` GoldPriceQuotes.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned GoldPriceQuotes
    **/
    _count?: true | GoldPriceQuoteCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: GoldPriceQuoteAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: GoldPriceQuoteSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: GoldPriceQuoteMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: GoldPriceQuoteMaxAggregateInputType
  }

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




  export type GoldPriceQuoteGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: GoldPriceQuoteWhereInput
    orderBy?: GoldPriceQuoteOrderByWithAggregationInput | GoldPriceQuoteOrderByWithAggregationInput[]
    by: GoldPriceQuoteScalarFieldEnum[] | GoldPriceQuoteScalarFieldEnum
    having?: GoldPriceQuoteScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: GoldPriceQuoteCountAggregateInputType | true
    _avg?: GoldPriceQuoteAvgAggregateInputType
    _sum?: GoldPriceQuoteSumAggregateInputType
    _min?: GoldPriceQuoteMinAggregateInputType
    _max?: GoldPriceQuoteMaxAggregateInputType
  }

  export type GoldPriceQuoteGroupByOutputType = {
    id: string
    karatPerMille: number
    pricePerGramRial: Decimal
    source: string
    quotedAt: Date
    _count: GoldPriceQuoteCountAggregateOutputType | null
    _avg: GoldPriceQuoteAvgAggregateOutputType | null
    _sum: GoldPriceQuoteSumAggregateOutputType | null
    _min: GoldPriceQuoteMinAggregateOutputType | null
    _max: GoldPriceQuoteMaxAggregateOutputType | null
  }

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


  export type GoldPriceQuoteSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    karatPerMille?: boolean
    pricePerGramRial?: boolean
    source?: boolean
    quotedAt?: boolean
  }, ExtArgs["result"]["goldPriceQuote"]>

  export type GoldPriceQuoteSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    karatPerMille?: boolean
    pricePerGramRial?: boolean
    source?: boolean
    quotedAt?: boolean
  }, ExtArgs["result"]["goldPriceQuote"]>

  export type GoldPriceQuoteSelectScalar = {
    id?: boolean
    karatPerMille?: boolean
    pricePerGramRial?: boolean
    source?: boolean
    quotedAt?: boolean
  }


  export type $GoldPriceQuotePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "GoldPriceQuote"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      karatPerMille: number
      pricePerGramRial: Prisma.Decimal
      source: string
      quotedAt: Date
    }, ExtArgs["result"]["goldPriceQuote"]>
    composites: {}
  }

  type GoldPriceQuoteGetPayload<S extends boolean | null | undefined | GoldPriceQuoteDefaultArgs> = $Result.GetResult<Prisma.$GoldPriceQuotePayload, S>

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

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

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

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

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

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

    /**
     * Create a GoldPriceQuote.
     * @param {GoldPriceQuoteCreateArgs} args - Arguments to create a GoldPriceQuote.
     * @example
     * // Create one GoldPriceQuote
     * const GoldPriceQuote = await prisma.goldPriceQuote.create({
     *   data: {
     *     // ... data to create a GoldPriceQuote
     *   }
     * })
     * 
     */
    create<T extends GoldPriceQuoteCreateArgs>(args: SelectSubset<T, GoldPriceQuoteCreateArgs<ExtArgs>>): Prisma__GoldPriceQuoteClient<$Result.GetResult<Prisma.$GoldPriceQuotePayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a GoldPriceQuote.
     * @param {GoldPriceQuoteDeleteArgs} args - Arguments to delete one GoldPriceQuote.
     * @example
     * // Delete one GoldPriceQuote
     * const GoldPriceQuote = await prisma.goldPriceQuote.delete({
     *   where: {
     *     // ... filter to delete one GoldPriceQuote
     *   }
     * })
     * 
     */
    delete<T extends GoldPriceQuoteDeleteArgs>(args: SelectSubset<T, GoldPriceQuoteDeleteArgs<ExtArgs>>): Prisma__GoldPriceQuoteClient<$Result.GetResult<Prisma.$GoldPriceQuotePayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for GoldPriceQuote.
   * 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__GoldPriceQuoteClient<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 GoldPriceQuote model
   */ 
  interface GoldPriceQuoteFieldRefs {
    readonly id: FieldRef<"GoldPriceQuote", 'String'>
    readonly karatPerMille: FieldRef<"GoldPriceQuote", 'Int'>
    readonly pricePerGramRial: FieldRef<"GoldPriceQuote", 'Decimal'>
    readonly source: FieldRef<"GoldPriceQuote", 'String'>
    readonly quotedAt: FieldRef<"GoldPriceQuote", 'DateTime'>
  }
    

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

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

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

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

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

  /**
   * GoldPriceQuote create
   */
  export type GoldPriceQuoteCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GoldPriceQuote
     */
    select?: GoldPriceQuoteSelect<ExtArgs> | null
    /**
     * The data needed to create a GoldPriceQuote.
     */
    data: XOR<GoldPriceQuoteCreateInput, GoldPriceQuoteUncheckedCreateInput>
  }

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

  /**
   * GoldPriceQuote createManyAndReturn
   */
  export type GoldPriceQuoteCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GoldPriceQuote
     */
    select?: GoldPriceQuoteSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many GoldPriceQuotes.
     */
    data: GoldPriceQuoteCreateManyInput | GoldPriceQuoteCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * GoldPriceQuote update
   */
  export type GoldPriceQuoteUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GoldPriceQuote
     */
    select?: GoldPriceQuoteSelect<ExtArgs> | null
    /**
     * The data needed to update a GoldPriceQuote.
     */
    data: XOR<GoldPriceQuoteUpdateInput, GoldPriceQuoteUncheckedUpdateInput>
    /**
     * Choose, which GoldPriceQuote to update.
     */
    where: GoldPriceQuoteWhereUniqueInput
  }

  /**
   * GoldPriceQuote updateMany
   */
  export type GoldPriceQuoteUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update GoldPriceQuotes.
     */
    data: XOR<GoldPriceQuoteUpdateManyMutationInput, GoldPriceQuoteUncheckedUpdateManyInput>
    /**
     * Filter which GoldPriceQuotes to update
     */
    where?: GoldPriceQuoteWhereInput
  }

  /**
   * GoldPriceQuote upsert
   */
  export type GoldPriceQuoteUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the GoldPriceQuote
     */
    select?: GoldPriceQuoteSelect<ExtArgs> | null
    /**
     * The filter to search for the GoldPriceQuote to update in case it exists.
     */
    where: GoldPriceQuoteWhereUniqueInput
    /**
     * In case the GoldPriceQuote found by the `where` argument doesn't exist, create a new GoldPriceQuote with this data.
     */
    create: XOR<GoldPriceQuoteCreateInput, GoldPriceQuoteUncheckedCreateInput>
    /**
     * In case the GoldPriceQuote was found with the provided `where` argument, update it with this data.
     */
    update: XOR<GoldPriceQuoteUpdateInput, GoldPriceQuoteUncheckedUpdateInput>
  }

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

  /**
   * GoldPriceQuote deleteMany
   */
  export type GoldPriceQuoteDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which GoldPriceQuotes to delete
     */
    where?: GoldPriceQuoteWhereInput
  }

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


  /**
   * Model WalletBonus
   */

  export type AggregateWalletBonus = {
    _count: WalletBonusCountAggregateOutputType | null
    _avg: WalletBonusAvgAggregateOutputType | null
    _sum: WalletBonusSumAggregateOutputType | null
    _min: WalletBonusMinAggregateOutputType | null
    _max: WalletBonusMaxAggregateOutputType | null
  }

  export type WalletBonusAvgAggregateOutputType = {
    goldGrams: Decimal | null
  }

  export type WalletBonusSumAggregateOutputType = {
    goldGrams: Decimal | null
  }

  export type WalletBonusMinAggregateOutputType = {
    id: string | null
    customerId: string | null
    orderId: string | null
    goldGrams: Decimal | null
    grantedAt: Date | null
    expiresAt: Date | null
    consumedAt: Date | null
    isActive: boolean | null
  }

  export type WalletBonusMaxAggregateOutputType = {
    id: string | null
    customerId: string | null
    orderId: string | null
    goldGrams: Decimal | null
    grantedAt: Date | null
    expiresAt: Date | null
    consumedAt: Date | null
    isActive: boolean | null
  }

  export type WalletBonusCountAggregateOutputType = {
    id: number
    customerId: number
    orderId: number
    goldGrams: number
    grantedAt: number
    expiresAt: number
    consumedAt: number
    isActive: number
    _all: number
  }


  export type WalletBonusAvgAggregateInputType = {
    goldGrams?: true
  }

  export type WalletBonusSumAggregateInputType = {
    goldGrams?: true
  }

  export type WalletBonusMinAggregateInputType = {
    id?: true
    customerId?: true
    orderId?: true
    goldGrams?: true
    grantedAt?: true
    expiresAt?: true
    consumedAt?: true
    isActive?: true
  }

  export type WalletBonusMaxAggregateInputType = {
    id?: true
    customerId?: true
    orderId?: true
    goldGrams?: true
    grantedAt?: true
    expiresAt?: true
    consumedAt?: true
    isActive?: true
  }

  export type WalletBonusCountAggregateInputType = {
    id?: true
    customerId?: true
    orderId?: true
    goldGrams?: true
    grantedAt?: true
    expiresAt?: true
    consumedAt?: true
    isActive?: true
    _all?: true
  }

  export type WalletBonusAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which WalletBonus to aggregate.
     */
    where?: WalletBonusWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of WalletBonuses to fetch.
     */
    orderBy?: WalletBonusOrderByWithRelationInput | WalletBonusOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: WalletBonusWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` WalletBonuses from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` WalletBonuses.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned WalletBonuses
    **/
    _count?: true | WalletBonusCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: WalletBonusAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: WalletBonusSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: WalletBonusMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: WalletBonusMaxAggregateInputType
  }

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




  export type WalletBonusGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: WalletBonusWhereInput
    orderBy?: WalletBonusOrderByWithAggregationInput | WalletBonusOrderByWithAggregationInput[]
    by: WalletBonusScalarFieldEnum[] | WalletBonusScalarFieldEnum
    having?: WalletBonusScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: WalletBonusCountAggregateInputType | true
    _avg?: WalletBonusAvgAggregateInputType
    _sum?: WalletBonusSumAggregateInputType
    _min?: WalletBonusMinAggregateInputType
    _max?: WalletBonusMaxAggregateInputType
  }

  export type WalletBonusGroupByOutputType = {
    id: string
    customerId: string
    orderId: string | null
    goldGrams: Decimal
    grantedAt: Date
    expiresAt: Date
    consumedAt: Date | null
    isActive: boolean
    _count: WalletBonusCountAggregateOutputType | null
    _avg: WalletBonusAvgAggregateOutputType | null
    _sum: WalletBonusSumAggregateOutputType | null
    _min: WalletBonusMinAggregateOutputType | null
    _max: WalletBonusMaxAggregateOutputType | null
  }

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


  export type WalletBonusSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    customerId?: boolean
    orderId?: boolean
    goldGrams?: boolean
    grantedAt?: boolean
    expiresAt?: boolean
    consumedAt?: boolean
    isActive?: boolean
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["walletBonus"]>

  export type WalletBonusSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    customerId?: boolean
    orderId?: boolean
    goldGrams?: boolean
    grantedAt?: boolean
    expiresAt?: boolean
    consumedAt?: boolean
    isActive?: boolean
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["walletBonus"]>

  export type WalletBonusSelectScalar = {
    id?: boolean
    customerId?: boolean
    orderId?: boolean
    goldGrams?: boolean
    grantedAt?: boolean
    expiresAt?: boolean
    consumedAt?: boolean
    isActive?: boolean
  }

  export type WalletBonusInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
  }
  export type WalletBonusIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
  }

  export type $WalletBonusPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "WalletBonus"
    objects: {
      customer: Prisma.$CustomerPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      customerId: string
      orderId: string | null
      goldGrams: Prisma.Decimal
      grantedAt: Date
      expiresAt: Date
      consumedAt: Date | null
      isActive: boolean
    }, ExtArgs["result"]["walletBonus"]>
    composites: {}
  }

  type WalletBonusGetPayload<S extends boolean | null | undefined | WalletBonusDefaultArgs> = $Result.GetResult<Prisma.$WalletBonusPayload, S>

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

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

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

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

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

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

    /**
     * Create a WalletBonus.
     * @param {WalletBonusCreateArgs} args - Arguments to create a WalletBonus.
     * @example
     * // Create one WalletBonus
     * const WalletBonus = await prisma.walletBonus.create({
     *   data: {
     *     // ... data to create a WalletBonus
     *   }
     * })
     * 
     */
    create<T extends WalletBonusCreateArgs>(args: SelectSubset<T, WalletBonusCreateArgs<ExtArgs>>): Prisma__WalletBonusClient<$Result.GetResult<Prisma.$WalletBonusPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a WalletBonus.
     * @param {WalletBonusDeleteArgs} args - Arguments to delete one WalletBonus.
     * @example
     * // Delete one WalletBonus
     * const WalletBonus = await prisma.walletBonus.delete({
     *   where: {
     *     // ... filter to delete one WalletBonus
     *   }
     * })
     * 
     */
    delete<T extends WalletBonusDeleteArgs>(args: SelectSubset<T, WalletBonusDeleteArgs<ExtArgs>>): Prisma__WalletBonusClient<$Result.GetResult<Prisma.$WalletBonusPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for WalletBonus.
   * 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__WalletBonusClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    customer<T extends CustomerDefaultArgs<ExtArgs> = {}>(args?: Subset<T, CustomerDefaultArgs<ExtArgs>>): Prisma__CustomerClient<$Result.GetResult<Prisma.$CustomerPayload<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 WalletBonus model
   */ 
  interface WalletBonusFieldRefs {
    readonly id: FieldRef<"WalletBonus", 'String'>
    readonly customerId: FieldRef<"WalletBonus", 'String'>
    readonly orderId: FieldRef<"WalletBonus", 'String'>
    readonly goldGrams: FieldRef<"WalletBonus", 'Decimal'>
    readonly grantedAt: FieldRef<"WalletBonus", 'DateTime'>
    readonly expiresAt: FieldRef<"WalletBonus", 'DateTime'>
    readonly consumedAt: FieldRef<"WalletBonus", 'DateTime'>
    readonly isActive: FieldRef<"WalletBonus", 'Boolean'>
  }
    

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

  /**
   * WalletBonus findUniqueOrThrow
   */
  export type WalletBonusFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WalletBonus
     */
    select?: WalletBonusSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WalletBonusInclude<ExtArgs> | null
    /**
     * Filter, which WalletBonus to fetch.
     */
    where: WalletBonusWhereUniqueInput
  }

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

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

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

  /**
   * WalletBonus create
   */
  export type WalletBonusCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WalletBonus
     */
    select?: WalletBonusSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WalletBonusInclude<ExtArgs> | null
    /**
     * The data needed to create a WalletBonus.
     */
    data: XOR<WalletBonusCreateInput, WalletBonusUncheckedCreateInput>
  }

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

  /**
   * WalletBonus createManyAndReturn
   */
  export type WalletBonusCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WalletBonus
     */
    select?: WalletBonusSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many WalletBonuses.
     */
    data: WalletBonusCreateManyInput | WalletBonusCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WalletBonusIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * WalletBonus update
   */
  export type WalletBonusUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WalletBonus
     */
    select?: WalletBonusSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WalletBonusInclude<ExtArgs> | null
    /**
     * The data needed to update a WalletBonus.
     */
    data: XOR<WalletBonusUpdateInput, WalletBonusUncheckedUpdateInput>
    /**
     * Choose, which WalletBonus to update.
     */
    where: WalletBonusWhereUniqueInput
  }

  /**
   * WalletBonus updateMany
   */
  export type WalletBonusUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update WalletBonuses.
     */
    data: XOR<WalletBonusUpdateManyMutationInput, WalletBonusUncheckedUpdateManyInput>
    /**
     * Filter which WalletBonuses to update
     */
    where?: WalletBonusWhereInput
  }

  /**
   * WalletBonus upsert
   */
  export type WalletBonusUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WalletBonus
     */
    select?: WalletBonusSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WalletBonusInclude<ExtArgs> | null
    /**
     * The filter to search for the WalletBonus to update in case it exists.
     */
    where: WalletBonusWhereUniqueInput
    /**
     * In case the WalletBonus found by the `where` argument doesn't exist, create a new WalletBonus with this data.
     */
    create: XOR<WalletBonusCreateInput, WalletBonusUncheckedCreateInput>
    /**
     * In case the WalletBonus was found with the provided `where` argument, update it with this data.
     */
    update: XOR<WalletBonusUpdateInput, WalletBonusUncheckedUpdateInput>
  }

  /**
   * WalletBonus delete
   */
  export type WalletBonusDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the WalletBonus
     */
    select?: WalletBonusSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: WalletBonusInclude<ExtArgs> | null
    /**
     * Filter which WalletBonus to delete.
     */
    where: WalletBonusWhereUniqueInput
  }

  /**
   * WalletBonus deleteMany
   */
  export type WalletBonusDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which WalletBonuses to delete
     */
    where?: WalletBonusWhereInput
  }

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


  /**
   * Model UserType
   */

  export type AggregateUserType = {
    _count: UserTypeCountAggregateOutputType | null
    _avg: UserTypeAvgAggregateOutputType | null
    _sum: UserTypeSumAggregateOutputType | null
    _min: UserTypeMinAggregateOutputType | null
    _max: UserTypeMaxAggregateOutputType | null
  }

  export type UserTypeAvgAggregateOutputType = {
    id: number | null
  }

  export type UserTypeSumAggregateOutputType = {
    id: number | null
  }

  export type UserTypeMinAggregateOutputType = {
    id: number | null
    title: string | null
    isActive: boolean | null
    createdAt: Date | null
  }

  export type UserTypeMaxAggregateOutputType = {
    id: number | null
    title: string | null
    isActive: boolean | null
    createdAt: Date | null
  }

  export type UserTypeCountAggregateOutputType = {
    id: number
    title: number
    isActive: number
    createdAt: number
    _all: number
  }


  export type UserTypeAvgAggregateInputType = {
    id?: true
  }

  export type UserTypeSumAggregateInputType = {
    id?: true
  }

  export type UserTypeMinAggregateInputType = {
    id?: true
    title?: true
    isActive?: true
    createdAt?: true
  }

  export type UserTypeMaxAggregateInputType = {
    id?: true
    title?: true
    isActive?: true
    createdAt?: true
  }

  export type UserTypeCountAggregateInputType = {
    id?: true
    title?: true
    isActive?: true
    createdAt?: true
    _all?: true
  }

  export type UserTypeAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which UserType to aggregate.
     */
    where?: UserTypeWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of UserTypes to fetch.
     */
    orderBy?: UserTypeOrderByWithRelationInput | UserTypeOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: UserTypeWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` UserTypes from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` UserTypes.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned UserTypes
    **/
    _count?: true | UserTypeCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: UserTypeAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: UserTypeSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: UserTypeMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: UserTypeMaxAggregateInputType
  }

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




  export type UserTypeGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: UserTypeWhereInput
    orderBy?: UserTypeOrderByWithAggregationInput | UserTypeOrderByWithAggregationInput[]
    by: UserTypeScalarFieldEnum[] | UserTypeScalarFieldEnum
    having?: UserTypeScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: UserTypeCountAggregateInputType | true
    _avg?: UserTypeAvgAggregateInputType
    _sum?: UserTypeSumAggregateInputType
    _min?: UserTypeMinAggregateInputType
    _max?: UserTypeMaxAggregateInputType
  }

  export type UserTypeGroupByOutputType = {
    id: number
    title: string
    isActive: boolean
    createdAt: Date
    _count: UserTypeCountAggregateOutputType | null
    _avg: UserTypeAvgAggregateOutputType | null
    _sum: UserTypeSumAggregateOutputType | null
    _min: UserTypeMinAggregateOutputType | null
    _max: UserTypeMaxAggregateOutputType | null
  }

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


  export type UserTypeSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    isActive?: boolean
    createdAt?: boolean
    permissions?: boolean | UserType$permissionsArgs<ExtArgs>
    adminUsers?: boolean | UserType$adminUsersArgs<ExtArgs>
    _count?: boolean | UserTypeCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["userType"]>

  export type UserTypeSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    isActive?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["userType"]>

  export type UserTypeSelectScalar = {
    id?: boolean
    title?: boolean
    isActive?: boolean
    createdAt?: boolean
  }

  export type UserTypeInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    permissions?: boolean | UserType$permissionsArgs<ExtArgs>
    adminUsers?: boolean | UserType$adminUsersArgs<ExtArgs>
    _count?: boolean | UserTypeCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type UserTypeIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {}

  export type $UserTypePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "UserType"
    objects: {
      permissions: Prisma.$PermissionPayload<ExtArgs>[]
      adminUsers: Prisma.$AdminUserPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      /**
       * Legacy `permission.ut` / `users.ut` — an integer, kept as the PK so seeded
       * rows keep their legacy identity rather than getting new cuids.
       */
      id: number
      title: string
      isActive: boolean
      createdAt: Date
    }, ExtArgs["result"]["userType"]>
    composites: {}
  }

  type UserTypeGetPayload<S extends boolean | null | undefined | UserTypeDefaultArgs> = $Result.GetResult<Prisma.$UserTypePayload, S>

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

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

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

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

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

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

    /**
     * Create a UserType.
     * @param {UserTypeCreateArgs} args - Arguments to create a UserType.
     * @example
     * // Create one UserType
     * const UserType = await prisma.userType.create({
     *   data: {
     *     // ... data to create a UserType
     *   }
     * })
     * 
     */
    create<T extends UserTypeCreateArgs>(args: SelectSubset<T, UserTypeCreateArgs<ExtArgs>>): Prisma__UserTypeClient<$Result.GetResult<Prisma.$UserTypePayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a UserType.
     * @param {UserTypeDeleteArgs} args - Arguments to delete one UserType.
     * @example
     * // Delete one UserType
     * const UserType = await prisma.userType.delete({
     *   where: {
     *     // ... filter to delete one UserType
     *   }
     * })
     * 
     */
    delete<T extends UserTypeDeleteArgs>(args: SelectSubset<T, UserTypeDeleteArgs<ExtArgs>>): Prisma__UserTypeClient<$Result.GetResult<Prisma.$UserTypePayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for UserType.
   * 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__UserTypeClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    permissions<T extends UserType$permissionsArgs<ExtArgs> = {}>(args?: Subset<T, UserType$permissionsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$PermissionPayload<ExtArgs>, T, "findMany"> | Null>
    adminUsers<T extends UserType$adminUsersArgs<ExtArgs> = {}>(args?: Subset<T, UserType$adminUsersArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AdminUserPayload<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 UserType model
   */ 
  interface UserTypeFieldRefs {
    readonly id: FieldRef<"UserType", 'Int'>
    readonly title: FieldRef<"UserType", 'String'>
    readonly isActive: FieldRef<"UserType", 'Boolean'>
    readonly createdAt: FieldRef<"UserType", 'DateTime'>
  }
    

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

  /**
   * UserType findUniqueOrThrow
   */
  export type UserTypeFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserType
     */
    select?: UserTypeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserTypeInclude<ExtArgs> | null
    /**
     * Filter, which UserType to fetch.
     */
    where: UserTypeWhereUniqueInput
  }

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

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

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

  /**
   * UserType create
   */
  export type UserTypeCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserType
     */
    select?: UserTypeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserTypeInclude<ExtArgs> | null
    /**
     * The data needed to create a UserType.
     */
    data: XOR<UserTypeCreateInput, UserTypeUncheckedCreateInput>
  }

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

  /**
   * UserType createManyAndReturn
   */
  export type UserTypeCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserType
     */
    select?: UserTypeSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many UserTypes.
     */
    data: UserTypeCreateManyInput | UserTypeCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * UserType update
   */
  export type UserTypeUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserType
     */
    select?: UserTypeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserTypeInclude<ExtArgs> | null
    /**
     * The data needed to update a UserType.
     */
    data: XOR<UserTypeUpdateInput, UserTypeUncheckedUpdateInput>
    /**
     * Choose, which UserType to update.
     */
    where: UserTypeWhereUniqueInput
  }

  /**
   * UserType updateMany
   */
  export type UserTypeUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update UserTypes.
     */
    data: XOR<UserTypeUpdateManyMutationInput, UserTypeUncheckedUpdateManyInput>
    /**
     * Filter which UserTypes to update
     */
    where?: UserTypeWhereInput
  }

  /**
   * UserType upsert
   */
  export type UserTypeUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserType
     */
    select?: UserTypeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserTypeInclude<ExtArgs> | null
    /**
     * The filter to search for the UserType to update in case it exists.
     */
    where: UserTypeWhereUniqueInput
    /**
     * In case the UserType found by the `where` argument doesn't exist, create a new UserType with this data.
     */
    create: XOR<UserTypeCreateInput, UserTypeUncheckedCreateInput>
    /**
     * In case the UserType was found with the provided `where` argument, update it with this data.
     */
    update: XOR<UserTypeUpdateInput, UserTypeUncheckedUpdateInput>
  }

  /**
   * UserType delete
   */
  export type UserTypeDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UserType
     */
    select?: UserTypeSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UserTypeInclude<ExtArgs> | null
    /**
     * Filter which UserType to delete.
     */
    where: UserTypeWhereUniqueInput
  }

  /**
   * UserType deleteMany
   */
  export type UserTypeDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which UserTypes to delete
     */
    where?: UserTypeWhereInput
  }

  /**
   * UserType.permissions
   */
  export type UserType$permissionsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Permission
     */
    select?: PermissionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PermissionInclude<ExtArgs> | null
    where?: PermissionWhereInput
    orderBy?: PermissionOrderByWithRelationInput | PermissionOrderByWithRelationInput[]
    cursor?: PermissionWhereUniqueInput
    take?: number
    skip?: number
    distinct?: PermissionScalarFieldEnum | PermissionScalarFieldEnum[]
  }

  /**
   * UserType.adminUsers
   */
  export type UserType$adminUsersArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AdminUser
     */
    select?: AdminUserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AdminUserInclude<ExtArgs> | null
    where?: AdminUserWhereInput
    orderBy?: AdminUserOrderByWithRelationInput | AdminUserOrderByWithRelationInput[]
    cursor?: AdminUserWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AdminUserScalarFieldEnum | AdminUserScalarFieldEnum[]
  }

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


  /**
   * Model Permission
   */

  export type AggregatePermission = {
    _count: PermissionCountAggregateOutputType | null
    _avg: PermissionAvgAggregateOutputType | null
    _sum: PermissionSumAggregateOutputType | null
    _min: PermissionMinAggregateOutputType | null
    _max: PermissionMaxAggregateOutputType | null
  }

  export type PermissionAvgAggregateOutputType = {
    userTypeId: number | null
  }

  export type PermissionSumAggregateOutputType = {
    userTypeId: number | null
  }

  export type PermissionMinAggregateOutputType = {
    rid: string | null
    userTypeId: number | null
  }

  export type PermissionMaxAggregateOutputType = {
    rid: string | null
    userTypeId: number | null
  }

  export type PermissionCountAggregateOutputType = {
    rid: number
    userTypeId: number
    _all: number
  }


  export type PermissionAvgAggregateInputType = {
    userTypeId?: true
  }

  export type PermissionSumAggregateInputType = {
    userTypeId?: true
  }

  export type PermissionMinAggregateInputType = {
    rid?: true
    userTypeId?: true
  }

  export type PermissionMaxAggregateInputType = {
    rid?: true
    userTypeId?: true
  }

  export type PermissionCountAggregateInputType = {
    rid?: true
    userTypeId?: true
    _all?: true
  }

  export type PermissionAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Permission to aggregate.
     */
    where?: PermissionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Permissions to fetch.
     */
    orderBy?: PermissionOrderByWithRelationInput | PermissionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: PermissionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Permissions from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Permissions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Permissions
    **/
    _count?: true | PermissionCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: PermissionAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: PermissionSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: PermissionMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: PermissionMaxAggregateInputType
  }

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




  export type PermissionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PermissionWhereInput
    orderBy?: PermissionOrderByWithAggregationInput | PermissionOrderByWithAggregationInput[]
    by: PermissionScalarFieldEnum[] | PermissionScalarFieldEnum
    having?: PermissionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: PermissionCountAggregateInputType | true
    _avg?: PermissionAvgAggregateInputType
    _sum?: PermissionSumAggregateInputType
    _min?: PermissionMinAggregateInputType
    _max?: PermissionMaxAggregateInputType
  }

  export type PermissionGroupByOutputType = {
    rid: string
    userTypeId: number
    _count: PermissionCountAggregateOutputType | null
    _avg: PermissionAvgAggregateOutputType | null
    _sum: PermissionSumAggregateOutputType | null
    _min: PermissionMinAggregateOutputType | null
    _max: PermissionMaxAggregateOutputType | null
  }

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


  export type PermissionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    rid?: boolean
    userTypeId?: boolean
    userType?: boolean | UserTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["permission"]>

  export type PermissionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    rid?: boolean
    userTypeId?: boolean
    userType?: boolean | UserTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["permission"]>

  export type PermissionSelectScalar = {
    rid?: boolean
    userTypeId?: boolean
  }

  export type PermissionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    userType?: boolean | UserTypeDefaultArgs<ExtArgs>
  }
  export type PermissionIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    userType?: boolean | UserTypeDefaultArgs<ExtArgs>
  }

  export type $PermissionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Permission"
    objects: {
      userType: Prisma.$UserTypePayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      /**
       * Dotted permission id, e.g. "order.list", "persons.list.client.omde".
       */
      rid: string
      userTypeId: number
    }, ExtArgs["result"]["permission"]>
    composites: {}
  }

  type PermissionGetPayload<S extends boolean | null | undefined | PermissionDefaultArgs> = $Result.GetResult<Prisma.$PermissionPayload, S>

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

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

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

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

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

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

    /**
     * Create a Permission.
     * @param {PermissionCreateArgs} args - Arguments to create a Permission.
     * @example
     * // Create one Permission
     * const Permission = await prisma.permission.create({
     *   data: {
     *     // ... data to create a Permission
     *   }
     * })
     * 
     */
    create<T extends PermissionCreateArgs>(args: SelectSubset<T, PermissionCreateArgs<ExtArgs>>): Prisma__PermissionClient<$Result.GetResult<Prisma.$PermissionPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Permission.
     * @param {PermissionDeleteArgs} args - Arguments to delete one Permission.
     * @example
     * // Delete one Permission
     * const Permission = await prisma.permission.delete({
     *   where: {
     *     // ... filter to delete one Permission
     *   }
     * })
     * 
     */
    delete<T extends PermissionDeleteArgs>(args: SelectSubset<T, PermissionDeleteArgs<ExtArgs>>): Prisma__PermissionClient<$Result.GetResult<Prisma.$PermissionPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Permission.
   * 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__PermissionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    userType<T extends UserTypeDefaultArgs<ExtArgs> = {}>(args?: Subset<T, UserTypeDefaultArgs<ExtArgs>>): Prisma__UserTypeClient<$Result.GetResult<Prisma.$UserTypePayload<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 Permission model
   */ 
  interface PermissionFieldRefs {
    readonly rid: FieldRef<"Permission", 'String'>
    readonly userTypeId: FieldRef<"Permission", 'Int'>
  }
    

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

  /**
   * Permission findUniqueOrThrow
   */
  export type PermissionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Permission
     */
    select?: PermissionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PermissionInclude<ExtArgs> | null
    /**
     * Filter, which Permission to fetch.
     */
    where: PermissionWhereUniqueInput
  }

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

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

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

  /**
   * Permission create
   */
  export type PermissionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Permission
     */
    select?: PermissionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PermissionInclude<ExtArgs> | null
    /**
     * The data needed to create a Permission.
     */
    data: XOR<PermissionCreateInput, PermissionUncheckedCreateInput>
  }

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

  /**
   * Permission createManyAndReturn
   */
  export type PermissionCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Permission
     */
    select?: PermissionSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Permissions.
     */
    data: PermissionCreateManyInput | PermissionCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PermissionIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Permission update
   */
  export type PermissionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Permission
     */
    select?: PermissionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PermissionInclude<ExtArgs> | null
    /**
     * The data needed to update a Permission.
     */
    data: XOR<PermissionUpdateInput, PermissionUncheckedUpdateInput>
    /**
     * Choose, which Permission to update.
     */
    where: PermissionWhereUniqueInput
  }

  /**
   * Permission updateMany
   */
  export type PermissionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Permissions.
     */
    data: XOR<PermissionUpdateManyMutationInput, PermissionUncheckedUpdateManyInput>
    /**
     * Filter which Permissions to update
     */
    where?: PermissionWhereInput
  }

  /**
   * Permission upsert
   */
  export type PermissionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Permission
     */
    select?: PermissionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PermissionInclude<ExtArgs> | null
    /**
     * The filter to search for the Permission to update in case it exists.
     */
    where: PermissionWhereUniqueInput
    /**
     * In case the Permission found by the `where` argument doesn't exist, create a new Permission with this data.
     */
    create: XOR<PermissionCreateInput, PermissionUncheckedCreateInput>
    /**
     * In case the Permission was found with the provided `where` argument, update it with this data.
     */
    update: XOR<PermissionUpdateInput, PermissionUncheckedUpdateInput>
  }

  /**
   * Permission delete
   */
  export type PermissionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Permission
     */
    select?: PermissionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PermissionInclude<ExtArgs> | null
    /**
     * Filter which Permission to delete.
     */
    where: PermissionWhereUniqueInput
  }

  /**
   * Permission deleteMany
   */
  export type PermissionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Permissions to delete
     */
    where?: PermissionWhereInput
  }

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


  /**
   * Model Comment
   */

  export type AggregateComment = {
    _count: CommentCountAggregateOutputType | null
    _min: CommentMinAggregateOutputType | null
    _max: CommentMaxAggregateOutputType | null
  }

  export type CommentMinAggregateOutputType = {
    id: string | null
    productId: string | null
    customerId: string | null
    body: string | null
    status: $Enums.CommentStatus | null
    replyToId: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type CommentMaxAggregateOutputType = {
    id: string | null
    productId: string | null
    customerId: string | null
    body: string | null
    status: $Enums.CommentStatus | null
    replyToId: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type CommentCountAggregateOutputType = {
    id: number
    productId: number
    customerId: number
    body: number
    status: number
    replyToId: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type CommentMinAggregateInputType = {
    id?: true
    productId?: true
    customerId?: true
    body?: true
    status?: true
    replyToId?: true
    createdAt?: true
    updatedAt?: true
  }

  export type CommentMaxAggregateInputType = {
    id?: true
    productId?: true
    customerId?: true
    body?: true
    status?: true
    replyToId?: true
    createdAt?: true
    updatedAt?: true
  }

  export type CommentCountAggregateInputType = {
    id?: true
    productId?: true
    customerId?: true
    body?: true
    status?: true
    replyToId?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

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

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




  export type CommentGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CommentWhereInput
    orderBy?: CommentOrderByWithAggregationInput | CommentOrderByWithAggregationInput[]
    by: CommentScalarFieldEnum[] | CommentScalarFieldEnum
    having?: CommentScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CommentCountAggregateInputType | true
    _min?: CommentMinAggregateInputType
    _max?: CommentMaxAggregateInputType
  }

  export type CommentGroupByOutputType = {
    id: string
    productId: string
    customerId: string
    body: string
    status: $Enums.CommentStatus
    replyToId: string | null
    createdAt: Date
    updatedAt: Date
    _count: CommentCountAggregateOutputType | null
    _min: CommentMinAggregateOutputType | null
    _max: CommentMaxAggregateOutputType | null
  }

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


  export type CommentSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    productId?: boolean
    customerId?: boolean
    body?: boolean
    status?: boolean
    replyToId?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    product?: boolean | ProductDefaultArgs<ExtArgs>
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
    replyTo?: boolean | Comment$replyToArgs<ExtArgs>
    replies?: boolean | Comment$repliesArgs<ExtArgs>
    _count?: boolean | CommentCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["comment"]>

  export type CommentSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    productId?: boolean
    customerId?: boolean
    body?: boolean
    status?: boolean
    replyToId?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    product?: boolean | ProductDefaultArgs<ExtArgs>
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
    replyTo?: boolean | Comment$replyToArgs<ExtArgs>
  }, ExtArgs["result"]["comment"]>

  export type CommentSelectScalar = {
    id?: boolean
    productId?: boolean
    customerId?: boolean
    body?: boolean
    status?: boolean
    replyToId?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type CommentInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    product?: boolean | ProductDefaultArgs<ExtArgs>
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
    replyTo?: boolean | Comment$replyToArgs<ExtArgs>
    replies?: boolean | Comment$repliesArgs<ExtArgs>
    _count?: boolean | CommentCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type CommentIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    product?: boolean | ProductDefaultArgs<ExtArgs>
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
    replyTo?: boolean | Comment$replyToArgs<ExtArgs>
  }

  export type $CommentPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Comment"
    objects: {
      product: Prisma.$ProductPayload<ExtArgs>
      customer: Prisma.$CustomerPayload<ExtArgs>
      replyTo: Prisma.$CommentPayload<ExtArgs> | null
      replies: Prisma.$CommentPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      productId: string
      customerId: string
      body: string
      status: $Enums.CommentStatus
      /**
       * Legacy `reply_to`: a staff reply threads under the comment it answers.
       */
      replyToId: string | null
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["comment"]>
    composites: {}
  }

  type CommentGetPayload<S extends boolean | null | undefined | CommentDefaultArgs> = $Result.GetResult<Prisma.$CommentPayload, S>

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

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

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

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

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

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

    /**
     * Create a Comment.
     * @param {CommentCreateArgs} args - Arguments to create a Comment.
     * @example
     * // Create one Comment
     * const Comment = await prisma.comment.create({
     *   data: {
     *     // ... data to create a Comment
     *   }
     * })
     * 
     */
    create<T extends CommentCreateArgs>(args: SelectSubset<T, CommentCreateArgs<ExtArgs>>): Prisma__CommentClient<$Result.GetResult<Prisma.$CommentPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Comment.
     * @param {CommentDeleteArgs} args - Arguments to delete one Comment.
     * @example
     * // Delete one Comment
     * const Comment = await prisma.comment.delete({
     *   where: {
     *     // ... filter to delete one Comment
     *   }
     * })
     * 
     */
    delete<T extends CommentDeleteArgs>(args: SelectSubset<T, CommentDeleteArgs<ExtArgs>>): Prisma__CommentClient<$Result.GetResult<Prisma.$CommentPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Comment.
   * 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__CommentClient<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>
    customer<T extends CustomerDefaultArgs<ExtArgs> = {}>(args?: Subset<T, CustomerDefaultArgs<ExtArgs>>): Prisma__CustomerClient<$Result.GetResult<Prisma.$CustomerPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    replyTo<T extends Comment$replyToArgs<ExtArgs> = {}>(args?: Subset<T, Comment$replyToArgs<ExtArgs>>): Prisma__CommentClient<$Result.GetResult<Prisma.$CommentPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    replies<T extends Comment$repliesArgs<ExtArgs> = {}>(args?: Subset<T, Comment$repliesArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CommentPayload<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 Comment model
   */ 
  interface CommentFieldRefs {
    readonly id: FieldRef<"Comment", 'String'>
    readonly productId: FieldRef<"Comment", 'String'>
    readonly customerId: FieldRef<"Comment", 'String'>
    readonly body: FieldRef<"Comment", 'String'>
    readonly status: FieldRef<"Comment", 'CommentStatus'>
    readonly replyToId: FieldRef<"Comment", 'String'>
    readonly createdAt: FieldRef<"Comment", 'DateTime'>
    readonly updatedAt: FieldRef<"Comment", 'DateTime'>
  }
    

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

  /**
   * Comment findUniqueOrThrow
   */
  export type CommentFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Comment
     */
    select?: CommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommentInclude<ExtArgs> | null
    /**
     * Filter, which Comment to fetch.
     */
    where: CommentWhereUniqueInput
  }

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

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

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

  /**
   * Comment create
   */
  export type CommentCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Comment
     */
    select?: CommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommentInclude<ExtArgs> | null
    /**
     * The data needed to create a Comment.
     */
    data: XOR<CommentCreateInput, CommentUncheckedCreateInput>
  }

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

  /**
   * Comment createManyAndReturn
   */
  export type CommentCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Comment
     */
    select?: CommentSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Comments.
     */
    data: CommentCreateManyInput | CommentCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommentIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Comment update
   */
  export type CommentUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Comment
     */
    select?: CommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommentInclude<ExtArgs> | null
    /**
     * The data needed to update a Comment.
     */
    data: XOR<CommentUpdateInput, CommentUncheckedUpdateInput>
    /**
     * Choose, which Comment to update.
     */
    where: CommentWhereUniqueInput
  }

  /**
   * Comment updateMany
   */
  export type CommentUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Comments.
     */
    data: XOR<CommentUpdateManyMutationInput, CommentUncheckedUpdateManyInput>
    /**
     * Filter which Comments to update
     */
    where?: CommentWhereInput
  }

  /**
   * Comment upsert
   */
  export type CommentUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Comment
     */
    select?: CommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommentInclude<ExtArgs> | null
    /**
     * The filter to search for the Comment to update in case it exists.
     */
    where: CommentWhereUniqueInput
    /**
     * In case the Comment found by the `where` argument doesn't exist, create a new Comment with this data.
     */
    create: XOR<CommentCreateInput, CommentUncheckedCreateInput>
    /**
     * In case the Comment was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CommentUpdateInput, CommentUncheckedUpdateInput>
  }

  /**
   * Comment delete
   */
  export type CommentDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Comment
     */
    select?: CommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommentInclude<ExtArgs> | null
    /**
     * Filter which Comment to delete.
     */
    where: CommentWhereUniqueInput
  }

  /**
   * Comment deleteMany
   */
  export type CommentDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Comments to delete
     */
    where?: CommentWhereInput
  }

  /**
   * Comment.replyTo
   */
  export type Comment$replyToArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Comment
     */
    select?: CommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommentInclude<ExtArgs> | null
    where?: CommentWhereInput
  }

  /**
   * Comment.replies
   */
  export type Comment$repliesArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Comment
     */
    select?: CommentSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CommentInclude<ExtArgs> | null
    where?: CommentWhereInput
    orderBy?: CommentOrderByWithRelationInput | CommentOrderByWithRelationInput[]
    cursor?: CommentWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CommentScalarFieldEnum | CommentScalarFieldEnum[]
  }

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


  /**
   * Model Setting
   */

  export type AggregateSetting = {
    _count: SettingCountAggregateOutputType | null
    _min: SettingMinAggregateOutputType | null
    _max: SettingMaxAggregateOutputType | null
  }

  export type SettingMinAggregateOutputType = {
    key: string | null
    updatedAt: Date | null
  }

  export type SettingMaxAggregateOutputType = {
    key: string | null
    updatedAt: Date | null
  }

  export type SettingCountAggregateOutputType = {
    key: number
    value: number
    updatedAt: number
    _all: number
  }


  export type SettingMinAggregateInputType = {
    key?: true
    updatedAt?: true
  }

  export type SettingMaxAggregateInputType = {
    key?: true
    updatedAt?: true
  }

  export type SettingCountAggregateInputType = {
    key?: true
    value?: true
    updatedAt?: true
    _all?: true
  }

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

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




  export type SettingGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SettingWhereInput
    orderBy?: SettingOrderByWithAggregationInput | SettingOrderByWithAggregationInput[]
    by: SettingScalarFieldEnum[] | SettingScalarFieldEnum
    having?: SettingScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: SettingCountAggregateInputType | true
    _min?: SettingMinAggregateInputType
    _max?: SettingMaxAggregateInputType
  }

  export type SettingGroupByOutputType = {
    key: string
    value: JsonValue
    updatedAt: Date
    _count: SettingCountAggregateOutputType | null
    _min: SettingMinAggregateOutputType | null
    _max: SettingMaxAggregateOutputType | null
  }

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


  export type SettingSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    key?: boolean
    value?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["setting"]>

  export type SettingSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    key?: boolean
    value?: boolean
    updatedAt?: boolean
  }, ExtArgs["result"]["setting"]>

  export type SettingSelectScalar = {
    key?: boolean
    value?: boolean
    updatedAt?: boolean
  }


  export type $SettingPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Setting"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      key: string
      value: Prisma.JsonValue
      updatedAt: Date
    }, ExtArgs["result"]["setting"]>
    composites: {}
  }

  type SettingGetPayload<S extends boolean | null | undefined | SettingDefaultArgs> = $Result.GetResult<Prisma.$SettingPayload, S>

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

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

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

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

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

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

    /**
     * Create a Setting.
     * @param {SettingCreateArgs} args - Arguments to create a Setting.
     * @example
     * // Create one Setting
     * const Setting = await prisma.setting.create({
     *   data: {
     *     // ... data to create a Setting
     *   }
     * })
     * 
     */
    create<T extends SettingCreateArgs>(args: SelectSubset<T, SettingCreateArgs<ExtArgs>>): Prisma__SettingClient<$Result.GetResult<Prisma.$SettingPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Setting.
     * @param {SettingDeleteArgs} args - Arguments to delete one Setting.
     * @example
     * // Delete one Setting
     * const Setting = await prisma.setting.delete({
     *   where: {
     *     // ... filter to delete one Setting
     *   }
     * })
     * 
     */
    delete<T extends SettingDeleteArgs>(args: SelectSubset<T, SettingDeleteArgs<ExtArgs>>): Prisma__SettingClient<$Result.GetResult<Prisma.$SettingPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Setting.
   * 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__SettingClient<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 Setting model
   */ 
  interface SettingFieldRefs {
    readonly key: FieldRef<"Setting", 'String'>
    readonly value: FieldRef<"Setting", 'Json'>
    readonly updatedAt: FieldRef<"Setting", 'DateTime'>
  }
    

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

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

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

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

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

  /**
   * Setting create
   */
  export type SettingCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Setting
     */
    select?: SettingSelect<ExtArgs> | null
    /**
     * The data needed to create a Setting.
     */
    data: XOR<SettingCreateInput, SettingUncheckedCreateInput>
  }

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

  /**
   * Setting createManyAndReturn
   */
  export type SettingCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Setting
     */
    select?: SettingSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Settings.
     */
    data: SettingCreateManyInput | SettingCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Setting update
   */
  export type SettingUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Setting
     */
    select?: SettingSelect<ExtArgs> | null
    /**
     * The data needed to update a Setting.
     */
    data: XOR<SettingUpdateInput, SettingUncheckedUpdateInput>
    /**
     * Choose, which Setting to update.
     */
    where: SettingWhereUniqueInput
  }

  /**
   * Setting updateMany
   */
  export type SettingUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Settings.
     */
    data: XOR<SettingUpdateManyMutationInput, SettingUncheckedUpdateManyInput>
    /**
     * Filter which Settings to update
     */
    where?: SettingWhereInput
  }

  /**
   * Setting upsert
   */
  export type SettingUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Setting
     */
    select?: SettingSelect<ExtArgs> | null
    /**
     * The filter to search for the Setting to update in case it exists.
     */
    where: SettingWhereUniqueInput
    /**
     * In case the Setting found by the `where` argument doesn't exist, create a new Setting with this data.
     */
    create: XOR<SettingCreateInput, SettingUncheckedCreateInput>
    /**
     * In case the Setting was found with the provided `where` argument, update it with this data.
     */
    update: XOR<SettingUpdateInput, SettingUncheckedUpdateInput>
  }

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

  /**
   * Setting deleteMany
   */
  export type SettingDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Settings to delete
     */
    where?: SettingWhereInput
  }

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


  /**
   * Model Promotion
   */

  export type AggregatePromotion = {
    _count: PromotionCountAggregateOutputType | null
    _avg: PromotionAvgAggregateOutputType | null
    _sum: PromotionSumAggregateOutputType | null
    _min: PromotionMinAggregateOutputType | null
    _max: PromotionMaxAggregateOutputType | null
  }

  export type PromotionAvgAggregateOutputType = {
    discountPercent: Decimal | null
    platform: number | null
  }

  export type PromotionSumAggregateOutputType = {
    discountPercent: Decimal | null
    platform: number | null
  }

  export type PromotionMinAggregateOutputType = {
    id: string | null
    title: string | null
    description: string | null
    scope: $Enums.PromotionScope | null
    usage: $Enums.PromotionUsage | null
    discountPercent: Decimal | null
    isActive: boolean | null
    platform: number | null
    startsAt: Date | null
    endsAt: Date | null
    productId: string | null
    categoryId: string | null
    customerId: string | null
    brandId: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type PromotionMaxAggregateOutputType = {
    id: string | null
    title: string | null
    description: string | null
    scope: $Enums.PromotionScope | null
    usage: $Enums.PromotionUsage | null
    discountPercent: Decimal | null
    isActive: boolean | null
    platform: number | null
    startsAt: Date | null
    endsAt: Date | null
    productId: string | null
    categoryId: string | null
    customerId: string | null
    brandId: string | null
    createdAt: Date | null
    updatedAt: Date | null
  }

  export type PromotionCountAggregateOutputType = {
    id: number
    title: number
    description: number
    scope: number
    usage: number
    discountPercent: number
    isActive: number
    platform: number
    startsAt: number
    endsAt: number
    productId: number
    categoryId: number
    customerId: number
    brandId: number
    createdAt: number
    updatedAt: number
    _all: number
  }


  export type PromotionAvgAggregateInputType = {
    discountPercent?: true
    platform?: true
  }

  export type PromotionSumAggregateInputType = {
    discountPercent?: true
    platform?: true
  }

  export type PromotionMinAggregateInputType = {
    id?: true
    title?: true
    description?: true
    scope?: true
    usage?: true
    discountPercent?: true
    isActive?: true
    platform?: true
    startsAt?: true
    endsAt?: true
    productId?: true
    categoryId?: true
    customerId?: true
    brandId?: true
    createdAt?: true
    updatedAt?: true
  }

  export type PromotionMaxAggregateInputType = {
    id?: true
    title?: true
    description?: true
    scope?: true
    usage?: true
    discountPercent?: true
    isActive?: true
    platform?: true
    startsAt?: true
    endsAt?: true
    productId?: true
    categoryId?: true
    customerId?: true
    brandId?: true
    createdAt?: true
    updatedAt?: true
  }

  export type PromotionCountAggregateInputType = {
    id?: true
    title?: true
    description?: true
    scope?: true
    usage?: true
    discountPercent?: true
    isActive?: true
    platform?: true
    startsAt?: true
    endsAt?: true
    productId?: true
    categoryId?: true
    customerId?: true
    brandId?: true
    createdAt?: true
    updatedAt?: true
    _all?: true
  }

  export type PromotionAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Promotion to aggregate.
     */
    where?: PromotionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Promotions to fetch.
     */
    orderBy?: PromotionOrderByWithRelationInput | PromotionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: PromotionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Promotions from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Promotions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Promotions
    **/
    _count?: true | PromotionCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: PromotionAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: PromotionSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: PromotionMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: PromotionMaxAggregateInputType
  }

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




  export type PromotionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PromotionWhereInput
    orderBy?: PromotionOrderByWithAggregationInput | PromotionOrderByWithAggregationInput[]
    by: PromotionScalarFieldEnum[] | PromotionScalarFieldEnum
    having?: PromotionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: PromotionCountAggregateInputType | true
    _avg?: PromotionAvgAggregateInputType
    _sum?: PromotionSumAggregateInputType
    _min?: PromotionMinAggregateInputType
    _max?: PromotionMaxAggregateInputType
  }

  export type PromotionGroupByOutputType = {
    id: string
    title: string
    description: string | null
    scope: $Enums.PromotionScope
    usage: $Enums.PromotionUsage
    discountPercent: Decimal
    isActive: boolean
    platform: number
    startsAt: Date | null
    endsAt: Date | null
    productId: string | null
    categoryId: string | null
    customerId: string | null
    brandId: string | null
    createdAt: Date
    updatedAt: Date
    _count: PromotionCountAggregateOutputType | null
    _avg: PromotionAvgAggregateOutputType | null
    _sum: PromotionSumAggregateOutputType | null
    _min: PromotionMinAggregateOutputType | null
    _max: PromotionMaxAggregateOutputType | null
  }

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


  export type PromotionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    description?: boolean
    scope?: boolean
    usage?: boolean
    discountPercent?: boolean
    isActive?: boolean
    platform?: boolean
    startsAt?: boolean
    endsAt?: boolean
    productId?: boolean
    categoryId?: boolean
    customerId?: boolean
    brandId?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    product?: boolean | Promotion$productArgs<ExtArgs>
    category?: boolean | Promotion$categoryArgs<ExtArgs>
    customer?: boolean | Promotion$customerArgs<ExtArgs>
    brand?: boolean | Promotion$brandArgs<ExtArgs>
  }, ExtArgs["result"]["promotion"]>

  export type PromotionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    description?: boolean
    scope?: boolean
    usage?: boolean
    discountPercent?: boolean
    isActive?: boolean
    platform?: boolean
    startsAt?: boolean
    endsAt?: boolean
    productId?: boolean
    categoryId?: boolean
    customerId?: boolean
    brandId?: boolean
    createdAt?: boolean
    updatedAt?: boolean
    product?: boolean | Promotion$productArgs<ExtArgs>
    category?: boolean | Promotion$categoryArgs<ExtArgs>
    customer?: boolean | Promotion$customerArgs<ExtArgs>
    brand?: boolean | Promotion$brandArgs<ExtArgs>
  }, ExtArgs["result"]["promotion"]>

  export type PromotionSelectScalar = {
    id?: boolean
    title?: boolean
    description?: boolean
    scope?: boolean
    usage?: boolean
    discountPercent?: boolean
    isActive?: boolean
    platform?: boolean
    startsAt?: boolean
    endsAt?: boolean
    productId?: boolean
    categoryId?: boolean
    customerId?: boolean
    brandId?: boolean
    createdAt?: boolean
    updatedAt?: boolean
  }

  export type PromotionInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    product?: boolean | Promotion$productArgs<ExtArgs>
    category?: boolean | Promotion$categoryArgs<ExtArgs>
    customer?: boolean | Promotion$customerArgs<ExtArgs>
    brand?: boolean | Promotion$brandArgs<ExtArgs>
  }
  export type PromotionIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    product?: boolean | Promotion$productArgs<ExtArgs>
    category?: boolean | Promotion$categoryArgs<ExtArgs>
    customer?: boolean | Promotion$customerArgs<ExtArgs>
    brand?: boolean | Promotion$brandArgs<ExtArgs>
  }

  export type $PromotionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Promotion"
    objects: {
      product: Prisma.$ProductPayload<ExtArgs> | null
      category: Prisma.$CategoryPayload<ExtArgs> | null
      customer: Prisma.$CustomerPayload<ExtArgs> | null
      brand: Prisma.$BrandPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      title: string
      description: string | null
      scope: $Enums.PromotionScope
      usage: $Enums.PromotionUsage
      /**
       * Percentage off, 0-100 (legacy discount_percent).
       */
      discountPercent: Prisma.Decimal
      isActive: boolean
      /**
       * Which storefront it shows on, mirroring Product.showType (legacy platform).
       */
      platform: number
      startsAt: Date | null
      endsAt: Date | null
      /**
       * Exactly one of these is populated, per `scope`.
       */
      productId: string | null
      categoryId: string | null
      customerId: string | null
      brandId: string | null
      createdAt: Date
      updatedAt: Date
    }, ExtArgs["result"]["promotion"]>
    composites: {}
  }

  type PromotionGetPayload<S extends boolean | null | undefined | PromotionDefaultArgs> = $Result.GetResult<Prisma.$PromotionPayload, S>

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

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

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

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

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

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

    /**
     * Create a Promotion.
     * @param {PromotionCreateArgs} args - Arguments to create a Promotion.
     * @example
     * // Create one Promotion
     * const Promotion = await prisma.promotion.create({
     *   data: {
     *     // ... data to create a Promotion
     *   }
     * })
     * 
     */
    create<T extends PromotionCreateArgs>(args: SelectSubset<T, PromotionCreateArgs<ExtArgs>>): Prisma__PromotionClient<$Result.GetResult<Prisma.$PromotionPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a Promotion.
     * @param {PromotionDeleteArgs} args - Arguments to delete one Promotion.
     * @example
     * // Delete one Promotion
     * const Promotion = await prisma.promotion.delete({
     *   where: {
     *     // ... filter to delete one Promotion
     *   }
     * })
     * 
     */
    delete<T extends PromotionDeleteArgs>(args: SelectSubset<T, PromotionDeleteArgs<ExtArgs>>): Prisma__PromotionClient<$Result.GetResult<Prisma.$PromotionPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for Promotion.
   * 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__PromotionClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    product<T extends Promotion$productArgs<ExtArgs> = {}>(args?: Subset<T, Promotion$productArgs<ExtArgs>>): Prisma__ProductClient<$Result.GetResult<Prisma.$ProductPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    category<T extends Promotion$categoryArgs<ExtArgs> = {}>(args?: Subset<T, Promotion$categoryArgs<ExtArgs>>): Prisma__CategoryClient<$Result.GetResult<Prisma.$CategoryPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    customer<T extends Promotion$customerArgs<ExtArgs> = {}>(args?: Subset<T, Promotion$customerArgs<ExtArgs>>): Prisma__CustomerClient<$Result.GetResult<Prisma.$CustomerPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    brand<T extends Promotion$brandArgs<ExtArgs> = {}>(args?: Subset<T, Promotion$brandArgs<ExtArgs>>): Prisma__BrandClient<$Result.GetResult<Prisma.$BrandPayload<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 Promotion model
   */ 
  interface PromotionFieldRefs {
    readonly id: FieldRef<"Promotion", 'String'>
    readonly title: FieldRef<"Promotion", 'String'>
    readonly description: FieldRef<"Promotion", 'String'>
    readonly scope: FieldRef<"Promotion", 'PromotionScope'>
    readonly usage: FieldRef<"Promotion", 'PromotionUsage'>
    readonly discountPercent: FieldRef<"Promotion", 'Decimal'>
    readonly isActive: FieldRef<"Promotion", 'Boolean'>
    readonly platform: FieldRef<"Promotion", 'Int'>
    readonly startsAt: FieldRef<"Promotion", 'DateTime'>
    readonly endsAt: FieldRef<"Promotion", 'DateTime'>
    readonly productId: FieldRef<"Promotion", 'String'>
    readonly categoryId: FieldRef<"Promotion", 'String'>
    readonly customerId: FieldRef<"Promotion", 'String'>
    readonly brandId: FieldRef<"Promotion", 'String'>
    readonly createdAt: FieldRef<"Promotion", 'DateTime'>
    readonly updatedAt: FieldRef<"Promotion", 'DateTime'>
  }
    

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

  /**
   * Promotion findUniqueOrThrow
   */
  export type PromotionFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Promotion
     */
    select?: PromotionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PromotionInclude<ExtArgs> | null
    /**
     * Filter, which Promotion to fetch.
     */
    where: PromotionWhereUniqueInput
  }

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

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

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

  /**
   * Promotion create
   */
  export type PromotionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Promotion
     */
    select?: PromotionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PromotionInclude<ExtArgs> | null
    /**
     * The data needed to create a Promotion.
     */
    data: XOR<PromotionCreateInput, PromotionUncheckedCreateInput>
  }

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

  /**
   * Promotion createManyAndReturn
   */
  export type PromotionCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Promotion
     */
    select?: PromotionSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Promotions.
     */
    data: PromotionCreateManyInput | PromotionCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PromotionIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Promotion update
   */
  export type PromotionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Promotion
     */
    select?: PromotionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PromotionInclude<ExtArgs> | null
    /**
     * The data needed to update a Promotion.
     */
    data: XOR<PromotionUpdateInput, PromotionUncheckedUpdateInput>
    /**
     * Choose, which Promotion to update.
     */
    where: PromotionWhereUniqueInput
  }

  /**
   * Promotion updateMany
   */
  export type PromotionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Promotions.
     */
    data: XOR<PromotionUpdateManyMutationInput, PromotionUncheckedUpdateManyInput>
    /**
     * Filter which Promotions to update
     */
    where?: PromotionWhereInput
  }

  /**
   * Promotion upsert
   */
  export type PromotionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Promotion
     */
    select?: PromotionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PromotionInclude<ExtArgs> | null
    /**
     * The filter to search for the Promotion to update in case it exists.
     */
    where: PromotionWhereUniqueInput
    /**
     * In case the Promotion found by the `where` argument doesn't exist, create a new Promotion with this data.
     */
    create: XOR<PromotionCreateInput, PromotionUncheckedCreateInput>
    /**
     * In case the Promotion was found with the provided `where` argument, update it with this data.
     */
    update: XOR<PromotionUpdateInput, PromotionUncheckedUpdateInput>
  }

  /**
   * Promotion delete
   */
  export type PromotionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Promotion
     */
    select?: PromotionSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: PromotionInclude<ExtArgs> | null
    /**
     * Filter which Promotion to delete.
     */
    where: PromotionWhereUniqueInput
  }

  /**
   * Promotion deleteMany
   */
  export type PromotionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Promotions to delete
     */
    where?: PromotionWhereInput
  }

  /**
   * Promotion.product
   */
  export type Promotion$productArgs<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
    where?: ProductWhereInput
  }

  /**
   * Promotion.category
   */
  export type Promotion$categoryArgs<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
    where?: CategoryWhereInput
  }

  /**
   * Promotion.customer
   */
  export type Promotion$customerArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Customer
     */
    select?: CustomerSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerInclude<ExtArgs> | null
    where?: CustomerWhereInput
  }

  /**
   * Promotion.brand
   */
  export type Promotion$brandArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Brand
     */
    select?: BrandSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BrandInclude<ExtArgs> | null
    where?: BrandWhereInput
  }

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


  /**
   * Model PromotionExclusion
   */

  export type AggregatePromotionExclusion = {
    _count: PromotionExclusionCountAggregateOutputType | null
    _avg: PromotionExclusionAvgAggregateOutputType | null
    _sum: PromotionExclusionSumAggregateOutputType | null
    _min: PromotionExclusionMinAggregateOutputType | null
    _max: PromotionExclusionMaxAggregateOutputType | null
  }

  export type PromotionExclusionAvgAggregateOutputType = {
    type: number | null
  }

  export type PromotionExclusionSumAggregateOutputType = {
    type: number | null
  }

  export type PromotionExclusionMinAggregateOutputType = {
    id: string | null
    type: number | null
    itemId: string | null
    createdAt: Date | null
  }

  export type PromotionExclusionMaxAggregateOutputType = {
    id: string | null
    type: number | null
    itemId: string | null
    createdAt: Date | null
  }

  export type PromotionExclusionCountAggregateOutputType = {
    id: number
    type: number
    itemId: number
    createdAt: number
    _all: number
  }


  export type PromotionExclusionAvgAggregateInputType = {
    type?: true
  }

  export type PromotionExclusionSumAggregateInputType = {
    type?: true
  }

  export type PromotionExclusionMinAggregateInputType = {
    id?: true
    type?: true
    itemId?: true
    createdAt?: true
  }

  export type PromotionExclusionMaxAggregateInputType = {
    id?: true
    type?: true
    itemId?: true
    createdAt?: true
  }

  export type PromotionExclusionCountAggregateInputType = {
    id?: true
    type?: true
    itemId?: true
    createdAt?: true
    _all?: true
  }

  export type PromotionExclusionAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which PromotionExclusion to aggregate.
     */
    where?: PromotionExclusionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PromotionExclusions to fetch.
     */
    orderBy?: PromotionExclusionOrderByWithRelationInput | PromotionExclusionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: PromotionExclusionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PromotionExclusions from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` PromotionExclusions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned PromotionExclusions
    **/
    _count?: true | PromotionExclusionCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: PromotionExclusionAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: PromotionExclusionSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: PromotionExclusionMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: PromotionExclusionMaxAggregateInputType
  }

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




  export type PromotionExclusionGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: PromotionExclusionWhereInput
    orderBy?: PromotionExclusionOrderByWithAggregationInput | PromotionExclusionOrderByWithAggregationInput[]
    by: PromotionExclusionScalarFieldEnum[] | PromotionExclusionScalarFieldEnum
    having?: PromotionExclusionScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: PromotionExclusionCountAggregateInputType | true
    _avg?: PromotionExclusionAvgAggregateInputType
    _sum?: PromotionExclusionSumAggregateInputType
    _min?: PromotionExclusionMinAggregateInputType
    _max?: PromotionExclusionMaxAggregateInputType
  }

  export type PromotionExclusionGroupByOutputType = {
    id: string
    type: number
    itemId: string
    createdAt: Date
    _count: PromotionExclusionCountAggregateOutputType | null
    _avg: PromotionExclusionAvgAggregateOutputType | null
    _sum: PromotionExclusionSumAggregateOutputType | null
    _min: PromotionExclusionMinAggregateOutputType | null
    _max: PromotionExclusionMaxAggregateOutputType | null
  }

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


  export type PromotionExclusionSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    type?: boolean
    itemId?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["promotionExclusion"]>

  export type PromotionExclusionSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    type?: boolean
    itemId?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["promotionExclusion"]>

  export type PromotionExclusionSelectScalar = {
    id?: boolean
    type?: boolean
    itemId?: boolean
    createdAt?: boolean
  }


  export type $PromotionExclusionPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "PromotionExclusion"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      type: number
      itemId: string
      createdAt: Date
    }, ExtArgs["result"]["promotionExclusion"]>
    composites: {}
  }

  type PromotionExclusionGetPayload<S extends boolean | null | undefined | PromotionExclusionDefaultArgs> = $Result.GetResult<Prisma.$PromotionExclusionPayload, S>

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

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

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

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

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

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

    /**
     * Create a PromotionExclusion.
     * @param {PromotionExclusionCreateArgs} args - Arguments to create a PromotionExclusion.
     * @example
     * // Create one PromotionExclusion
     * const PromotionExclusion = await prisma.promotionExclusion.create({
     *   data: {
     *     // ... data to create a PromotionExclusion
     *   }
     * })
     * 
     */
    create<T extends PromotionExclusionCreateArgs>(args: SelectSubset<T, PromotionExclusionCreateArgs<ExtArgs>>): Prisma__PromotionExclusionClient<$Result.GetResult<Prisma.$PromotionExclusionPayload<ExtArgs>, T, "create">, never, ExtArgs>

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

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

    /**
     * Delete a PromotionExclusion.
     * @param {PromotionExclusionDeleteArgs} args - Arguments to delete one PromotionExclusion.
     * @example
     * // Delete one PromotionExclusion
     * const PromotionExclusion = await prisma.promotionExclusion.delete({
     *   where: {
     *     // ... filter to delete one PromotionExclusion
     *   }
     * })
     * 
     */
    delete<T extends PromotionExclusionDeleteArgs>(args: SelectSubset<T, PromotionExclusionDeleteArgs<ExtArgs>>): Prisma__PromotionExclusionClient<$Result.GetResult<Prisma.$PromotionExclusionPayload<ExtArgs>, T, "delete">, never, ExtArgs>

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

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

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

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


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

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

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

  /**
   * The delegate class that acts as a "Promise-like" for PromotionExclusion.
   * 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__PromotionExclusionClient<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 PromotionExclusion model
   */ 
  interface PromotionExclusionFieldRefs {
    readonly id: FieldRef<"PromotionExclusion", 'String'>
    readonly type: FieldRef<"PromotionExclusion", 'Int'>
    readonly itemId: FieldRef<"PromotionExclusion", 'String'>
    readonly createdAt: FieldRef<"PromotionExclusion", 'DateTime'>
  }
    

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

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

  /**
   * PromotionExclusion findFirst
   */
  export type PromotionExclusionFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PromotionExclusion
     */
    select?: PromotionExclusionSelect<ExtArgs> | null
    /**
     * Filter, which PromotionExclusion to fetch.
     */
    where?: PromotionExclusionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PromotionExclusions to fetch.
     */
    orderBy?: PromotionExclusionOrderByWithRelationInput | PromotionExclusionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for PromotionExclusions.
     */
    cursor?: PromotionExclusionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PromotionExclusions from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` PromotionExclusions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of PromotionExclusions.
     */
    distinct?: PromotionExclusionScalarFieldEnum | PromotionExclusionScalarFieldEnum[]
  }

  /**
   * PromotionExclusion findFirstOrThrow
   */
  export type PromotionExclusionFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PromotionExclusion
     */
    select?: PromotionExclusionSelect<ExtArgs> | null
    /**
     * Filter, which PromotionExclusion to fetch.
     */
    where?: PromotionExclusionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PromotionExclusions to fetch.
     */
    orderBy?: PromotionExclusionOrderByWithRelationInput | PromotionExclusionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for PromotionExclusions.
     */
    cursor?: PromotionExclusionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PromotionExclusions from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` PromotionExclusions.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of PromotionExclusions.
     */
    distinct?: PromotionExclusionScalarFieldEnum | PromotionExclusionScalarFieldEnum[]
  }

  /**
   * PromotionExclusion findMany
   */
  export type PromotionExclusionFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PromotionExclusion
     */
    select?: PromotionExclusionSelect<ExtArgs> | null
    /**
     * Filter, which PromotionExclusions to fetch.
     */
    where?: PromotionExclusionWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of PromotionExclusions to fetch.
     */
    orderBy?: PromotionExclusionOrderByWithRelationInput | PromotionExclusionOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing PromotionExclusions.
     */
    cursor?: PromotionExclusionWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` PromotionExclusions from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` PromotionExclusions.
     */
    skip?: number
    distinct?: PromotionExclusionScalarFieldEnum | PromotionExclusionScalarFieldEnum[]
  }

  /**
   * PromotionExclusion create
   */
  export type PromotionExclusionCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PromotionExclusion
     */
    select?: PromotionExclusionSelect<ExtArgs> | null
    /**
     * The data needed to create a PromotionExclusion.
     */
    data: XOR<PromotionExclusionCreateInput, PromotionExclusionUncheckedCreateInput>
  }

  /**
   * PromotionExclusion createMany
   */
  export type PromotionExclusionCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many PromotionExclusions.
     */
    data: PromotionExclusionCreateManyInput | PromotionExclusionCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * PromotionExclusion createManyAndReturn
   */
  export type PromotionExclusionCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PromotionExclusion
     */
    select?: PromotionExclusionSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many PromotionExclusions.
     */
    data: PromotionExclusionCreateManyInput | PromotionExclusionCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * PromotionExclusion update
   */
  export type PromotionExclusionUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PromotionExclusion
     */
    select?: PromotionExclusionSelect<ExtArgs> | null
    /**
     * The data needed to update a PromotionExclusion.
     */
    data: XOR<PromotionExclusionUpdateInput, PromotionExclusionUncheckedUpdateInput>
    /**
     * Choose, which PromotionExclusion to update.
     */
    where: PromotionExclusionWhereUniqueInput
  }

  /**
   * PromotionExclusion updateMany
   */
  export type PromotionExclusionUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update PromotionExclusions.
     */
    data: XOR<PromotionExclusionUpdateManyMutationInput, PromotionExclusionUncheckedUpdateManyInput>
    /**
     * Filter which PromotionExclusions to update
     */
    where?: PromotionExclusionWhereInput
  }

  /**
   * PromotionExclusion upsert
   */
  export type PromotionExclusionUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PromotionExclusion
     */
    select?: PromotionExclusionSelect<ExtArgs> | null
    /**
     * The filter to search for the PromotionExclusion to update in case it exists.
     */
    where: PromotionExclusionWhereUniqueInput
    /**
     * In case the PromotionExclusion found by the `where` argument doesn't exist, create a new PromotionExclusion with this data.
     */
    create: XOR<PromotionExclusionCreateInput, PromotionExclusionUncheckedCreateInput>
    /**
     * In case the PromotionExclusion was found with the provided `where` argument, update it with this data.
     */
    update: XOR<PromotionExclusionUpdateInput, PromotionExclusionUncheckedUpdateInput>
  }

  /**
   * PromotionExclusion delete
   */
  export type PromotionExclusionDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PromotionExclusion
     */
    select?: PromotionExclusionSelect<ExtArgs> | null
    /**
     * Filter which PromotionExclusion to delete.
     */
    where: PromotionExclusionWhereUniqueInput
  }

  /**
   * PromotionExclusion deleteMany
   */
  export type PromotionExclusionDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which PromotionExclusions to delete
     */
    where?: PromotionExclusionWhereInput
  }

  /**
   * PromotionExclusion without action
   */
  export type PromotionExclusionDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the PromotionExclusion
     */
    select?: PromotionExclusionSelect<ExtArgs> | null
  }


  /**
   * Model BranchAllocation
   */

  export type AggregateBranchAllocation = {
    _count: BranchAllocationCountAggregateOutputType | null
    _min: BranchAllocationMinAggregateOutputType | null
    _max: BranchAllocationMaxAggregateOutputType | null
  }

  export type BranchAllocationMinAggregateOutputType = {
    id: string | null
    branchId: string | null
    allocatorAdminUserId: string | null
    note: string | null
    createdAt: Date | null
  }

  export type BranchAllocationMaxAggregateOutputType = {
    id: string | null
    branchId: string | null
    allocatorAdminUserId: string | null
    note: string | null
    createdAt: Date | null
  }

  export type BranchAllocationCountAggregateOutputType = {
    id: number
    branchId: number
    allocatorAdminUserId: number
    note: number
    createdAt: number
    _all: number
  }


  export type BranchAllocationMinAggregateInputType = {
    id?: true
    branchId?: true
    allocatorAdminUserId?: true
    note?: true
    createdAt?: true
  }

  export type BranchAllocationMaxAggregateInputType = {
    id?: true
    branchId?: true
    allocatorAdminUserId?: true
    note?: true
    createdAt?: true
  }

  export type BranchAllocationCountAggregateInputType = {
    id?: true
    branchId?: true
    allocatorAdminUserId?: true
    note?: true
    createdAt?: true
    _all?: true
  }

  export type BranchAllocationAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which BranchAllocation to aggregate.
     */
    where?: BranchAllocationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of BranchAllocations to fetch.
     */
    orderBy?: BranchAllocationOrderByWithRelationInput | BranchAllocationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: BranchAllocationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` BranchAllocations from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` BranchAllocations.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned BranchAllocations
    **/
    _count?: true | BranchAllocationCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: BranchAllocationMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: BranchAllocationMaxAggregateInputType
  }

  export type GetBranchAllocationAggregateType<T extends BranchAllocationAggregateArgs> = {
        [P in keyof T & keyof AggregateBranchAllocation]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateBranchAllocation[P]>
      : GetScalarType<T[P], AggregateBranchAllocation[P]>
  }




  export type BranchAllocationGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: BranchAllocationWhereInput
    orderBy?: BranchAllocationOrderByWithAggregationInput | BranchAllocationOrderByWithAggregationInput[]
    by: BranchAllocationScalarFieldEnum[] | BranchAllocationScalarFieldEnum
    having?: BranchAllocationScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: BranchAllocationCountAggregateInputType | true
    _min?: BranchAllocationMinAggregateInputType
    _max?: BranchAllocationMaxAggregateInputType
  }

  export type BranchAllocationGroupByOutputType = {
    id: string
    branchId: string
    allocatorAdminUserId: string | null
    note: string | null
    createdAt: Date
    _count: BranchAllocationCountAggregateOutputType | null
    _min: BranchAllocationMinAggregateOutputType | null
    _max: BranchAllocationMaxAggregateOutputType | null
  }

  type GetBranchAllocationGroupByPayload<T extends BranchAllocationGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<BranchAllocationGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof BranchAllocationGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], BranchAllocationGroupByOutputType[P]>
            : GetScalarType<T[P], BranchAllocationGroupByOutputType[P]>
        }
      >
    >


  export type BranchAllocationSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    branchId?: boolean
    allocatorAdminUserId?: boolean
    note?: boolean
    createdAt?: boolean
    branch?: boolean | BranchDefaultArgs<ExtArgs>
    allocatorAdminUser?: boolean | BranchAllocation$allocatorAdminUserArgs<ExtArgs>
    items?: boolean | BranchAllocation$itemsArgs<ExtArgs>
    _count?: boolean | BranchAllocationCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["branchAllocation"]>

  export type BranchAllocationSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    branchId?: boolean
    allocatorAdminUserId?: boolean
    note?: boolean
    createdAt?: boolean
    branch?: boolean | BranchDefaultArgs<ExtArgs>
    allocatorAdminUser?: boolean | BranchAllocation$allocatorAdminUserArgs<ExtArgs>
  }, ExtArgs["result"]["branchAllocation"]>

  export type BranchAllocationSelectScalar = {
    id?: boolean
    branchId?: boolean
    allocatorAdminUserId?: boolean
    note?: boolean
    createdAt?: boolean
  }

  export type BranchAllocationInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    branch?: boolean | BranchDefaultArgs<ExtArgs>
    allocatorAdminUser?: boolean | BranchAllocation$allocatorAdminUserArgs<ExtArgs>
    items?: boolean | BranchAllocation$itemsArgs<ExtArgs>
    _count?: boolean | BranchAllocationCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type BranchAllocationIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    branch?: boolean | BranchDefaultArgs<ExtArgs>
    allocatorAdminUser?: boolean | BranchAllocation$allocatorAdminUserArgs<ExtArgs>
  }

  export type $BranchAllocationPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "BranchAllocation"
    objects: {
      branch: Prisma.$BranchPayload<ExtArgs>
      allocatorAdminUser: Prisma.$AdminUserPayload<ExtArgs> | null
      items: Prisma.$BranchAllocationItemPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      branchId: string
      /**
       * Legacy `allocator_user` — the admin who filed the allocation.
       */
      allocatorAdminUserId: string | null
      note: string | null
      createdAt: Date
    }, ExtArgs["result"]["branchAllocation"]>
    composites: {}
  }

  type BranchAllocationGetPayload<S extends boolean | null | undefined | BranchAllocationDefaultArgs> = $Result.GetResult<Prisma.$BranchAllocationPayload, S>

  type BranchAllocationCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<BranchAllocationFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: BranchAllocationCountAggregateInputType | true
    }

  export interface BranchAllocationDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['BranchAllocation'], meta: { name: 'BranchAllocation' } }
    /**
     * Find zero or one BranchAllocation that matches the filter.
     * @param {BranchAllocationFindUniqueArgs} args - Arguments to find a BranchAllocation
     * @example
     * // Get one BranchAllocation
     * const branchAllocation = await prisma.branchAllocation.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends BranchAllocationFindUniqueArgs>(args: SelectSubset<T, BranchAllocationFindUniqueArgs<ExtArgs>>): Prisma__BranchAllocationClient<$Result.GetResult<Prisma.$BranchAllocationPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one BranchAllocation that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {BranchAllocationFindUniqueOrThrowArgs} args - Arguments to find a BranchAllocation
     * @example
     * // Get one BranchAllocation
     * const branchAllocation = await prisma.branchAllocation.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends BranchAllocationFindUniqueOrThrowArgs>(args: SelectSubset<T, BranchAllocationFindUniqueOrThrowArgs<ExtArgs>>): Prisma__BranchAllocationClient<$Result.GetResult<Prisma.$BranchAllocationPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first BranchAllocation that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {BranchAllocationFindFirstArgs} args - Arguments to find a BranchAllocation
     * @example
     * // Get one BranchAllocation
     * const branchAllocation = await prisma.branchAllocation.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends BranchAllocationFindFirstArgs>(args?: SelectSubset<T, BranchAllocationFindFirstArgs<ExtArgs>>): Prisma__BranchAllocationClient<$Result.GetResult<Prisma.$BranchAllocationPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first BranchAllocation 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 {BranchAllocationFindFirstOrThrowArgs} args - Arguments to find a BranchAllocation
     * @example
     * // Get one BranchAllocation
     * const branchAllocation = await prisma.branchAllocation.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends BranchAllocationFindFirstOrThrowArgs>(args?: SelectSubset<T, BranchAllocationFindFirstOrThrowArgs<ExtArgs>>): Prisma__BranchAllocationClient<$Result.GetResult<Prisma.$BranchAllocationPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more BranchAllocations that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {BranchAllocationFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all BranchAllocations
     * const branchAllocations = await prisma.branchAllocation.findMany()
     * 
     * // Get first 10 BranchAllocations
     * const branchAllocations = await prisma.branchAllocation.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const branchAllocationWithIdOnly = await prisma.branchAllocation.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends BranchAllocationFindManyArgs>(args?: SelectSubset<T, BranchAllocationFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$BranchAllocationPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a BranchAllocation.
     * @param {BranchAllocationCreateArgs} args - Arguments to create a BranchAllocation.
     * @example
     * // Create one BranchAllocation
     * const BranchAllocation = await prisma.branchAllocation.create({
     *   data: {
     *     // ... data to create a BranchAllocation
     *   }
     * })
     * 
     */
    create<T extends BranchAllocationCreateArgs>(args: SelectSubset<T, BranchAllocationCreateArgs<ExtArgs>>): Prisma__BranchAllocationClient<$Result.GetResult<Prisma.$BranchAllocationPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many BranchAllocations.
     * @param {BranchAllocationCreateManyArgs} args - Arguments to create many BranchAllocations.
     * @example
     * // Create many BranchAllocations
     * const branchAllocation = await prisma.branchAllocation.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends BranchAllocationCreateManyArgs>(args?: SelectSubset<T, BranchAllocationCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many BranchAllocations and returns the data saved in the database.
     * @param {BranchAllocationCreateManyAndReturnArgs} args - Arguments to create many BranchAllocations.
     * @example
     * // Create many BranchAllocations
     * const branchAllocation = await prisma.branchAllocation.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many BranchAllocations and only return the `id`
     * const branchAllocationWithIdOnly = await prisma.branchAllocation.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends BranchAllocationCreateManyAndReturnArgs>(args?: SelectSubset<T, BranchAllocationCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$BranchAllocationPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a BranchAllocation.
     * @param {BranchAllocationDeleteArgs} args - Arguments to delete one BranchAllocation.
     * @example
     * // Delete one BranchAllocation
     * const BranchAllocation = await prisma.branchAllocation.delete({
     *   where: {
     *     // ... filter to delete one BranchAllocation
     *   }
     * })
     * 
     */
    delete<T extends BranchAllocationDeleteArgs>(args: SelectSubset<T, BranchAllocationDeleteArgs<ExtArgs>>): Prisma__BranchAllocationClient<$Result.GetResult<Prisma.$BranchAllocationPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one BranchAllocation.
     * @param {BranchAllocationUpdateArgs} args - Arguments to update one BranchAllocation.
     * @example
     * // Update one BranchAllocation
     * const branchAllocation = await prisma.branchAllocation.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends BranchAllocationUpdateArgs>(args: SelectSubset<T, BranchAllocationUpdateArgs<ExtArgs>>): Prisma__BranchAllocationClient<$Result.GetResult<Prisma.$BranchAllocationPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more BranchAllocations.
     * @param {BranchAllocationDeleteManyArgs} args - Arguments to filter BranchAllocations to delete.
     * @example
     * // Delete a few BranchAllocations
     * const { count } = await prisma.branchAllocation.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends BranchAllocationDeleteManyArgs>(args?: SelectSubset<T, BranchAllocationDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more BranchAllocations.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {BranchAllocationUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many BranchAllocations
     * const branchAllocation = await prisma.branchAllocation.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends BranchAllocationUpdateManyArgs>(args: SelectSubset<T, BranchAllocationUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one BranchAllocation.
     * @param {BranchAllocationUpsertArgs} args - Arguments to update or create a BranchAllocation.
     * @example
     * // Update or create a BranchAllocation
     * const branchAllocation = await prisma.branchAllocation.upsert({
     *   create: {
     *     // ... data to create a BranchAllocation
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the BranchAllocation we want to update
     *   }
     * })
     */
    upsert<T extends BranchAllocationUpsertArgs>(args: SelectSubset<T, BranchAllocationUpsertArgs<ExtArgs>>): Prisma__BranchAllocationClient<$Result.GetResult<Prisma.$BranchAllocationPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of BranchAllocations.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {BranchAllocationCountArgs} args - Arguments to filter BranchAllocations to count.
     * @example
     * // Count the number of BranchAllocations
     * const count = await prisma.branchAllocation.count({
     *   where: {
     *     // ... the filter for the BranchAllocations we want to count
     *   }
     * })
    **/
    count<T extends BranchAllocationCountArgs>(
      args?: Subset<T, BranchAllocationCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], BranchAllocationCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a BranchAllocation.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {BranchAllocationAggregateArgs} 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 BranchAllocationAggregateArgs>(args: Subset<T, BranchAllocationAggregateArgs>): Prisma.PrismaPromise<GetBranchAllocationAggregateType<T>>

    /**
     * Group by BranchAllocation.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {BranchAllocationGroupByArgs} 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 BranchAllocationGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: BranchAllocationGroupByArgs['orderBy'] }
        : { orderBy?: BranchAllocationGroupByArgs['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, BranchAllocationGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetBranchAllocationGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the BranchAllocation model
   */
  readonly fields: BranchAllocationFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for BranchAllocation.
   * 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__BranchAllocationClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    branch<T extends BranchDefaultArgs<ExtArgs> = {}>(args?: Subset<T, BranchDefaultArgs<ExtArgs>>): Prisma__BranchClient<$Result.GetResult<Prisma.$BranchPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    allocatorAdminUser<T extends BranchAllocation$allocatorAdminUserArgs<ExtArgs> = {}>(args?: Subset<T, BranchAllocation$allocatorAdminUserArgs<ExtArgs>>): Prisma__AdminUserClient<$Result.GetResult<Prisma.$AdminUserPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    items<T extends BranchAllocation$itemsArgs<ExtArgs> = {}>(args?: Subset<T, BranchAllocation$itemsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$BranchAllocationItemPayload<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 BranchAllocation model
   */ 
  interface BranchAllocationFieldRefs {
    readonly id: FieldRef<"BranchAllocation", 'String'>
    readonly branchId: FieldRef<"BranchAllocation", 'String'>
    readonly allocatorAdminUserId: FieldRef<"BranchAllocation", 'String'>
    readonly note: FieldRef<"BranchAllocation", 'String'>
    readonly createdAt: FieldRef<"BranchAllocation", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * BranchAllocation findUnique
   */
  export type BranchAllocationFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BranchAllocation
     */
    select?: BranchAllocationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchAllocationInclude<ExtArgs> | null
    /**
     * Filter, which BranchAllocation to fetch.
     */
    where: BranchAllocationWhereUniqueInput
  }

  /**
   * BranchAllocation findUniqueOrThrow
   */
  export type BranchAllocationFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BranchAllocation
     */
    select?: BranchAllocationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchAllocationInclude<ExtArgs> | null
    /**
     * Filter, which BranchAllocation to fetch.
     */
    where: BranchAllocationWhereUniqueInput
  }

  /**
   * BranchAllocation findFirst
   */
  export type BranchAllocationFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BranchAllocation
     */
    select?: BranchAllocationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchAllocationInclude<ExtArgs> | null
    /**
     * Filter, which BranchAllocation to fetch.
     */
    where?: BranchAllocationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of BranchAllocations to fetch.
     */
    orderBy?: BranchAllocationOrderByWithRelationInput | BranchAllocationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for BranchAllocations.
     */
    cursor?: BranchAllocationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` BranchAllocations from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` BranchAllocations.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of BranchAllocations.
     */
    distinct?: BranchAllocationScalarFieldEnum | BranchAllocationScalarFieldEnum[]
  }

  /**
   * BranchAllocation findFirstOrThrow
   */
  export type BranchAllocationFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BranchAllocation
     */
    select?: BranchAllocationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchAllocationInclude<ExtArgs> | null
    /**
     * Filter, which BranchAllocation to fetch.
     */
    where?: BranchAllocationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of BranchAllocations to fetch.
     */
    orderBy?: BranchAllocationOrderByWithRelationInput | BranchAllocationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for BranchAllocations.
     */
    cursor?: BranchAllocationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` BranchAllocations from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` BranchAllocations.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of BranchAllocations.
     */
    distinct?: BranchAllocationScalarFieldEnum | BranchAllocationScalarFieldEnum[]
  }

  /**
   * BranchAllocation findMany
   */
  export type BranchAllocationFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BranchAllocation
     */
    select?: BranchAllocationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchAllocationInclude<ExtArgs> | null
    /**
     * Filter, which BranchAllocations to fetch.
     */
    where?: BranchAllocationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of BranchAllocations to fetch.
     */
    orderBy?: BranchAllocationOrderByWithRelationInput | BranchAllocationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing BranchAllocations.
     */
    cursor?: BranchAllocationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` BranchAllocations from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` BranchAllocations.
     */
    skip?: number
    distinct?: BranchAllocationScalarFieldEnum | BranchAllocationScalarFieldEnum[]
  }

  /**
   * BranchAllocation create
   */
  export type BranchAllocationCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BranchAllocation
     */
    select?: BranchAllocationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchAllocationInclude<ExtArgs> | null
    /**
     * The data needed to create a BranchAllocation.
     */
    data: XOR<BranchAllocationCreateInput, BranchAllocationUncheckedCreateInput>
  }

  /**
   * BranchAllocation createMany
   */
  export type BranchAllocationCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many BranchAllocations.
     */
    data: BranchAllocationCreateManyInput | BranchAllocationCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * BranchAllocation createManyAndReturn
   */
  export type BranchAllocationCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BranchAllocation
     */
    select?: BranchAllocationSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many BranchAllocations.
     */
    data: BranchAllocationCreateManyInput | BranchAllocationCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchAllocationIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * BranchAllocation update
   */
  export type BranchAllocationUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BranchAllocation
     */
    select?: BranchAllocationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchAllocationInclude<ExtArgs> | null
    /**
     * The data needed to update a BranchAllocation.
     */
    data: XOR<BranchAllocationUpdateInput, BranchAllocationUncheckedUpdateInput>
    /**
     * Choose, which BranchAllocation to update.
     */
    where: BranchAllocationWhereUniqueInput
  }

  /**
   * BranchAllocation updateMany
   */
  export type BranchAllocationUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update BranchAllocations.
     */
    data: XOR<BranchAllocationUpdateManyMutationInput, BranchAllocationUncheckedUpdateManyInput>
    /**
     * Filter which BranchAllocations to update
     */
    where?: BranchAllocationWhereInput
  }

  /**
   * BranchAllocation upsert
   */
  export type BranchAllocationUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BranchAllocation
     */
    select?: BranchAllocationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchAllocationInclude<ExtArgs> | null
    /**
     * The filter to search for the BranchAllocation to update in case it exists.
     */
    where: BranchAllocationWhereUniqueInput
    /**
     * In case the BranchAllocation found by the `where` argument doesn't exist, create a new BranchAllocation with this data.
     */
    create: XOR<BranchAllocationCreateInput, BranchAllocationUncheckedCreateInput>
    /**
     * In case the BranchAllocation was found with the provided `where` argument, update it with this data.
     */
    update: XOR<BranchAllocationUpdateInput, BranchAllocationUncheckedUpdateInput>
  }

  /**
   * BranchAllocation delete
   */
  export type BranchAllocationDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BranchAllocation
     */
    select?: BranchAllocationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchAllocationInclude<ExtArgs> | null
    /**
     * Filter which BranchAllocation to delete.
     */
    where: BranchAllocationWhereUniqueInput
  }

  /**
   * BranchAllocation deleteMany
   */
  export type BranchAllocationDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which BranchAllocations to delete
     */
    where?: BranchAllocationWhereInput
  }

  /**
   * BranchAllocation.allocatorAdminUser
   */
  export type BranchAllocation$allocatorAdminUserArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AdminUser
     */
    select?: AdminUserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AdminUserInclude<ExtArgs> | null
    where?: AdminUserWhereInput
  }

  /**
   * BranchAllocation.items
   */
  export type BranchAllocation$itemsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BranchAllocationItem
     */
    select?: BranchAllocationItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchAllocationItemInclude<ExtArgs> | null
    where?: BranchAllocationItemWhereInput
    orderBy?: BranchAllocationItemOrderByWithRelationInput | BranchAllocationItemOrderByWithRelationInput[]
    cursor?: BranchAllocationItemWhereUniqueInput
    take?: number
    skip?: number
    distinct?: BranchAllocationItemScalarFieldEnum | BranchAllocationItemScalarFieldEnum[]
  }

  /**
   * BranchAllocation without action
   */
  export type BranchAllocationDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BranchAllocation
     */
    select?: BranchAllocationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchAllocationInclude<ExtArgs> | null
  }


  /**
   * Model BranchAllocationItem
   */

  export type AggregateBranchAllocationItem = {
    _count: BranchAllocationItemCountAggregateOutputType | null
    _avg: BranchAllocationItemAvgAggregateOutputType | null
    _sum: BranchAllocationItemSumAggregateOutputType | null
    _min: BranchAllocationItemMinAggregateOutputType | null
    _max: BranchAllocationItemMaxAggregateOutputType | null
  }

  export type BranchAllocationItemAvgAggregateOutputType = {
    weightGrams: Decimal | null
  }

  export type BranchAllocationItemSumAggregateOutputType = {
    weightGrams: Decimal | null
  }

  export type BranchAllocationItemMinAggregateOutputType = {
    id: string | null
    allocationId: string | null
    productId: string | null
    weightGrams: Decimal | null
  }

  export type BranchAllocationItemMaxAggregateOutputType = {
    id: string | null
    allocationId: string | null
    productId: string | null
    weightGrams: Decimal | null
  }

  export type BranchAllocationItemCountAggregateOutputType = {
    id: number
    allocationId: number
    productId: number
    weightGrams: number
    _all: number
  }


  export type BranchAllocationItemAvgAggregateInputType = {
    weightGrams?: true
  }

  export type BranchAllocationItemSumAggregateInputType = {
    weightGrams?: true
  }

  export type BranchAllocationItemMinAggregateInputType = {
    id?: true
    allocationId?: true
    productId?: true
    weightGrams?: true
  }

  export type BranchAllocationItemMaxAggregateInputType = {
    id?: true
    allocationId?: true
    productId?: true
    weightGrams?: true
  }

  export type BranchAllocationItemCountAggregateInputType = {
    id?: true
    allocationId?: true
    productId?: true
    weightGrams?: true
    _all?: true
  }

  export type BranchAllocationItemAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which BranchAllocationItem to aggregate.
     */
    where?: BranchAllocationItemWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of BranchAllocationItems to fetch.
     */
    orderBy?: BranchAllocationItemOrderByWithRelationInput | BranchAllocationItemOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: BranchAllocationItemWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` BranchAllocationItems from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` BranchAllocationItems.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned BranchAllocationItems
    **/
    _count?: true | BranchAllocationItemCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: BranchAllocationItemAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: BranchAllocationItemSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: BranchAllocationItemMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: BranchAllocationItemMaxAggregateInputType
  }

  export type GetBranchAllocationItemAggregateType<T extends BranchAllocationItemAggregateArgs> = {
        [P in keyof T & keyof AggregateBranchAllocationItem]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateBranchAllocationItem[P]>
      : GetScalarType<T[P], AggregateBranchAllocationItem[P]>
  }




  export type BranchAllocationItemGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: BranchAllocationItemWhereInput
    orderBy?: BranchAllocationItemOrderByWithAggregationInput | BranchAllocationItemOrderByWithAggregationInput[]
    by: BranchAllocationItemScalarFieldEnum[] | BranchAllocationItemScalarFieldEnum
    having?: BranchAllocationItemScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: BranchAllocationItemCountAggregateInputType | true
    _avg?: BranchAllocationItemAvgAggregateInputType
    _sum?: BranchAllocationItemSumAggregateInputType
    _min?: BranchAllocationItemMinAggregateInputType
    _max?: BranchAllocationItemMaxAggregateInputType
  }

  export type BranchAllocationItemGroupByOutputType = {
    id: string
    allocationId: string
    productId: string
    weightGrams: Decimal | null
    _count: BranchAllocationItemCountAggregateOutputType | null
    _avg: BranchAllocationItemAvgAggregateOutputType | null
    _sum: BranchAllocationItemSumAggregateOutputType | null
    _min: BranchAllocationItemMinAggregateOutputType | null
    _max: BranchAllocationItemMaxAggregateOutputType | null
  }

  type GetBranchAllocationItemGroupByPayload<T extends BranchAllocationItemGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<BranchAllocationItemGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof BranchAllocationItemGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], BranchAllocationItemGroupByOutputType[P]>
            : GetScalarType<T[P], BranchAllocationItemGroupByOutputType[P]>
        }
      >
    >


  export type BranchAllocationItemSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    allocationId?: boolean
    productId?: boolean
    weightGrams?: boolean
    allocation?: boolean | BranchAllocationDefaultArgs<ExtArgs>
    product?: boolean | ProductDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["branchAllocationItem"]>

  export type BranchAllocationItemSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    allocationId?: boolean
    productId?: boolean
    weightGrams?: boolean
    allocation?: boolean | BranchAllocationDefaultArgs<ExtArgs>
    product?: boolean | ProductDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["branchAllocationItem"]>

  export type BranchAllocationItemSelectScalar = {
    id?: boolean
    allocationId?: boolean
    productId?: boolean
    weightGrams?: boolean
  }

  export type BranchAllocationItemInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    allocation?: boolean | BranchAllocationDefaultArgs<ExtArgs>
    product?: boolean | ProductDefaultArgs<ExtArgs>
  }
  export type BranchAllocationItemIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    allocation?: boolean | BranchAllocationDefaultArgs<ExtArgs>
    product?: boolean | ProductDefaultArgs<ExtArgs>
  }

  export type $BranchAllocationItemPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "BranchAllocationItem"
    objects: {
      allocation: Prisma.$BranchAllocationPayload<ExtArgs>
      product: Prisma.$ProductPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      allocationId: string
      productId: string
      /**
       * Weight snapshot at allocation time, so later catalog edits do not rewrite history.
       */
      weightGrams: Prisma.Decimal | null
    }, ExtArgs["result"]["branchAllocationItem"]>
    composites: {}
  }

  type BranchAllocationItemGetPayload<S extends boolean | null | undefined | BranchAllocationItemDefaultArgs> = $Result.GetResult<Prisma.$BranchAllocationItemPayload, S>

  type BranchAllocationItemCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<BranchAllocationItemFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: BranchAllocationItemCountAggregateInputType | true
    }

  export interface BranchAllocationItemDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['BranchAllocationItem'], meta: { name: 'BranchAllocationItem' } }
    /**
     * Find zero or one BranchAllocationItem that matches the filter.
     * @param {BranchAllocationItemFindUniqueArgs} args - Arguments to find a BranchAllocationItem
     * @example
     * // Get one BranchAllocationItem
     * const branchAllocationItem = await prisma.branchAllocationItem.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends BranchAllocationItemFindUniqueArgs>(args: SelectSubset<T, BranchAllocationItemFindUniqueArgs<ExtArgs>>): Prisma__BranchAllocationItemClient<$Result.GetResult<Prisma.$BranchAllocationItemPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one BranchAllocationItem that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {BranchAllocationItemFindUniqueOrThrowArgs} args - Arguments to find a BranchAllocationItem
     * @example
     * // Get one BranchAllocationItem
     * const branchAllocationItem = await prisma.branchAllocationItem.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends BranchAllocationItemFindUniqueOrThrowArgs>(args: SelectSubset<T, BranchAllocationItemFindUniqueOrThrowArgs<ExtArgs>>): Prisma__BranchAllocationItemClient<$Result.GetResult<Prisma.$BranchAllocationItemPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first BranchAllocationItem that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {BranchAllocationItemFindFirstArgs} args - Arguments to find a BranchAllocationItem
     * @example
     * // Get one BranchAllocationItem
     * const branchAllocationItem = await prisma.branchAllocationItem.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends BranchAllocationItemFindFirstArgs>(args?: SelectSubset<T, BranchAllocationItemFindFirstArgs<ExtArgs>>): Prisma__BranchAllocationItemClient<$Result.GetResult<Prisma.$BranchAllocationItemPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first BranchAllocationItem 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 {BranchAllocationItemFindFirstOrThrowArgs} args - Arguments to find a BranchAllocationItem
     * @example
     * // Get one BranchAllocationItem
     * const branchAllocationItem = await prisma.branchAllocationItem.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends BranchAllocationItemFindFirstOrThrowArgs>(args?: SelectSubset<T, BranchAllocationItemFindFirstOrThrowArgs<ExtArgs>>): Prisma__BranchAllocationItemClient<$Result.GetResult<Prisma.$BranchAllocationItemPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more BranchAllocationItems that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {BranchAllocationItemFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all BranchAllocationItems
     * const branchAllocationItems = await prisma.branchAllocationItem.findMany()
     * 
     * // Get first 10 BranchAllocationItems
     * const branchAllocationItems = await prisma.branchAllocationItem.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const branchAllocationItemWithIdOnly = await prisma.branchAllocationItem.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends BranchAllocationItemFindManyArgs>(args?: SelectSubset<T, BranchAllocationItemFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$BranchAllocationItemPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a BranchAllocationItem.
     * @param {BranchAllocationItemCreateArgs} args - Arguments to create a BranchAllocationItem.
     * @example
     * // Create one BranchAllocationItem
     * const BranchAllocationItem = await prisma.branchAllocationItem.create({
     *   data: {
     *     // ... data to create a BranchAllocationItem
     *   }
     * })
     * 
     */
    create<T extends BranchAllocationItemCreateArgs>(args: SelectSubset<T, BranchAllocationItemCreateArgs<ExtArgs>>): Prisma__BranchAllocationItemClient<$Result.GetResult<Prisma.$BranchAllocationItemPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many BranchAllocationItems.
     * @param {BranchAllocationItemCreateManyArgs} args - Arguments to create many BranchAllocationItems.
     * @example
     * // Create many BranchAllocationItems
     * const branchAllocationItem = await prisma.branchAllocationItem.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends BranchAllocationItemCreateManyArgs>(args?: SelectSubset<T, BranchAllocationItemCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many BranchAllocationItems and returns the data saved in the database.
     * @param {BranchAllocationItemCreateManyAndReturnArgs} args - Arguments to create many BranchAllocationItems.
     * @example
     * // Create many BranchAllocationItems
     * const branchAllocationItem = await prisma.branchAllocationItem.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many BranchAllocationItems and only return the `id`
     * const branchAllocationItemWithIdOnly = await prisma.branchAllocationItem.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends BranchAllocationItemCreateManyAndReturnArgs>(args?: SelectSubset<T, BranchAllocationItemCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$BranchAllocationItemPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a BranchAllocationItem.
     * @param {BranchAllocationItemDeleteArgs} args - Arguments to delete one BranchAllocationItem.
     * @example
     * // Delete one BranchAllocationItem
     * const BranchAllocationItem = await prisma.branchAllocationItem.delete({
     *   where: {
     *     // ... filter to delete one BranchAllocationItem
     *   }
     * })
     * 
     */
    delete<T extends BranchAllocationItemDeleteArgs>(args: SelectSubset<T, BranchAllocationItemDeleteArgs<ExtArgs>>): Prisma__BranchAllocationItemClient<$Result.GetResult<Prisma.$BranchAllocationItemPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one BranchAllocationItem.
     * @param {BranchAllocationItemUpdateArgs} args - Arguments to update one BranchAllocationItem.
     * @example
     * // Update one BranchAllocationItem
     * const branchAllocationItem = await prisma.branchAllocationItem.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends BranchAllocationItemUpdateArgs>(args: SelectSubset<T, BranchAllocationItemUpdateArgs<ExtArgs>>): Prisma__BranchAllocationItemClient<$Result.GetResult<Prisma.$BranchAllocationItemPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more BranchAllocationItems.
     * @param {BranchAllocationItemDeleteManyArgs} args - Arguments to filter BranchAllocationItems to delete.
     * @example
     * // Delete a few BranchAllocationItems
     * const { count } = await prisma.branchAllocationItem.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends BranchAllocationItemDeleteManyArgs>(args?: SelectSubset<T, BranchAllocationItemDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more BranchAllocationItems.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {BranchAllocationItemUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many BranchAllocationItems
     * const branchAllocationItem = await prisma.branchAllocationItem.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends BranchAllocationItemUpdateManyArgs>(args: SelectSubset<T, BranchAllocationItemUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one BranchAllocationItem.
     * @param {BranchAllocationItemUpsertArgs} args - Arguments to update or create a BranchAllocationItem.
     * @example
     * // Update or create a BranchAllocationItem
     * const branchAllocationItem = await prisma.branchAllocationItem.upsert({
     *   create: {
     *     // ... data to create a BranchAllocationItem
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the BranchAllocationItem we want to update
     *   }
     * })
     */
    upsert<T extends BranchAllocationItemUpsertArgs>(args: SelectSubset<T, BranchAllocationItemUpsertArgs<ExtArgs>>): Prisma__BranchAllocationItemClient<$Result.GetResult<Prisma.$BranchAllocationItemPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of BranchAllocationItems.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {BranchAllocationItemCountArgs} args - Arguments to filter BranchAllocationItems to count.
     * @example
     * // Count the number of BranchAllocationItems
     * const count = await prisma.branchAllocationItem.count({
     *   where: {
     *     // ... the filter for the BranchAllocationItems we want to count
     *   }
     * })
    **/
    count<T extends BranchAllocationItemCountArgs>(
      args?: Subset<T, BranchAllocationItemCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], BranchAllocationItemCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a BranchAllocationItem.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {BranchAllocationItemAggregateArgs} 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 BranchAllocationItemAggregateArgs>(args: Subset<T, BranchAllocationItemAggregateArgs>): Prisma.PrismaPromise<GetBranchAllocationItemAggregateType<T>>

    /**
     * Group by BranchAllocationItem.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {BranchAllocationItemGroupByArgs} 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 BranchAllocationItemGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: BranchAllocationItemGroupByArgs['orderBy'] }
        : { orderBy?: BranchAllocationItemGroupByArgs['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, BranchAllocationItemGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetBranchAllocationItemGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the BranchAllocationItem model
   */
  readonly fields: BranchAllocationItemFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for BranchAllocationItem.
   * 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__BranchAllocationItemClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    allocation<T extends BranchAllocationDefaultArgs<ExtArgs> = {}>(args?: Subset<T, BranchAllocationDefaultArgs<ExtArgs>>): Prisma__BranchAllocationClient<$Result.GetResult<Prisma.$BranchAllocationPayload<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>
    /**
     * 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 BranchAllocationItem model
   */ 
  interface BranchAllocationItemFieldRefs {
    readonly id: FieldRef<"BranchAllocationItem", 'String'>
    readonly allocationId: FieldRef<"BranchAllocationItem", 'String'>
    readonly productId: FieldRef<"BranchAllocationItem", 'String'>
    readonly weightGrams: FieldRef<"BranchAllocationItem", 'Decimal'>
  }
    

  // Custom InputTypes
  /**
   * BranchAllocationItem findUnique
   */
  export type BranchAllocationItemFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BranchAllocationItem
     */
    select?: BranchAllocationItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchAllocationItemInclude<ExtArgs> | null
    /**
     * Filter, which BranchAllocationItem to fetch.
     */
    where: BranchAllocationItemWhereUniqueInput
  }

  /**
   * BranchAllocationItem findUniqueOrThrow
   */
  export type BranchAllocationItemFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BranchAllocationItem
     */
    select?: BranchAllocationItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchAllocationItemInclude<ExtArgs> | null
    /**
     * Filter, which BranchAllocationItem to fetch.
     */
    where: BranchAllocationItemWhereUniqueInput
  }

  /**
   * BranchAllocationItem findFirst
   */
  export type BranchAllocationItemFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BranchAllocationItem
     */
    select?: BranchAllocationItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchAllocationItemInclude<ExtArgs> | null
    /**
     * Filter, which BranchAllocationItem to fetch.
     */
    where?: BranchAllocationItemWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of BranchAllocationItems to fetch.
     */
    orderBy?: BranchAllocationItemOrderByWithRelationInput | BranchAllocationItemOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for BranchAllocationItems.
     */
    cursor?: BranchAllocationItemWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` BranchAllocationItems from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` BranchAllocationItems.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of BranchAllocationItems.
     */
    distinct?: BranchAllocationItemScalarFieldEnum | BranchAllocationItemScalarFieldEnum[]
  }

  /**
   * BranchAllocationItem findFirstOrThrow
   */
  export type BranchAllocationItemFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BranchAllocationItem
     */
    select?: BranchAllocationItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchAllocationItemInclude<ExtArgs> | null
    /**
     * Filter, which BranchAllocationItem to fetch.
     */
    where?: BranchAllocationItemWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of BranchAllocationItems to fetch.
     */
    orderBy?: BranchAllocationItemOrderByWithRelationInput | BranchAllocationItemOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for BranchAllocationItems.
     */
    cursor?: BranchAllocationItemWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` BranchAllocationItems from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` BranchAllocationItems.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of BranchAllocationItems.
     */
    distinct?: BranchAllocationItemScalarFieldEnum | BranchAllocationItemScalarFieldEnum[]
  }

  /**
   * BranchAllocationItem findMany
   */
  export type BranchAllocationItemFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BranchAllocationItem
     */
    select?: BranchAllocationItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchAllocationItemInclude<ExtArgs> | null
    /**
     * Filter, which BranchAllocationItems to fetch.
     */
    where?: BranchAllocationItemWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of BranchAllocationItems to fetch.
     */
    orderBy?: BranchAllocationItemOrderByWithRelationInput | BranchAllocationItemOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing BranchAllocationItems.
     */
    cursor?: BranchAllocationItemWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` BranchAllocationItems from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` BranchAllocationItems.
     */
    skip?: number
    distinct?: BranchAllocationItemScalarFieldEnum | BranchAllocationItemScalarFieldEnum[]
  }

  /**
   * BranchAllocationItem create
   */
  export type BranchAllocationItemCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BranchAllocationItem
     */
    select?: BranchAllocationItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchAllocationItemInclude<ExtArgs> | null
    /**
     * The data needed to create a BranchAllocationItem.
     */
    data: XOR<BranchAllocationItemCreateInput, BranchAllocationItemUncheckedCreateInput>
  }

  /**
   * BranchAllocationItem createMany
   */
  export type BranchAllocationItemCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many BranchAllocationItems.
     */
    data: BranchAllocationItemCreateManyInput | BranchAllocationItemCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * BranchAllocationItem createManyAndReturn
   */
  export type BranchAllocationItemCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BranchAllocationItem
     */
    select?: BranchAllocationItemSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many BranchAllocationItems.
     */
    data: BranchAllocationItemCreateManyInput | BranchAllocationItemCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchAllocationItemIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * BranchAllocationItem update
   */
  export type BranchAllocationItemUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BranchAllocationItem
     */
    select?: BranchAllocationItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchAllocationItemInclude<ExtArgs> | null
    /**
     * The data needed to update a BranchAllocationItem.
     */
    data: XOR<BranchAllocationItemUpdateInput, BranchAllocationItemUncheckedUpdateInput>
    /**
     * Choose, which BranchAllocationItem to update.
     */
    where: BranchAllocationItemWhereUniqueInput
  }

  /**
   * BranchAllocationItem updateMany
   */
  export type BranchAllocationItemUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update BranchAllocationItems.
     */
    data: XOR<BranchAllocationItemUpdateManyMutationInput, BranchAllocationItemUncheckedUpdateManyInput>
    /**
     * Filter which BranchAllocationItems to update
     */
    where?: BranchAllocationItemWhereInput
  }

  /**
   * BranchAllocationItem upsert
   */
  export type BranchAllocationItemUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BranchAllocationItem
     */
    select?: BranchAllocationItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchAllocationItemInclude<ExtArgs> | null
    /**
     * The filter to search for the BranchAllocationItem to update in case it exists.
     */
    where: BranchAllocationItemWhereUniqueInput
    /**
     * In case the BranchAllocationItem found by the `where` argument doesn't exist, create a new BranchAllocationItem with this data.
     */
    create: XOR<BranchAllocationItemCreateInput, BranchAllocationItemUncheckedCreateInput>
    /**
     * In case the BranchAllocationItem was found with the provided `where` argument, update it with this data.
     */
    update: XOR<BranchAllocationItemUpdateInput, BranchAllocationItemUncheckedUpdateInput>
  }

  /**
   * BranchAllocationItem delete
   */
  export type BranchAllocationItemDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BranchAllocationItem
     */
    select?: BranchAllocationItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchAllocationItemInclude<ExtArgs> | null
    /**
     * Filter which BranchAllocationItem to delete.
     */
    where: BranchAllocationItemWhereUniqueInput
  }

  /**
   * BranchAllocationItem deleteMany
   */
  export type BranchAllocationItemDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which BranchAllocationItems to delete
     */
    where?: BranchAllocationItemWhereInput
  }

  /**
   * BranchAllocationItem without action
   */
  export type BranchAllocationItemDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the BranchAllocationItem
     */
    select?: BranchAllocationItemSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: BranchAllocationItemInclude<ExtArgs> | null
  }


  /**
   * Model SmsMessage
   */

  export type AggregateSmsMessage = {
    _count: SmsMessageCountAggregateOutputType | null
    _avg: SmsMessageAvgAggregateOutputType | null
    _sum: SmsMessageSumAggregateOutputType | null
    _min: SmsMessageMinAggregateOutputType | null
    _max: SmsMessageMaxAggregateOutputType | null
  }

  export type SmsMessageAvgAggregateOutputType = {
    sentCount: number | null
  }

  export type SmsMessageSumAggregateOutputType = {
    sentCount: number | null
  }

  export type SmsMessageMinAggregateOutputType = {
    id: string | null
    audience: $Enums.MessageAudience | null
    recipients: string | null
    body: string | null
    sentCount: number | null
    sentByAdminUserId: string | null
    createdAt: Date | null
  }

  export type SmsMessageMaxAggregateOutputType = {
    id: string | null
    audience: $Enums.MessageAudience | null
    recipients: string | null
    body: string | null
    sentCount: number | null
    sentByAdminUserId: string | null
    createdAt: Date | null
  }

  export type SmsMessageCountAggregateOutputType = {
    id: number
    audience: number
    recipients: number
    body: number
    sentCount: number
    sentByAdminUserId: number
    createdAt: number
    _all: number
  }


  export type SmsMessageAvgAggregateInputType = {
    sentCount?: true
  }

  export type SmsMessageSumAggregateInputType = {
    sentCount?: true
  }

  export type SmsMessageMinAggregateInputType = {
    id?: true
    audience?: true
    recipients?: true
    body?: true
    sentCount?: true
    sentByAdminUserId?: true
    createdAt?: true
  }

  export type SmsMessageMaxAggregateInputType = {
    id?: true
    audience?: true
    recipients?: true
    body?: true
    sentCount?: true
    sentByAdminUserId?: true
    createdAt?: true
  }

  export type SmsMessageCountAggregateInputType = {
    id?: true
    audience?: true
    recipients?: true
    body?: true
    sentCount?: true
    sentByAdminUserId?: true
    createdAt?: true
    _all?: true
  }

  export type SmsMessageAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which SmsMessage to aggregate.
     */
    where?: SmsMessageWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SmsMessages to fetch.
     */
    orderBy?: SmsMessageOrderByWithRelationInput | SmsMessageOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: SmsMessageWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SmsMessages from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` SmsMessages.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned SmsMessages
    **/
    _count?: true | SmsMessageCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: SmsMessageAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: SmsMessageSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: SmsMessageMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: SmsMessageMaxAggregateInputType
  }

  export type GetSmsMessageAggregateType<T extends SmsMessageAggregateArgs> = {
        [P in keyof T & keyof AggregateSmsMessage]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateSmsMessage[P]>
      : GetScalarType<T[P], AggregateSmsMessage[P]>
  }




  export type SmsMessageGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: SmsMessageWhereInput
    orderBy?: SmsMessageOrderByWithAggregationInput | SmsMessageOrderByWithAggregationInput[]
    by: SmsMessageScalarFieldEnum[] | SmsMessageScalarFieldEnum
    having?: SmsMessageScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: SmsMessageCountAggregateInputType | true
    _avg?: SmsMessageAvgAggregateInputType
    _sum?: SmsMessageSumAggregateInputType
    _min?: SmsMessageMinAggregateInputType
    _max?: SmsMessageMaxAggregateInputType
  }

  export type SmsMessageGroupByOutputType = {
    id: string
    audience: $Enums.MessageAudience
    recipients: string | null
    body: string
    sentCount: number
    sentByAdminUserId: string | null
    createdAt: Date
    _count: SmsMessageCountAggregateOutputType | null
    _avg: SmsMessageAvgAggregateOutputType | null
    _sum: SmsMessageSumAggregateOutputType | null
    _min: SmsMessageMinAggregateOutputType | null
    _max: SmsMessageMaxAggregateOutputType | null
  }

  type GetSmsMessageGroupByPayload<T extends SmsMessageGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<SmsMessageGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof SmsMessageGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], SmsMessageGroupByOutputType[P]>
            : GetScalarType<T[P], SmsMessageGroupByOutputType[P]>
        }
      >
    >


  export type SmsMessageSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    audience?: boolean
    recipients?: boolean
    body?: boolean
    sentCount?: boolean
    sentByAdminUserId?: boolean
    createdAt?: boolean
    sentByAdminUser?: boolean | SmsMessage$sentByAdminUserArgs<ExtArgs>
  }, ExtArgs["result"]["smsMessage"]>

  export type SmsMessageSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    audience?: boolean
    recipients?: boolean
    body?: boolean
    sentCount?: boolean
    sentByAdminUserId?: boolean
    createdAt?: boolean
    sentByAdminUser?: boolean | SmsMessage$sentByAdminUserArgs<ExtArgs>
  }, ExtArgs["result"]["smsMessage"]>

  export type SmsMessageSelectScalar = {
    id?: boolean
    audience?: boolean
    recipients?: boolean
    body?: boolean
    sentCount?: boolean
    sentByAdminUserId?: boolean
    createdAt?: boolean
  }

  export type SmsMessageInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    sentByAdminUser?: boolean | SmsMessage$sentByAdminUserArgs<ExtArgs>
  }
  export type SmsMessageIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    sentByAdminUser?: boolean | SmsMessage$sentByAdminUserArgs<ExtArgs>
  }

  export type $SmsMessagePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "SmsMessage"
    objects: {
      sentByAdminUser: Prisma.$AdminUserPayload<ExtArgs> | null
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      audience: $Enums.MessageAudience
      /**
       * Comma-separated recipients for the SINGLE/MULTIPLE audiences.
       */
      recipients: string | null
      body: string
      /**
       * How many numbers the send actually resolved to.
       */
      sentCount: number
      sentByAdminUserId: string | null
      createdAt: Date
    }, ExtArgs["result"]["smsMessage"]>
    composites: {}
  }

  type SmsMessageGetPayload<S extends boolean | null | undefined | SmsMessageDefaultArgs> = $Result.GetResult<Prisma.$SmsMessagePayload, S>

  type SmsMessageCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<SmsMessageFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: SmsMessageCountAggregateInputType | true
    }

  export interface SmsMessageDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['SmsMessage'], meta: { name: 'SmsMessage' } }
    /**
     * Find zero or one SmsMessage that matches the filter.
     * @param {SmsMessageFindUniqueArgs} args - Arguments to find a SmsMessage
     * @example
     * // Get one SmsMessage
     * const smsMessage = await prisma.smsMessage.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends SmsMessageFindUniqueArgs>(args: SelectSubset<T, SmsMessageFindUniqueArgs<ExtArgs>>): Prisma__SmsMessageClient<$Result.GetResult<Prisma.$SmsMessagePayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one SmsMessage that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {SmsMessageFindUniqueOrThrowArgs} args - Arguments to find a SmsMessage
     * @example
     * // Get one SmsMessage
     * const smsMessage = await prisma.smsMessage.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends SmsMessageFindUniqueOrThrowArgs>(args: SelectSubset<T, SmsMessageFindUniqueOrThrowArgs<ExtArgs>>): Prisma__SmsMessageClient<$Result.GetResult<Prisma.$SmsMessagePayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first SmsMessage that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SmsMessageFindFirstArgs} args - Arguments to find a SmsMessage
     * @example
     * // Get one SmsMessage
     * const smsMessage = await prisma.smsMessage.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends SmsMessageFindFirstArgs>(args?: SelectSubset<T, SmsMessageFindFirstArgs<ExtArgs>>): Prisma__SmsMessageClient<$Result.GetResult<Prisma.$SmsMessagePayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first SmsMessage 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 {SmsMessageFindFirstOrThrowArgs} args - Arguments to find a SmsMessage
     * @example
     * // Get one SmsMessage
     * const smsMessage = await prisma.smsMessage.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends SmsMessageFindFirstOrThrowArgs>(args?: SelectSubset<T, SmsMessageFindFirstOrThrowArgs<ExtArgs>>): Prisma__SmsMessageClient<$Result.GetResult<Prisma.$SmsMessagePayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more SmsMessages that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SmsMessageFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all SmsMessages
     * const smsMessages = await prisma.smsMessage.findMany()
     * 
     * // Get first 10 SmsMessages
     * const smsMessages = await prisma.smsMessage.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const smsMessageWithIdOnly = await prisma.smsMessage.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends SmsMessageFindManyArgs>(args?: SelectSubset<T, SmsMessageFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SmsMessagePayload<ExtArgs>, T, "findMany">>

    /**
     * Create a SmsMessage.
     * @param {SmsMessageCreateArgs} args - Arguments to create a SmsMessage.
     * @example
     * // Create one SmsMessage
     * const SmsMessage = await prisma.smsMessage.create({
     *   data: {
     *     // ... data to create a SmsMessage
     *   }
     * })
     * 
     */
    create<T extends SmsMessageCreateArgs>(args: SelectSubset<T, SmsMessageCreateArgs<ExtArgs>>): Prisma__SmsMessageClient<$Result.GetResult<Prisma.$SmsMessagePayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many SmsMessages.
     * @param {SmsMessageCreateManyArgs} args - Arguments to create many SmsMessages.
     * @example
     * // Create many SmsMessages
     * const smsMessage = await prisma.smsMessage.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends SmsMessageCreateManyArgs>(args?: SelectSubset<T, SmsMessageCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many SmsMessages and returns the data saved in the database.
     * @param {SmsMessageCreateManyAndReturnArgs} args - Arguments to create many SmsMessages.
     * @example
     * // Create many SmsMessages
     * const smsMessage = await prisma.smsMessage.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many SmsMessages and only return the `id`
     * const smsMessageWithIdOnly = await prisma.smsMessage.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends SmsMessageCreateManyAndReturnArgs>(args?: SelectSubset<T, SmsMessageCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$SmsMessagePayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a SmsMessage.
     * @param {SmsMessageDeleteArgs} args - Arguments to delete one SmsMessage.
     * @example
     * // Delete one SmsMessage
     * const SmsMessage = await prisma.smsMessage.delete({
     *   where: {
     *     // ... filter to delete one SmsMessage
     *   }
     * })
     * 
     */
    delete<T extends SmsMessageDeleteArgs>(args: SelectSubset<T, SmsMessageDeleteArgs<ExtArgs>>): Prisma__SmsMessageClient<$Result.GetResult<Prisma.$SmsMessagePayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one SmsMessage.
     * @param {SmsMessageUpdateArgs} args - Arguments to update one SmsMessage.
     * @example
     * // Update one SmsMessage
     * const smsMessage = await prisma.smsMessage.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends SmsMessageUpdateArgs>(args: SelectSubset<T, SmsMessageUpdateArgs<ExtArgs>>): Prisma__SmsMessageClient<$Result.GetResult<Prisma.$SmsMessagePayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more SmsMessages.
     * @param {SmsMessageDeleteManyArgs} args - Arguments to filter SmsMessages to delete.
     * @example
     * // Delete a few SmsMessages
     * const { count } = await prisma.smsMessage.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends SmsMessageDeleteManyArgs>(args?: SelectSubset<T, SmsMessageDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more SmsMessages.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SmsMessageUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many SmsMessages
     * const smsMessage = await prisma.smsMessage.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends SmsMessageUpdateManyArgs>(args: SelectSubset<T, SmsMessageUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one SmsMessage.
     * @param {SmsMessageUpsertArgs} args - Arguments to update or create a SmsMessage.
     * @example
     * // Update or create a SmsMessage
     * const smsMessage = await prisma.smsMessage.upsert({
     *   create: {
     *     // ... data to create a SmsMessage
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the SmsMessage we want to update
     *   }
     * })
     */
    upsert<T extends SmsMessageUpsertArgs>(args: SelectSubset<T, SmsMessageUpsertArgs<ExtArgs>>): Prisma__SmsMessageClient<$Result.GetResult<Prisma.$SmsMessagePayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of SmsMessages.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SmsMessageCountArgs} args - Arguments to filter SmsMessages to count.
     * @example
     * // Count the number of SmsMessages
     * const count = await prisma.smsMessage.count({
     *   where: {
     *     // ... the filter for the SmsMessages we want to count
     *   }
     * })
    **/
    count<T extends SmsMessageCountArgs>(
      args?: Subset<T, SmsMessageCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], SmsMessageCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a SmsMessage.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SmsMessageAggregateArgs} 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 SmsMessageAggregateArgs>(args: Subset<T, SmsMessageAggregateArgs>): Prisma.PrismaPromise<GetSmsMessageAggregateType<T>>

    /**
     * Group by SmsMessage.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {SmsMessageGroupByArgs} 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 SmsMessageGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: SmsMessageGroupByArgs['orderBy'] }
        : { orderBy?: SmsMessageGroupByArgs['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, SmsMessageGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetSmsMessageGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the SmsMessage model
   */
  readonly fields: SmsMessageFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for SmsMessage.
   * 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__SmsMessageClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    sentByAdminUser<T extends SmsMessage$sentByAdminUserArgs<ExtArgs> = {}>(args?: Subset<T, SmsMessage$sentByAdminUserArgs<ExtArgs>>): Prisma__AdminUserClient<$Result.GetResult<Prisma.$AdminUserPayload<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 SmsMessage model
   */ 
  interface SmsMessageFieldRefs {
    readonly id: FieldRef<"SmsMessage", 'String'>
    readonly audience: FieldRef<"SmsMessage", 'MessageAudience'>
    readonly recipients: FieldRef<"SmsMessage", 'String'>
    readonly body: FieldRef<"SmsMessage", 'String'>
    readonly sentCount: FieldRef<"SmsMessage", 'Int'>
    readonly sentByAdminUserId: FieldRef<"SmsMessage", 'String'>
    readonly createdAt: FieldRef<"SmsMessage", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * SmsMessage findUnique
   */
  export type SmsMessageFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SmsMessage
     */
    select?: SmsMessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SmsMessageInclude<ExtArgs> | null
    /**
     * Filter, which SmsMessage to fetch.
     */
    where: SmsMessageWhereUniqueInput
  }

  /**
   * SmsMessage findUniqueOrThrow
   */
  export type SmsMessageFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SmsMessage
     */
    select?: SmsMessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SmsMessageInclude<ExtArgs> | null
    /**
     * Filter, which SmsMessage to fetch.
     */
    where: SmsMessageWhereUniqueInput
  }

  /**
   * SmsMessage findFirst
   */
  export type SmsMessageFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SmsMessage
     */
    select?: SmsMessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SmsMessageInclude<ExtArgs> | null
    /**
     * Filter, which SmsMessage to fetch.
     */
    where?: SmsMessageWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SmsMessages to fetch.
     */
    orderBy?: SmsMessageOrderByWithRelationInput | SmsMessageOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for SmsMessages.
     */
    cursor?: SmsMessageWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SmsMessages from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` SmsMessages.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of SmsMessages.
     */
    distinct?: SmsMessageScalarFieldEnum | SmsMessageScalarFieldEnum[]
  }

  /**
   * SmsMessage findFirstOrThrow
   */
  export type SmsMessageFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SmsMessage
     */
    select?: SmsMessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SmsMessageInclude<ExtArgs> | null
    /**
     * Filter, which SmsMessage to fetch.
     */
    where?: SmsMessageWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SmsMessages to fetch.
     */
    orderBy?: SmsMessageOrderByWithRelationInput | SmsMessageOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for SmsMessages.
     */
    cursor?: SmsMessageWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SmsMessages from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` SmsMessages.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of SmsMessages.
     */
    distinct?: SmsMessageScalarFieldEnum | SmsMessageScalarFieldEnum[]
  }

  /**
   * SmsMessage findMany
   */
  export type SmsMessageFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SmsMessage
     */
    select?: SmsMessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SmsMessageInclude<ExtArgs> | null
    /**
     * Filter, which SmsMessages to fetch.
     */
    where?: SmsMessageWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of SmsMessages to fetch.
     */
    orderBy?: SmsMessageOrderByWithRelationInput | SmsMessageOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing SmsMessages.
     */
    cursor?: SmsMessageWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` SmsMessages from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` SmsMessages.
     */
    skip?: number
    distinct?: SmsMessageScalarFieldEnum | SmsMessageScalarFieldEnum[]
  }

  /**
   * SmsMessage create
   */
  export type SmsMessageCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SmsMessage
     */
    select?: SmsMessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SmsMessageInclude<ExtArgs> | null
    /**
     * The data needed to create a SmsMessage.
     */
    data: XOR<SmsMessageCreateInput, SmsMessageUncheckedCreateInput>
  }

  /**
   * SmsMessage createMany
   */
  export type SmsMessageCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many SmsMessages.
     */
    data: SmsMessageCreateManyInput | SmsMessageCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * SmsMessage createManyAndReturn
   */
  export type SmsMessageCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SmsMessage
     */
    select?: SmsMessageSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many SmsMessages.
     */
    data: SmsMessageCreateManyInput | SmsMessageCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SmsMessageIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * SmsMessage update
   */
  export type SmsMessageUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SmsMessage
     */
    select?: SmsMessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SmsMessageInclude<ExtArgs> | null
    /**
     * The data needed to update a SmsMessage.
     */
    data: XOR<SmsMessageUpdateInput, SmsMessageUncheckedUpdateInput>
    /**
     * Choose, which SmsMessage to update.
     */
    where: SmsMessageWhereUniqueInput
  }

  /**
   * SmsMessage updateMany
   */
  export type SmsMessageUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update SmsMessages.
     */
    data: XOR<SmsMessageUpdateManyMutationInput, SmsMessageUncheckedUpdateManyInput>
    /**
     * Filter which SmsMessages to update
     */
    where?: SmsMessageWhereInput
  }

  /**
   * SmsMessage upsert
   */
  export type SmsMessageUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SmsMessage
     */
    select?: SmsMessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SmsMessageInclude<ExtArgs> | null
    /**
     * The filter to search for the SmsMessage to update in case it exists.
     */
    where: SmsMessageWhereUniqueInput
    /**
     * In case the SmsMessage found by the `where` argument doesn't exist, create a new SmsMessage with this data.
     */
    create: XOR<SmsMessageCreateInput, SmsMessageUncheckedCreateInput>
    /**
     * In case the SmsMessage was found with the provided `where` argument, update it with this data.
     */
    update: XOR<SmsMessageUpdateInput, SmsMessageUncheckedUpdateInput>
  }

  /**
   * SmsMessage delete
   */
  export type SmsMessageDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SmsMessage
     */
    select?: SmsMessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SmsMessageInclude<ExtArgs> | null
    /**
     * Filter which SmsMessage to delete.
     */
    where: SmsMessageWhereUniqueInput
  }

  /**
   * SmsMessage deleteMany
   */
  export type SmsMessageDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which SmsMessages to delete
     */
    where?: SmsMessageWhereInput
  }

  /**
   * SmsMessage.sentByAdminUser
   */
  export type SmsMessage$sentByAdminUserArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AdminUser
     */
    select?: AdminUserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AdminUserInclude<ExtArgs> | null
    where?: AdminUserWhereInput
  }

  /**
   * SmsMessage without action
   */
  export type SmsMessageDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the SmsMessage
     */
    select?: SmsMessageSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: SmsMessageInclude<ExtArgs> | null
  }


  /**
   * Model Notification
   */

  export type AggregateNotification = {
    _count: NotificationCountAggregateOutputType | null
    _min: NotificationMinAggregateOutputType | null
    _max: NotificationMaxAggregateOutputType | null
  }

  export type NotificationMinAggregateOutputType = {
    id: string | null
    title: string | null
    body: string | null
    audience: $Enums.MessageAudience | null
    sentByAdminUserId: string | null
    createdAt: Date | null
  }

  export type NotificationMaxAggregateOutputType = {
    id: string | null
    title: string | null
    body: string | null
    audience: $Enums.MessageAudience | null
    sentByAdminUserId: string | null
    createdAt: Date | null
  }

  export type NotificationCountAggregateOutputType = {
    id: number
    title: number
    body: number
    audience: number
    sentByAdminUserId: number
    createdAt: number
    _all: number
  }


  export type NotificationMinAggregateInputType = {
    id?: true
    title?: true
    body?: true
    audience?: true
    sentByAdminUserId?: true
    createdAt?: true
  }

  export type NotificationMaxAggregateInputType = {
    id?: true
    title?: true
    body?: true
    audience?: true
    sentByAdminUserId?: true
    createdAt?: true
  }

  export type NotificationCountAggregateInputType = {
    id?: true
    title?: true
    body?: true
    audience?: true
    sentByAdminUserId?: true
    createdAt?: true
    _all?: true
  }

  export type NotificationAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Notification to aggregate.
     */
    where?: NotificationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Notifications to fetch.
     */
    orderBy?: NotificationOrderByWithRelationInput | NotificationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: NotificationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Notifications from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Notifications.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned Notifications
    **/
    _count?: true | NotificationCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: NotificationMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: NotificationMaxAggregateInputType
  }

  export type GetNotificationAggregateType<T extends NotificationAggregateArgs> = {
        [P in keyof T & keyof AggregateNotification]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateNotification[P]>
      : GetScalarType<T[P], AggregateNotification[P]>
  }




  export type NotificationGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: NotificationWhereInput
    orderBy?: NotificationOrderByWithAggregationInput | NotificationOrderByWithAggregationInput[]
    by: NotificationScalarFieldEnum[] | NotificationScalarFieldEnum
    having?: NotificationScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: NotificationCountAggregateInputType | true
    _min?: NotificationMinAggregateInputType
    _max?: NotificationMaxAggregateInputType
  }

  export type NotificationGroupByOutputType = {
    id: string
    title: string
    body: string
    audience: $Enums.MessageAudience
    sentByAdminUserId: string | null
    createdAt: Date
    _count: NotificationCountAggregateOutputType | null
    _min: NotificationMinAggregateOutputType | null
    _max: NotificationMaxAggregateOutputType | null
  }

  type GetNotificationGroupByPayload<T extends NotificationGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<NotificationGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof NotificationGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], NotificationGroupByOutputType[P]>
            : GetScalarType<T[P], NotificationGroupByOutputType[P]>
        }
      >
    >


  export type NotificationSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    body?: boolean
    audience?: boolean
    sentByAdminUserId?: boolean
    createdAt?: boolean
    sentByAdminUser?: boolean | Notification$sentByAdminUserArgs<ExtArgs>
    recipients?: boolean | Notification$recipientsArgs<ExtArgs>
    _count?: boolean | NotificationCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["notification"]>

  export type NotificationSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    title?: boolean
    body?: boolean
    audience?: boolean
    sentByAdminUserId?: boolean
    createdAt?: boolean
    sentByAdminUser?: boolean | Notification$sentByAdminUserArgs<ExtArgs>
  }, ExtArgs["result"]["notification"]>

  export type NotificationSelectScalar = {
    id?: boolean
    title?: boolean
    body?: boolean
    audience?: boolean
    sentByAdminUserId?: boolean
    createdAt?: boolean
  }

  export type NotificationInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    sentByAdminUser?: boolean | Notification$sentByAdminUserArgs<ExtArgs>
    recipients?: boolean | Notification$recipientsArgs<ExtArgs>
    _count?: boolean | NotificationCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type NotificationIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    sentByAdminUser?: boolean | Notification$sentByAdminUserArgs<ExtArgs>
  }

  export type $NotificationPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "Notification"
    objects: {
      sentByAdminUser: Prisma.$AdminUserPayload<ExtArgs> | null
      recipients: Prisma.$NotificationRecipientPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      title: string
      body: string
      audience: $Enums.MessageAudience
      sentByAdminUserId: string | null
      createdAt: Date
    }, ExtArgs["result"]["notification"]>
    composites: {}
  }

  type NotificationGetPayload<S extends boolean | null | undefined | NotificationDefaultArgs> = $Result.GetResult<Prisma.$NotificationPayload, S>

  type NotificationCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<NotificationFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: NotificationCountAggregateInputType | true
    }

  export interface NotificationDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['Notification'], meta: { name: 'Notification' } }
    /**
     * Find zero or one Notification that matches the filter.
     * @param {NotificationFindUniqueArgs} args - Arguments to find a Notification
     * @example
     * // Get one Notification
     * const notification = await prisma.notification.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends NotificationFindUniqueArgs>(args: SelectSubset<T, NotificationFindUniqueArgs<ExtArgs>>): Prisma__NotificationClient<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one Notification that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {NotificationFindUniqueOrThrowArgs} args - Arguments to find a Notification
     * @example
     * // Get one Notification
     * const notification = await prisma.notification.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends NotificationFindUniqueOrThrowArgs>(args: SelectSubset<T, NotificationFindUniqueOrThrowArgs<ExtArgs>>): Prisma__NotificationClient<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first Notification that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NotificationFindFirstArgs} args - Arguments to find a Notification
     * @example
     * // Get one Notification
     * const notification = await prisma.notification.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends NotificationFindFirstArgs>(args?: SelectSubset<T, NotificationFindFirstArgs<ExtArgs>>): Prisma__NotificationClient<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first Notification that matches the filter or
     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NotificationFindFirstOrThrowArgs} args - Arguments to find a Notification
     * @example
     * // Get one Notification
     * const notification = await prisma.notification.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends NotificationFindFirstOrThrowArgs>(args?: SelectSubset<T, NotificationFindFirstOrThrowArgs<ExtArgs>>): Prisma__NotificationClient<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more Notifications that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NotificationFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all Notifications
     * const notifications = await prisma.notification.findMany()
     * 
     * // Get first 10 Notifications
     * const notifications = await prisma.notification.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const notificationWithIdOnly = await prisma.notification.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends NotificationFindManyArgs>(args?: SelectSubset<T, NotificationFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a Notification.
     * @param {NotificationCreateArgs} args - Arguments to create a Notification.
     * @example
     * // Create one Notification
     * const Notification = await prisma.notification.create({
     *   data: {
     *     // ... data to create a Notification
     *   }
     * })
     * 
     */
    create<T extends NotificationCreateArgs>(args: SelectSubset<T, NotificationCreateArgs<ExtArgs>>): Prisma__NotificationClient<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many Notifications.
     * @param {NotificationCreateManyArgs} args - Arguments to create many Notifications.
     * @example
     * // Create many Notifications
     * const notification = await prisma.notification.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends NotificationCreateManyArgs>(args?: SelectSubset<T, NotificationCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many Notifications and returns the data saved in the database.
     * @param {NotificationCreateManyAndReturnArgs} args - Arguments to create many Notifications.
     * @example
     * // Create many Notifications
     * const notification = await prisma.notification.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many Notifications and only return the `id`
     * const notificationWithIdOnly = await prisma.notification.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends NotificationCreateManyAndReturnArgs>(args?: SelectSubset<T, NotificationCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a Notification.
     * @param {NotificationDeleteArgs} args - Arguments to delete one Notification.
     * @example
     * // Delete one Notification
     * const Notification = await prisma.notification.delete({
     *   where: {
     *     // ... filter to delete one Notification
     *   }
     * })
     * 
     */
    delete<T extends NotificationDeleteArgs>(args: SelectSubset<T, NotificationDeleteArgs<ExtArgs>>): Prisma__NotificationClient<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one Notification.
     * @param {NotificationUpdateArgs} args - Arguments to update one Notification.
     * @example
     * // Update one Notification
     * const notification = await prisma.notification.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends NotificationUpdateArgs>(args: SelectSubset<T, NotificationUpdateArgs<ExtArgs>>): Prisma__NotificationClient<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more Notifications.
     * @param {NotificationDeleteManyArgs} args - Arguments to filter Notifications to delete.
     * @example
     * // Delete a few Notifications
     * const { count } = await prisma.notification.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends NotificationDeleteManyArgs>(args?: SelectSubset<T, NotificationDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more Notifications.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NotificationUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many Notifications
     * const notification = await prisma.notification.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends NotificationUpdateManyArgs>(args: SelectSubset<T, NotificationUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one Notification.
     * @param {NotificationUpsertArgs} args - Arguments to update or create a Notification.
     * @example
     * // Update or create a Notification
     * const notification = await prisma.notification.upsert({
     *   create: {
     *     // ... data to create a Notification
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the Notification we want to update
     *   }
     * })
     */
    upsert<T extends NotificationUpsertArgs>(args: SelectSubset<T, NotificationUpsertArgs<ExtArgs>>): Prisma__NotificationClient<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of Notifications.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NotificationCountArgs} args - Arguments to filter Notifications to count.
     * @example
     * // Count the number of Notifications
     * const count = await prisma.notification.count({
     *   where: {
     *     // ... the filter for the Notifications we want to count
     *   }
     * })
    **/
    count<T extends NotificationCountArgs>(
      args?: Subset<T, NotificationCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], NotificationCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a Notification.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NotificationAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
     * @example
     * // Ordered by age ascending
     * // Where email contains prisma.io
     * // Limited to the 10 users
     * const aggregations = await prisma.user.aggregate({
     *   _avg: {
     *     age: true,
     *   },
     *   where: {
     *     email: {
     *       contains: "prisma.io",
     *     },
     *   },
     *   orderBy: {
     *     age: "asc",
     *   },
     *   take: 10,
     * })
    **/
    aggregate<T extends NotificationAggregateArgs>(args: Subset<T, NotificationAggregateArgs>): Prisma.PrismaPromise<GetNotificationAggregateType<T>>

    /**
     * Group by Notification.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NotificationGroupByArgs} args - Group by arguments.
     * @example
     * // Group by city, order by createdAt, get count
     * const result = await prisma.user.groupBy({
     *   by: ['city', 'createdAt'],
     *   orderBy: {
     *     createdAt: true
     *   },
     *   _count: {
     *     _all: true
     *   },
     * })
     * 
    **/
    groupBy<
      T extends NotificationGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: NotificationGroupByArgs['orderBy'] }
        : { orderBy?: NotificationGroupByArgs['orderBy'] },
      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
      ByFields extends MaybeTupleToUnion<T['by']>,
      ByValid extends Has<ByFields, OrderFields>,
      HavingFields extends GetHavingFields<T['having']>,
      HavingValid extends Has<ByFields, HavingFields>,
      ByEmpty extends T['by'] extends never[] ? True : False,
      InputErrors extends ByEmpty extends True
      ? `Error: "by" must not be empty.`
      : HavingValid extends False
      ? {
          [P in HavingFields]: P extends ByFields
            ? never
            : P extends string
            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
            : [
                Error,
                'Field ',
                P,
                ` in "having" needs to be provided in "by"`,
              ]
        }[HavingFields]
      : 'take' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "take", you also need to provide "orderBy"'
      : 'skip' extends Keys<T>
      ? 'orderBy' extends Keys<T>
        ? ByValid extends True
          ? {}
          : {
              [P in OrderFields]: P extends ByFields
                ? never
                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
            }[OrderFields]
        : 'Error: If you provide "skip", you also need to provide "orderBy"'
      : ByValid extends True
      ? {}
      : {
          [P in OrderFields]: P extends ByFields
            ? never
            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
        }[OrderFields]
    >(args: SubsetIntersection<T, NotificationGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetNotificationGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the Notification model
   */
  readonly fields: NotificationFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for Notification.
   * Why is this prefixed with `Prisma__`?
   * Because we want to prevent naming conflicts as mentioned in
   * https://github.com/prisma/prisma-client-js/issues/707
   */
  export interface Prisma__NotificationClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    sentByAdminUser<T extends Notification$sentByAdminUserArgs<ExtArgs> = {}>(args?: Subset<T, Notification$sentByAdminUserArgs<ExtArgs>>): Prisma__AdminUserClient<$Result.GetResult<Prisma.$AdminUserPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    recipients<T extends Notification$recipientsArgs<ExtArgs> = {}>(args?: Subset<T, Notification$recipientsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$NotificationRecipientPayload<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 Notification model
   */ 
  interface NotificationFieldRefs {
    readonly id: FieldRef<"Notification", 'String'>
    readonly title: FieldRef<"Notification", 'String'>
    readonly body: FieldRef<"Notification", 'String'>
    readonly audience: FieldRef<"Notification", 'MessageAudience'>
    readonly sentByAdminUserId: FieldRef<"Notification", 'String'>
    readonly createdAt: FieldRef<"Notification", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * Notification findUnique
   */
  export type NotificationFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
    /**
     * Filter, which Notification to fetch.
     */
    where: NotificationWhereUniqueInput
  }

  /**
   * Notification findUniqueOrThrow
   */
  export type NotificationFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
    /**
     * Filter, which Notification to fetch.
     */
    where: NotificationWhereUniqueInput
  }

  /**
   * Notification findFirst
   */
  export type NotificationFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
    /**
     * Filter, which Notification to fetch.
     */
    where?: NotificationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Notifications to fetch.
     */
    orderBy?: NotificationOrderByWithRelationInput | NotificationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Notifications.
     */
    cursor?: NotificationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Notifications from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Notifications.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Notifications.
     */
    distinct?: NotificationScalarFieldEnum | NotificationScalarFieldEnum[]
  }

  /**
   * Notification findFirstOrThrow
   */
  export type NotificationFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
    /**
     * Filter, which Notification to fetch.
     */
    where?: NotificationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Notifications to fetch.
     */
    orderBy?: NotificationOrderByWithRelationInput | NotificationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for Notifications.
     */
    cursor?: NotificationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Notifications from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Notifications.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of Notifications.
     */
    distinct?: NotificationScalarFieldEnum | NotificationScalarFieldEnum[]
  }

  /**
   * Notification findMany
   */
  export type NotificationFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
    /**
     * Filter, which Notifications to fetch.
     */
    where?: NotificationWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of Notifications to fetch.
     */
    orderBy?: NotificationOrderByWithRelationInput | NotificationOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing Notifications.
     */
    cursor?: NotificationWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` Notifications from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` Notifications.
     */
    skip?: number
    distinct?: NotificationScalarFieldEnum | NotificationScalarFieldEnum[]
  }

  /**
   * Notification create
   */
  export type NotificationCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
    /**
     * The data needed to create a Notification.
     */
    data: XOR<NotificationCreateInput, NotificationUncheckedCreateInput>
  }

  /**
   * Notification createMany
   */
  export type NotificationCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many Notifications.
     */
    data: NotificationCreateManyInput | NotificationCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * Notification createManyAndReturn
   */
  export type NotificationCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many Notifications.
     */
    data: NotificationCreateManyInput | NotificationCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * Notification update
   */
  export type NotificationUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
    /**
     * The data needed to update a Notification.
     */
    data: XOR<NotificationUpdateInput, NotificationUncheckedUpdateInput>
    /**
     * Choose, which Notification to update.
     */
    where: NotificationWhereUniqueInput
  }

  /**
   * Notification updateMany
   */
  export type NotificationUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update Notifications.
     */
    data: XOR<NotificationUpdateManyMutationInput, NotificationUncheckedUpdateManyInput>
    /**
     * Filter which Notifications to update
     */
    where?: NotificationWhereInput
  }

  /**
   * Notification upsert
   */
  export type NotificationUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
    /**
     * The filter to search for the Notification to update in case it exists.
     */
    where: NotificationWhereUniqueInput
    /**
     * In case the Notification found by the `where` argument doesn't exist, create a new Notification with this data.
     */
    create: XOR<NotificationCreateInput, NotificationUncheckedCreateInput>
    /**
     * In case the Notification was found with the provided `where` argument, update it with this data.
     */
    update: XOR<NotificationUpdateInput, NotificationUncheckedUpdateInput>
  }

  /**
   * Notification delete
   */
  export type NotificationDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
    /**
     * Filter which Notification to delete.
     */
    where: NotificationWhereUniqueInput
  }

  /**
   * Notification deleteMany
   */
  export type NotificationDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which Notifications to delete
     */
    where?: NotificationWhereInput
  }

  /**
   * Notification.sentByAdminUser
   */
  export type Notification$sentByAdminUserArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AdminUser
     */
    select?: AdminUserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AdminUserInclude<ExtArgs> | null
    where?: AdminUserWhereInput
  }

  /**
   * Notification.recipients
   */
  export type Notification$recipientsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NotificationRecipient
     */
    select?: NotificationRecipientSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationRecipientInclude<ExtArgs> | null
    where?: NotificationRecipientWhereInput
    orderBy?: NotificationRecipientOrderByWithRelationInput | NotificationRecipientOrderByWithRelationInput[]
    cursor?: NotificationRecipientWhereUniqueInput
    take?: number
    skip?: number
    distinct?: NotificationRecipientScalarFieldEnum | NotificationRecipientScalarFieldEnum[]
  }

  /**
   * Notification without action
   */
  export type NotificationDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Notification
     */
    select?: NotificationSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationInclude<ExtArgs> | null
  }


  /**
   * Model NotificationRecipient
   */

  export type AggregateNotificationRecipient = {
    _count: NotificationRecipientCountAggregateOutputType | null
    _min: NotificationRecipientMinAggregateOutputType | null
    _max: NotificationRecipientMaxAggregateOutputType | null
  }

  export type NotificationRecipientMinAggregateOutputType = {
    id: string | null
    notificationId: string | null
    customerId: string | null
    readAt: Date | null
  }

  export type NotificationRecipientMaxAggregateOutputType = {
    id: string | null
    notificationId: string | null
    customerId: string | null
    readAt: Date | null
  }

  export type NotificationRecipientCountAggregateOutputType = {
    id: number
    notificationId: number
    customerId: number
    readAt: number
    _all: number
  }


  export type NotificationRecipientMinAggregateInputType = {
    id?: true
    notificationId?: true
    customerId?: true
    readAt?: true
  }

  export type NotificationRecipientMaxAggregateInputType = {
    id?: true
    notificationId?: true
    customerId?: true
    readAt?: true
  }

  export type NotificationRecipientCountAggregateInputType = {
    id?: true
    notificationId?: true
    customerId?: true
    readAt?: true
    _all?: true
  }

  export type NotificationRecipientAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which NotificationRecipient to aggregate.
     */
    where?: NotificationRecipientWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of NotificationRecipients to fetch.
     */
    orderBy?: NotificationRecipientOrderByWithRelationInput | NotificationRecipientOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: NotificationRecipientWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` NotificationRecipients from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` NotificationRecipients.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned NotificationRecipients
    **/
    _count?: true | NotificationRecipientCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: NotificationRecipientMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: NotificationRecipientMaxAggregateInputType
  }

  export type GetNotificationRecipientAggregateType<T extends NotificationRecipientAggregateArgs> = {
        [P in keyof T & keyof AggregateNotificationRecipient]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateNotificationRecipient[P]>
      : GetScalarType<T[P], AggregateNotificationRecipient[P]>
  }




  export type NotificationRecipientGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: NotificationRecipientWhereInput
    orderBy?: NotificationRecipientOrderByWithAggregationInput | NotificationRecipientOrderByWithAggregationInput[]
    by: NotificationRecipientScalarFieldEnum[] | NotificationRecipientScalarFieldEnum
    having?: NotificationRecipientScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: NotificationRecipientCountAggregateInputType | true
    _min?: NotificationRecipientMinAggregateInputType
    _max?: NotificationRecipientMaxAggregateInputType
  }

  export type NotificationRecipientGroupByOutputType = {
    id: string
    notificationId: string
    customerId: string
    readAt: Date | null
    _count: NotificationRecipientCountAggregateOutputType | null
    _min: NotificationRecipientMinAggregateOutputType | null
    _max: NotificationRecipientMaxAggregateOutputType | null
  }

  type GetNotificationRecipientGroupByPayload<T extends NotificationRecipientGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<NotificationRecipientGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof NotificationRecipientGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], NotificationRecipientGroupByOutputType[P]>
            : GetScalarType<T[P], NotificationRecipientGroupByOutputType[P]>
        }
      >
    >


  export type NotificationRecipientSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    notificationId?: boolean
    customerId?: boolean
    readAt?: boolean
    notification?: boolean | NotificationDefaultArgs<ExtArgs>
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["notificationRecipient"]>

  export type NotificationRecipientSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    notificationId?: boolean
    customerId?: boolean
    readAt?: boolean
    notification?: boolean | NotificationDefaultArgs<ExtArgs>
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["notificationRecipient"]>

  export type NotificationRecipientSelectScalar = {
    id?: boolean
    notificationId?: boolean
    customerId?: boolean
    readAt?: boolean
  }

  export type NotificationRecipientInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    notification?: boolean | NotificationDefaultArgs<ExtArgs>
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
  }
  export type NotificationRecipientIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    notification?: boolean | NotificationDefaultArgs<ExtArgs>
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
  }

  export type $NotificationRecipientPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "NotificationRecipient"
    objects: {
      notification: Prisma.$NotificationPayload<ExtArgs>
      customer: Prisma.$CustomerPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      notificationId: string
      customerId: string
      readAt: Date | null
    }, ExtArgs["result"]["notificationRecipient"]>
    composites: {}
  }

  type NotificationRecipientGetPayload<S extends boolean | null | undefined | NotificationRecipientDefaultArgs> = $Result.GetResult<Prisma.$NotificationRecipientPayload, S>

  type NotificationRecipientCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<NotificationRecipientFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: NotificationRecipientCountAggregateInputType | true
    }

  export interface NotificationRecipientDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['NotificationRecipient'], meta: { name: 'NotificationRecipient' } }
    /**
     * Find zero or one NotificationRecipient that matches the filter.
     * @param {NotificationRecipientFindUniqueArgs} args - Arguments to find a NotificationRecipient
     * @example
     * // Get one NotificationRecipient
     * const notificationRecipient = await prisma.notificationRecipient.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends NotificationRecipientFindUniqueArgs>(args: SelectSubset<T, NotificationRecipientFindUniqueArgs<ExtArgs>>): Prisma__NotificationRecipientClient<$Result.GetResult<Prisma.$NotificationRecipientPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one NotificationRecipient that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {NotificationRecipientFindUniqueOrThrowArgs} args - Arguments to find a NotificationRecipient
     * @example
     * // Get one NotificationRecipient
     * const notificationRecipient = await prisma.notificationRecipient.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends NotificationRecipientFindUniqueOrThrowArgs>(args: SelectSubset<T, NotificationRecipientFindUniqueOrThrowArgs<ExtArgs>>): Prisma__NotificationRecipientClient<$Result.GetResult<Prisma.$NotificationRecipientPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first NotificationRecipient that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NotificationRecipientFindFirstArgs} args - Arguments to find a NotificationRecipient
     * @example
     * // Get one NotificationRecipient
     * const notificationRecipient = await prisma.notificationRecipient.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends NotificationRecipientFindFirstArgs>(args?: SelectSubset<T, NotificationRecipientFindFirstArgs<ExtArgs>>): Prisma__NotificationRecipientClient<$Result.GetResult<Prisma.$NotificationRecipientPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first NotificationRecipient 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 {NotificationRecipientFindFirstOrThrowArgs} args - Arguments to find a NotificationRecipient
     * @example
     * // Get one NotificationRecipient
     * const notificationRecipient = await prisma.notificationRecipient.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends NotificationRecipientFindFirstOrThrowArgs>(args?: SelectSubset<T, NotificationRecipientFindFirstOrThrowArgs<ExtArgs>>): Prisma__NotificationRecipientClient<$Result.GetResult<Prisma.$NotificationRecipientPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more NotificationRecipients that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NotificationRecipientFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all NotificationRecipients
     * const notificationRecipients = await prisma.notificationRecipient.findMany()
     * 
     * // Get first 10 NotificationRecipients
     * const notificationRecipients = await prisma.notificationRecipient.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const notificationRecipientWithIdOnly = await prisma.notificationRecipient.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends NotificationRecipientFindManyArgs>(args?: SelectSubset<T, NotificationRecipientFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$NotificationRecipientPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a NotificationRecipient.
     * @param {NotificationRecipientCreateArgs} args - Arguments to create a NotificationRecipient.
     * @example
     * // Create one NotificationRecipient
     * const NotificationRecipient = await prisma.notificationRecipient.create({
     *   data: {
     *     // ... data to create a NotificationRecipient
     *   }
     * })
     * 
     */
    create<T extends NotificationRecipientCreateArgs>(args: SelectSubset<T, NotificationRecipientCreateArgs<ExtArgs>>): Prisma__NotificationRecipientClient<$Result.GetResult<Prisma.$NotificationRecipientPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many NotificationRecipients.
     * @param {NotificationRecipientCreateManyArgs} args - Arguments to create many NotificationRecipients.
     * @example
     * // Create many NotificationRecipients
     * const notificationRecipient = await prisma.notificationRecipient.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends NotificationRecipientCreateManyArgs>(args?: SelectSubset<T, NotificationRecipientCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many NotificationRecipients and returns the data saved in the database.
     * @param {NotificationRecipientCreateManyAndReturnArgs} args - Arguments to create many NotificationRecipients.
     * @example
     * // Create many NotificationRecipients
     * const notificationRecipient = await prisma.notificationRecipient.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many NotificationRecipients and only return the `id`
     * const notificationRecipientWithIdOnly = await prisma.notificationRecipient.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends NotificationRecipientCreateManyAndReturnArgs>(args?: SelectSubset<T, NotificationRecipientCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$NotificationRecipientPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a NotificationRecipient.
     * @param {NotificationRecipientDeleteArgs} args - Arguments to delete one NotificationRecipient.
     * @example
     * // Delete one NotificationRecipient
     * const NotificationRecipient = await prisma.notificationRecipient.delete({
     *   where: {
     *     // ... filter to delete one NotificationRecipient
     *   }
     * })
     * 
     */
    delete<T extends NotificationRecipientDeleteArgs>(args: SelectSubset<T, NotificationRecipientDeleteArgs<ExtArgs>>): Prisma__NotificationRecipientClient<$Result.GetResult<Prisma.$NotificationRecipientPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one NotificationRecipient.
     * @param {NotificationRecipientUpdateArgs} args - Arguments to update one NotificationRecipient.
     * @example
     * // Update one NotificationRecipient
     * const notificationRecipient = await prisma.notificationRecipient.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends NotificationRecipientUpdateArgs>(args: SelectSubset<T, NotificationRecipientUpdateArgs<ExtArgs>>): Prisma__NotificationRecipientClient<$Result.GetResult<Prisma.$NotificationRecipientPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more NotificationRecipients.
     * @param {NotificationRecipientDeleteManyArgs} args - Arguments to filter NotificationRecipients to delete.
     * @example
     * // Delete a few NotificationRecipients
     * const { count } = await prisma.notificationRecipient.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends NotificationRecipientDeleteManyArgs>(args?: SelectSubset<T, NotificationRecipientDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more NotificationRecipients.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NotificationRecipientUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many NotificationRecipients
     * const notificationRecipient = await prisma.notificationRecipient.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends NotificationRecipientUpdateManyArgs>(args: SelectSubset<T, NotificationRecipientUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one NotificationRecipient.
     * @param {NotificationRecipientUpsertArgs} args - Arguments to update or create a NotificationRecipient.
     * @example
     * // Update or create a NotificationRecipient
     * const notificationRecipient = await prisma.notificationRecipient.upsert({
     *   create: {
     *     // ... data to create a NotificationRecipient
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the NotificationRecipient we want to update
     *   }
     * })
     */
    upsert<T extends NotificationRecipientUpsertArgs>(args: SelectSubset<T, NotificationRecipientUpsertArgs<ExtArgs>>): Prisma__NotificationRecipientClient<$Result.GetResult<Prisma.$NotificationRecipientPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of NotificationRecipients.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NotificationRecipientCountArgs} args - Arguments to filter NotificationRecipients to count.
     * @example
     * // Count the number of NotificationRecipients
     * const count = await prisma.notificationRecipient.count({
     *   where: {
     *     // ... the filter for the NotificationRecipients we want to count
     *   }
     * })
    **/
    count<T extends NotificationRecipientCountArgs>(
      args?: Subset<T, NotificationRecipientCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], NotificationRecipientCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a NotificationRecipient.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NotificationRecipientAggregateArgs} 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 NotificationRecipientAggregateArgs>(args: Subset<T, NotificationRecipientAggregateArgs>): Prisma.PrismaPromise<GetNotificationRecipientAggregateType<T>>

    /**
     * Group by NotificationRecipient.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NotificationRecipientGroupByArgs} 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 NotificationRecipientGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: NotificationRecipientGroupByArgs['orderBy'] }
        : { orderBy?: NotificationRecipientGroupByArgs['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, NotificationRecipientGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetNotificationRecipientGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the NotificationRecipient model
   */
  readonly fields: NotificationRecipientFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for NotificationRecipient.
   * 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__NotificationRecipientClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    notification<T extends NotificationDefaultArgs<ExtArgs> = {}>(args?: Subset<T, NotificationDefaultArgs<ExtArgs>>): Prisma__NotificationClient<$Result.GetResult<Prisma.$NotificationPayload<ExtArgs>, T, "findUniqueOrThrow"> | Null, Null, ExtArgs>
    customer<T extends CustomerDefaultArgs<ExtArgs> = {}>(args?: Subset<T, CustomerDefaultArgs<ExtArgs>>): Prisma__CustomerClient<$Result.GetResult<Prisma.$CustomerPayload<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 NotificationRecipient model
   */ 
  interface NotificationRecipientFieldRefs {
    readonly id: FieldRef<"NotificationRecipient", 'String'>
    readonly notificationId: FieldRef<"NotificationRecipient", 'String'>
    readonly customerId: FieldRef<"NotificationRecipient", 'String'>
    readonly readAt: FieldRef<"NotificationRecipient", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * NotificationRecipient findUnique
   */
  export type NotificationRecipientFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NotificationRecipient
     */
    select?: NotificationRecipientSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationRecipientInclude<ExtArgs> | null
    /**
     * Filter, which NotificationRecipient to fetch.
     */
    where: NotificationRecipientWhereUniqueInput
  }

  /**
   * NotificationRecipient findUniqueOrThrow
   */
  export type NotificationRecipientFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NotificationRecipient
     */
    select?: NotificationRecipientSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationRecipientInclude<ExtArgs> | null
    /**
     * Filter, which NotificationRecipient to fetch.
     */
    where: NotificationRecipientWhereUniqueInput
  }

  /**
   * NotificationRecipient findFirst
   */
  export type NotificationRecipientFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NotificationRecipient
     */
    select?: NotificationRecipientSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationRecipientInclude<ExtArgs> | null
    /**
     * Filter, which NotificationRecipient to fetch.
     */
    where?: NotificationRecipientWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of NotificationRecipients to fetch.
     */
    orderBy?: NotificationRecipientOrderByWithRelationInput | NotificationRecipientOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for NotificationRecipients.
     */
    cursor?: NotificationRecipientWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` NotificationRecipients from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` NotificationRecipients.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of NotificationRecipients.
     */
    distinct?: NotificationRecipientScalarFieldEnum | NotificationRecipientScalarFieldEnum[]
  }

  /**
   * NotificationRecipient findFirstOrThrow
   */
  export type NotificationRecipientFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NotificationRecipient
     */
    select?: NotificationRecipientSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationRecipientInclude<ExtArgs> | null
    /**
     * Filter, which NotificationRecipient to fetch.
     */
    where?: NotificationRecipientWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of NotificationRecipients to fetch.
     */
    orderBy?: NotificationRecipientOrderByWithRelationInput | NotificationRecipientOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for NotificationRecipients.
     */
    cursor?: NotificationRecipientWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` NotificationRecipients from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` NotificationRecipients.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of NotificationRecipients.
     */
    distinct?: NotificationRecipientScalarFieldEnum | NotificationRecipientScalarFieldEnum[]
  }

  /**
   * NotificationRecipient findMany
   */
  export type NotificationRecipientFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NotificationRecipient
     */
    select?: NotificationRecipientSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationRecipientInclude<ExtArgs> | null
    /**
     * Filter, which NotificationRecipients to fetch.
     */
    where?: NotificationRecipientWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of NotificationRecipients to fetch.
     */
    orderBy?: NotificationRecipientOrderByWithRelationInput | NotificationRecipientOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing NotificationRecipients.
     */
    cursor?: NotificationRecipientWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` NotificationRecipients from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` NotificationRecipients.
     */
    skip?: number
    distinct?: NotificationRecipientScalarFieldEnum | NotificationRecipientScalarFieldEnum[]
  }

  /**
   * NotificationRecipient create
   */
  export type NotificationRecipientCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NotificationRecipient
     */
    select?: NotificationRecipientSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationRecipientInclude<ExtArgs> | null
    /**
     * The data needed to create a NotificationRecipient.
     */
    data: XOR<NotificationRecipientCreateInput, NotificationRecipientUncheckedCreateInput>
  }

  /**
   * NotificationRecipient createMany
   */
  export type NotificationRecipientCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many NotificationRecipients.
     */
    data: NotificationRecipientCreateManyInput | NotificationRecipientCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * NotificationRecipient createManyAndReturn
   */
  export type NotificationRecipientCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NotificationRecipient
     */
    select?: NotificationRecipientSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many NotificationRecipients.
     */
    data: NotificationRecipientCreateManyInput | NotificationRecipientCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationRecipientIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * NotificationRecipient update
   */
  export type NotificationRecipientUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NotificationRecipient
     */
    select?: NotificationRecipientSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationRecipientInclude<ExtArgs> | null
    /**
     * The data needed to update a NotificationRecipient.
     */
    data: XOR<NotificationRecipientUpdateInput, NotificationRecipientUncheckedUpdateInput>
    /**
     * Choose, which NotificationRecipient to update.
     */
    where: NotificationRecipientWhereUniqueInput
  }

  /**
   * NotificationRecipient updateMany
   */
  export type NotificationRecipientUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update NotificationRecipients.
     */
    data: XOR<NotificationRecipientUpdateManyMutationInput, NotificationRecipientUncheckedUpdateManyInput>
    /**
     * Filter which NotificationRecipients to update
     */
    where?: NotificationRecipientWhereInput
  }

  /**
   * NotificationRecipient upsert
   */
  export type NotificationRecipientUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NotificationRecipient
     */
    select?: NotificationRecipientSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationRecipientInclude<ExtArgs> | null
    /**
     * The filter to search for the NotificationRecipient to update in case it exists.
     */
    where: NotificationRecipientWhereUniqueInput
    /**
     * In case the NotificationRecipient found by the `where` argument doesn't exist, create a new NotificationRecipient with this data.
     */
    create: XOR<NotificationRecipientCreateInput, NotificationRecipientUncheckedCreateInput>
    /**
     * In case the NotificationRecipient was found with the provided `where` argument, update it with this data.
     */
    update: XOR<NotificationRecipientUpdateInput, NotificationRecipientUncheckedUpdateInput>
  }

  /**
   * NotificationRecipient delete
   */
  export type NotificationRecipientDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NotificationRecipient
     */
    select?: NotificationRecipientSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationRecipientInclude<ExtArgs> | null
    /**
     * Filter which NotificationRecipient to delete.
     */
    where: NotificationRecipientWhereUniqueInput
  }

  /**
   * NotificationRecipient deleteMany
   */
  export type NotificationRecipientDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which NotificationRecipients to delete
     */
    where?: NotificationRecipientWhereInput
  }

  /**
   * NotificationRecipient without action
   */
  export type NotificationRecipientDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NotificationRecipient
     */
    select?: NotificationRecipientSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: NotificationRecipientInclude<ExtArgs> | null
  }


  /**
   * Model NewsletterSubscriber
   */

  export type AggregateNewsletterSubscriber = {
    _count: NewsletterSubscriberCountAggregateOutputType | null
    _min: NewsletterSubscriberMinAggregateOutputType | null
    _max: NewsletterSubscriberMaxAggregateOutputType | null
  }

  export type NewsletterSubscriberMinAggregateOutputType = {
    id: string | null
    email: string | null
    mobile: string | null
    createdAt: Date | null
  }

  export type NewsletterSubscriberMaxAggregateOutputType = {
    id: string | null
    email: string | null
    mobile: string | null
    createdAt: Date | null
  }

  export type NewsletterSubscriberCountAggregateOutputType = {
    id: number
    email: number
    mobile: number
    createdAt: number
    _all: number
  }


  export type NewsletterSubscriberMinAggregateInputType = {
    id?: true
    email?: true
    mobile?: true
    createdAt?: true
  }

  export type NewsletterSubscriberMaxAggregateInputType = {
    id?: true
    email?: true
    mobile?: true
    createdAt?: true
  }

  export type NewsletterSubscriberCountAggregateInputType = {
    id?: true
    email?: true
    mobile?: true
    createdAt?: true
    _all?: true
  }

  export type NewsletterSubscriberAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which NewsletterSubscriber to aggregate.
     */
    where?: NewsletterSubscriberWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of NewsletterSubscribers to fetch.
     */
    orderBy?: NewsletterSubscriberOrderByWithRelationInput | NewsletterSubscriberOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: NewsletterSubscriberWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` NewsletterSubscribers from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` NewsletterSubscribers.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned NewsletterSubscribers
    **/
    _count?: true | NewsletterSubscriberCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: NewsletterSubscriberMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: NewsletterSubscriberMaxAggregateInputType
  }

  export type GetNewsletterSubscriberAggregateType<T extends NewsletterSubscriberAggregateArgs> = {
        [P in keyof T & keyof AggregateNewsletterSubscriber]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateNewsletterSubscriber[P]>
      : GetScalarType<T[P], AggregateNewsletterSubscriber[P]>
  }




  export type NewsletterSubscriberGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: NewsletterSubscriberWhereInput
    orderBy?: NewsletterSubscriberOrderByWithAggregationInput | NewsletterSubscriberOrderByWithAggregationInput[]
    by: NewsletterSubscriberScalarFieldEnum[] | NewsletterSubscriberScalarFieldEnum
    having?: NewsletterSubscriberScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: NewsletterSubscriberCountAggregateInputType | true
    _min?: NewsletterSubscriberMinAggregateInputType
    _max?: NewsletterSubscriberMaxAggregateInputType
  }

  export type NewsletterSubscriberGroupByOutputType = {
    id: string
    email: string | null
    mobile: string | null
    createdAt: Date
    _count: NewsletterSubscriberCountAggregateOutputType | null
    _min: NewsletterSubscriberMinAggregateOutputType | null
    _max: NewsletterSubscriberMaxAggregateOutputType | null
  }

  type GetNewsletterSubscriberGroupByPayload<T extends NewsletterSubscriberGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<NewsletterSubscriberGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof NewsletterSubscriberGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], NewsletterSubscriberGroupByOutputType[P]>
            : GetScalarType<T[P], NewsletterSubscriberGroupByOutputType[P]>
        }
      >
    >


  export type NewsletterSubscriberSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    email?: boolean
    mobile?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["newsletterSubscriber"]>

  export type NewsletterSubscriberSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    email?: boolean
    mobile?: boolean
    createdAt?: boolean
  }, ExtArgs["result"]["newsletterSubscriber"]>

  export type NewsletterSubscriberSelectScalar = {
    id?: boolean
    email?: boolean
    mobile?: boolean
    createdAt?: boolean
  }


  export type $NewsletterSubscriberPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "NewsletterSubscriber"
    objects: {}
    scalars: $Extensions.GetPayloadResult<{
      id: string
      email: string | null
      mobile: string | null
      createdAt: Date
    }, ExtArgs["result"]["newsletterSubscriber"]>
    composites: {}
  }

  type NewsletterSubscriberGetPayload<S extends boolean | null | undefined | NewsletterSubscriberDefaultArgs> = $Result.GetResult<Prisma.$NewsletterSubscriberPayload, S>

  type NewsletterSubscriberCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<NewsletterSubscriberFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: NewsletterSubscriberCountAggregateInputType | true
    }

  export interface NewsletterSubscriberDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['NewsletterSubscriber'], meta: { name: 'NewsletterSubscriber' } }
    /**
     * Find zero or one NewsletterSubscriber that matches the filter.
     * @param {NewsletterSubscriberFindUniqueArgs} args - Arguments to find a NewsletterSubscriber
     * @example
     * // Get one NewsletterSubscriber
     * const newsletterSubscriber = await prisma.newsletterSubscriber.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends NewsletterSubscriberFindUniqueArgs>(args: SelectSubset<T, NewsletterSubscriberFindUniqueArgs<ExtArgs>>): Prisma__NewsletterSubscriberClient<$Result.GetResult<Prisma.$NewsletterSubscriberPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one NewsletterSubscriber that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {NewsletterSubscriberFindUniqueOrThrowArgs} args - Arguments to find a NewsletterSubscriber
     * @example
     * // Get one NewsletterSubscriber
     * const newsletterSubscriber = await prisma.newsletterSubscriber.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends NewsletterSubscriberFindUniqueOrThrowArgs>(args: SelectSubset<T, NewsletterSubscriberFindUniqueOrThrowArgs<ExtArgs>>): Prisma__NewsletterSubscriberClient<$Result.GetResult<Prisma.$NewsletterSubscriberPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first NewsletterSubscriber that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NewsletterSubscriberFindFirstArgs} args - Arguments to find a NewsletterSubscriber
     * @example
     * // Get one NewsletterSubscriber
     * const newsletterSubscriber = await prisma.newsletterSubscriber.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends NewsletterSubscriberFindFirstArgs>(args?: SelectSubset<T, NewsletterSubscriberFindFirstArgs<ExtArgs>>): Prisma__NewsletterSubscriberClient<$Result.GetResult<Prisma.$NewsletterSubscriberPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first NewsletterSubscriber 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 {NewsletterSubscriberFindFirstOrThrowArgs} args - Arguments to find a NewsletterSubscriber
     * @example
     * // Get one NewsletterSubscriber
     * const newsletterSubscriber = await prisma.newsletterSubscriber.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends NewsletterSubscriberFindFirstOrThrowArgs>(args?: SelectSubset<T, NewsletterSubscriberFindFirstOrThrowArgs<ExtArgs>>): Prisma__NewsletterSubscriberClient<$Result.GetResult<Prisma.$NewsletterSubscriberPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more NewsletterSubscribers that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NewsletterSubscriberFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all NewsletterSubscribers
     * const newsletterSubscribers = await prisma.newsletterSubscriber.findMany()
     * 
     * // Get first 10 NewsletterSubscribers
     * const newsletterSubscribers = await prisma.newsletterSubscriber.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const newsletterSubscriberWithIdOnly = await prisma.newsletterSubscriber.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends NewsletterSubscriberFindManyArgs>(args?: SelectSubset<T, NewsletterSubscriberFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$NewsletterSubscriberPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a NewsletterSubscriber.
     * @param {NewsletterSubscriberCreateArgs} args - Arguments to create a NewsletterSubscriber.
     * @example
     * // Create one NewsletterSubscriber
     * const NewsletterSubscriber = await prisma.newsletterSubscriber.create({
     *   data: {
     *     // ... data to create a NewsletterSubscriber
     *   }
     * })
     * 
     */
    create<T extends NewsletterSubscriberCreateArgs>(args: SelectSubset<T, NewsletterSubscriberCreateArgs<ExtArgs>>): Prisma__NewsletterSubscriberClient<$Result.GetResult<Prisma.$NewsletterSubscriberPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many NewsletterSubscribers.
     * @param {NewsletterSubscriberCreateManyArgs} args - Arguments to create many NewsletterSubscribers.
     * @example
     * // Create many NewsletterSubscribers
     * const newsletterSubscriber = await prisma.newsletterSubscriber.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends NewsletterSubscriberCreateManyArgs>(args?: SelectSubset<T, NewsletterSubscriberCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many NewsletterSubscribers and returns the data saved in the database.
     * @param {NewsletterSubscriberCreateManyAndReturnArgs} args - Arguments to create many NewsletterSubscribers.
     * @example
     * // Create many NewsletterSubscribers
     * const newsletterSubscriber = await prisma.newsletterSubscriber.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many NewsletterSubscribers and only return the `id`
     * const newsletterSubscriberWithIdOnly = await prisma.newsletterSubscriber.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends NewsletterSubscriberCreateManyAndReturnArgs>(args?: SelectSubset<T, NewsletterSubscriberCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$NewsletterSubscriberPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a NewsletterSubscriber.
     * @param {NewsletterSubscriberDeleteArgs} args - Arguments to delete one NewsletterSubscriber.
     * @example
     * // Delete one NewsletterSubscriber
     * const NewsletterSubscriber = await prisma.newsletterSubscriber.delete({
     *   where: {
     *     // ... filter to delete one NewsletterSubscriber
     *   }
     * })
     * 
     */
    delete<T extends NewsletterSubscriberDeleteArgs>(args: SelectSubset<T, NewsletterSubscriberDeleteArgs<ExtArgs>>): Prisma__NewsletterSubscriberClient<$Result.GetResult<Prisma.$NewsletterSubscriberPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one NewsletterSubscriber.
     * @param {NewsletterSubscriberUpdateArgs} args - Arguments to update one NewsletterSubscriber.
     * @example
     * // Update one NewsletterSubscriber
     * const newsletterSubscriber = await prisma.newsletterSubscriber.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends NewsletterSubscriberUpdateArgs>(args: SelectSubset<T, NewsletterSubscriberUpdateArgs<ExtArgs>>): Prisma__NewsletterSubscriberClient<$Result.GetResult<Prisma.$NewsletterSubscriberPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more NewsletterSubscribers.
     * @param {NewsletterSubscriberDeleteManyArgs} args - Arguments to filter NewsletterSubscribers to delete.
     * @example
     * // Delete a few NewsletterSubscribers
     * const { count } = await prisma.newsletterSubscriber.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends NewsletterSubscriberDeleteManyArgs>(args?: SelectSubset<T, NewsletterSubscriberDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more NewsletterSubscribers.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NewsletterSubscriberUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many NewsletterSubscribers
     * const newsletterSubscriber = await prisma.newsletterSubscriber.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends NewsletterSubscriberUpdateManyArgs>(args: SelectSubset<T, NewsletterSubscriberUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one NewsletterSubscriber.
     * @param {NewsletterSubscriberUpsertArgs} args - Arguments to update or create a NewsletterSubscriber.
     * @example
     * // Update or create a NewsletterSubscriber
     * const newsletterSubscriber = await prisma.newsletterSubscriber.upsert({
     *   create: {
     *     // ... data to create a NewsletterSubscriber
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the NewsletterSubscriber we want to update
     *   }
     * })
     */
    upsert<T extends NewsletterSubscriberUpsertArgs>(args: SelectSubset<T, NewsletterSubscriberUpsertArgs<ExtArgs>>): Prisma__NewsletterSubscriberClient<$Result.GetResult<Prisma.$NewsletterSubscriberPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of NewsletterSubscribers.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NewsletterSubscriberCountArgs} args - Arguments to filter NewsletterSubscribers to count.
     * @example
     * // Count the number of NewsletterSubscribers
     * const count = await prisma.newsletterSubscriber.count({
     *   where: {
     *     // ... the filter for the NewsletterSubscribers we want to count
     *   }
     * })
    **/
    count<T extends NewsletterSubscriberCountArgs>(
      args?: Subset<T, NewsletterSubscriberCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], NewsletterSubscriberCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a NewsletterSubscriber.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NewsletterSubscriberAggregateArgs} 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 NewsletterSubscriberAggregateArgs>(args: Subset<T, NewsletterSubscriberAggregateArgs>): Prisma.PrismaPromise<GetNewsletterSubscriberAggregateType<T>>

    /**
     * Group by NewsletterSubscriber.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {NewsletterSubscriberGroupByArgs} 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 NewsletterSubscriberGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: NewsletterSubscriberGroupByArgs['orderBy'] }
        : { orderBy?: NewsletterSubscriberGroupByArgs['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, NewsletterSubscriberGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetNewsletterSubscriberGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the NewsletterSubscriber model
   */
  readonly fields: NewsletterSubscriberFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for NewsletterSubscriber.
   * 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__NewsletterSubscriberClient<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 NewsletterSubscriber model
   */ 
  interface NewsletterSubscriberFieldRefs {
    readonly id: FieldRef<"NewsletterSubscriber", 'String'>
    readonly email: FieldRef<"NewsletterSubscriber", 'String'>
    readonly mobile: FieldRef<"NewsletterSubscriber", 'String'>
    readonly createdAt: FieldRef<"NewsletterSubscriber", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * NewsletterSubscriber findUnique
   */
  export type NewsletterSubscriberFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NewsletterSubscriber
     */
    select?: NewsletterSubscriberSelect<ExtArgs> | null
    /**
     * Filter, which NewsletterSubscriber to fetch.
     */
    where: NewsletterSubscriberWhereUniqueInput
  }

  /**
   * NewsletterSubscriber findUniqueOrThrow
   */
  export type NewsletterSubscriberFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NewsletterSubscriber
     */
    select?: NewsletterSubscriberSelect<ExtArgs> | null
    /**
     * Filter, which NewsletterSubscriber to fetch.
     */
    where: NewsletterSubscriberWhereUniqueInput
  }

  /**
   * NewsletterSubscriber findFirst
   */
  export type NewsletterSubscriberFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NewsletterSubscriber
     */
    select?: NewsletterSubscriberSelect<ExtArgs> | null
    /**
     * Filter, which NewsletterSubscriber to fetch.
     */
    where?: NewsletterSubscriberWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of NewsletterSubscribers to fetch.
     */
    orderBy?: NewsletterSubscriberOrderByWithRelationInput | NewsletterSubscriberOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for NewsletterSubscribers.
     */
    cursor?: NewsletterSubscriberWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` NewsletterSubscribers from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` NewsletterSubscribers.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of NewsletterSubscribers.
     */
    distinct?: NewsletterSubscriberScalarFieldEnum | NewsletterSubscriberScalarFieldEnum[]
  }

  /**
   * NewsletterSubscriber findFirstOrThrow
   */
  export type NewsletterSubscriberFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NewsletterSubscriber
     */
    select?: NewsletterSubscriberSelect<ExtArgs> | null
    /**
     * Filter, which NewsletterSubscriber to fetch.
     */
    where?: NewsletterSubscriberWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of NewsletterSubscribers to fetch.
     */
    orderBy?: NewsletterSubscriberOrderByWithRelationInput | NewsletterSubscriberOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for NewsletterSubscribers.
     */
    cursor?: NewsletterSubscriberWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` NewsletterSubscribers from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` NewsletterSubscribers.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of NewsletterSubscribers.
     */
    distinct?: NewsletterSubscriberScalarFieldEnum | NewsletterSubscriberScalarFieldEnum[]
  }

  /**
   * NewsletterSubscriber findMany
   */
  export type NewsletterSubscriberFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NewsletterSubscriber
     */
    select?: NewsletterSubscriberSelect<ExtArgs> | null
    /**
     * Filter, which NewsletterSubscribers to fetch.
     */
    where?: NewsletterSubscriberWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of NewsletterSubscribers to fetch.
     */
    orderBy?: NewsletterSubscriberOrderByWithRelationInput | NewsletterSubscriberOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing NewsletterSubscribers.
     */
    cursor?: NewsletterSubscriberWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` NewsletterSubscribers from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` NewsletterSubscribers.
     */
    skip?: number
    distinct?: NewsletterSubscriberScalarFieldEnum | NewsletterSubscriberScalarFieldEnum[]
  }

  /**
   * NewsletterSubscriber create
   */
  export type NewsletterSubscriberCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NewsletterSubscriber
     */
    select?: NewsletterSubscriberSelect<ExtArgs> | null
    /**
     * The data needed to create a NewsletterSubscriber.
     */
    data?: XOR<NewsletterSubscriberCreateInput, NewsletterSubscriberUncheckedCreateInput>
  }

  /**
   * NewsletterSubscriber createMany
   */
  export type NewsletterSubscriberCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many NewsletterSubscribers.
     */
    data: NewsletterSubscriberCreateManyInput | NewsletterSubscriberCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * NewsletterSubscriber createManyAndReturn
   */
  export type NewsletterSubscriberCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NewsletterSubscriber
     */
    select?: NewsletterSubscriberSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many NewsletterSubscribers.
     */
    data: NewsletterSubscriberCreateManyInput | NewsletterSubscriberCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * NewsletterSubscriber update
   */
  export type NewsletterSubscriberUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NewsletterSubscriber
     */
    select?: NewsletterSubscriberSelect<ExtArgs> | null
    /**
     * The data needed to update a NewsletterSubscriber.
     */
    data: XOR<NewsletterSubscriberUpdateInput, NewsletterSubscriberUncheckedUpdateInput>
    /**
     * Choose, which NewsletterSubscriber to update.
     */
    where: NewsletterSubscriberWhereUniqueInput
  }

  /**
   * NewsletterSubscriber updateMany
   */
  export type NewsletterSubscriberUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update NewsletterSubscribers.
     */
    data: XOR<NewsletterSubscriberUpdateManyMutationInput, NewsletterSubscriberUncheckedUpdateManyInput>
    /**
     * Filter which NewsletterSubscribers to update
     */
    where?: NewsletterSubscriberWhereInput
  }

  /**
   * NewsletterSubscriber upsert
   */
  export type NewsletterSubscriberUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NewsletterSubscriber
     */
    select?: NewsletterSubscriberSelect<ExtArgs> | null
    /**
     * The filter to search for the NewsletterSubscriber to update in case it exists.
     */
    where: NewsletterSubscriberWhereUniqueInput
    /**
     * In case the NewsletterSubscriber found by the `where` argument doesn't exist, create a new NewsletterSubscriber with this data.
     */
    create: XOR<NewsletterSubscriberCreateInput, NewsletterSubscriberUncheckedCreateInput>
    /**
     * In case the NewsletterSubscriber was found with the provided `where` argument, update it with this data.
     */
    update: XOR<NewsletterSubscriberUpdateInput, NewsletterSubscriberUncheckedUpdateInput>
  }

  /**
   * NewsletterSubscriber delete
   */
  export type NewsletterSubscriberDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NewsletterSubscriber
     */
    select?: NewsletterSubscriberSelect<ExtArgs> | null
    /**
     * Filter which NewsletterSubscriber to delete.
     */
    where: NewsletterSubscriberWhereUniqueInput
  }

  /**
   * NewsletterSubscriber deleteMany
   */
  export type NewsletterSubscriberDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which NewsletterSubscribers to delete
     */
    where?: NewsletterSubscriberWhereInput
  }

  /**
   * NewsletterSubscriber without action
   */
  export type NewsletterSubscriberDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the NewsletterSubscriber
     */
    select?: NewsletterSubscriberSelect<ExtArgs> | null
  }


  /**
   * Model CustomerActivityLog
   */

  export type AggregateCustomerActivityLog = {
    _count: CustomerActivityLogCountAggregateOutputType | null
    _min: CustomerActivityLogMinAggregateOutputType | null
    _max: CustomerActivityLogMaxAggregateOutputType | null
  }

  export type CustomerActivityLogMinAggregateOutputType = {
    id: string | null
    customerId: string | null
    action: string | null
    detail: string | null
    createdAt: Date | null
  }

  export type CustomerActivityLogMaxAggregateOutputType = {
    id: string | null
    customerId: string | null
    action: string | null
    detail: string | null
    createdAt: Date | null
  }

  export type CustomerActivityLogCountAggregateOutputType = {
    id: number
    customerId: number
    action: number
    detail: number
    createdAt: number
    _all: number
  }


  export type CustomerActivityLogMinAggregateInputType = {
    id?: true
    customerId?: true
    action?: true
    detail?: true
    createdAt?: true
  }

  export type CustomerActivityLogMaxAggregateInputType = {
    id?: true
    customerId?: true
    action?: true
    detail?: true
    createdAt?: true
  }

  export type CustomerActivityLogCountAggregateInputType = {
    id?: true
    customerId?: true
    action?: true
    detail?: true
    createdAt?: true
    _all?: true
  }

  export type CustomerActivityLogAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CustomerActivityLog to aggregate.
     */
    where?: CustomerActivityLogWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CustomerActivityLogs to fetch.
     */
    orderBy?: CustomerActivityLogOrderByWithRelationInput | CustomerActivityLogOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: CustomerActivityLogWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CustomerActivityLogs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` CustomerActivityLogs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned CustomerActivityLogs
    **/
    _count?: true | CustomerActivityLogCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: CustomerActivityLogMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: CustomerActivityLogMaxAggregateInputType
  }

  export type GetCustomerActivityLogAggregateType<T extends CustomerActivityLogAggregateArgs> = {
        [P in keyof T & keyof AggregateCustomerActivityLog]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateCustomerActivityLog[P]>
      : GetScalarType<T[P], AggregateCustomerActivityLog[P]>
  }




  export type CustomerActivityLogGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CustomerActivityLogWhereInput
    orderBy?: CustomerActivityLogOrderByWithAggregationInput | CustomerActivityLogOrderByWithAggregationInput[]
    by: CustomerActivityLogScalarFieldEnum[] | CustomerActivityLogScalarFieldEnum
    having?: CustomerActivityLogScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CustomerActivityLogCountAggregateInputType | true
    _min?: CustomerActivityLogMinAggregateInputType
    _max?: CustomerActivityLogMaxAggregateInputType
  }

  export type CustomerActivityLogGroupByOutputType = {
    id: string
    customerId: string
    action: string
    detail: string | null
    createdAt: Date
    _count: CustomerActivityLogCountAggregateOutputType | null
    _min: CustomerActivityLogMinAggregateOutputType | null
    _max: CustomerActivityLogMaxAggregateOutputType | null
  }

  type GetCustomerActivityLogGroupByPayload<T extends CustomerActivityLogGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<CustomerActivityLogGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof CustomerActivityLogGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], CustomerActivityLogGroupByOutputType[P]>
            : GetScalarType<T[P], CustomerActivityLogGroupByOutputType[P]>
        }
      >
    >


  export type CustomerActivityLogSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    customerId?: boolean
    action?: boolean
    detail?: boolean
    createdAt?: boolean
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["customerActivityLog"]>

  export type CustomerActivityLogSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    customerId?: boolean
    action?: boolean
    detail?: boolean
    createdAt?: boolean
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["customerActivityLog"]>

  export type CustomerActivityLogSelectScalar = {
    id?: boolean
    customerId?: boolean
    action?: boolean
    detail?: boolean
    createdAt?: boolean
  }

  export type CustomerActivityLogInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
  }
  export type CustomerActivityLogIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
  }

  export type $CustomerActivityLogPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "CustomerActivityLog"
    objects: {
      customer: Prisma.$CustomerPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      customerId: string
      /**
       * Free-form action key, e.g. 'login', 'order.placed', 'profile.updated'.
       */
      action: string
      detail: string | null
      createdAt: Date
    }, ExtArgs["result"]["customerActivityLog"]>
    composites: {}
  }

  type CustomerActivityLogGetPayload<S extends boolean | null | undefined | CustomerActivityLogDefaultArgs> = $Result.GetResult<Prisma.$CustomerActivityLogPayload, S>

  type CustomerActivityLogCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<CustomerActivityLogFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: CustomerActivityLogCountAggregateInputType | true
    }

  export interface CustomerActivityLogDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['CustomerActivityLog'], meta: { name: 'CustomerActivityLog' } }
    /**
     * Find zero or one CustomerActivityLog that matches the filter.
     * @param {CustomerActivityLogFindUniqueArgs} args - Arguments to find a CustomerActivityLog
     * @example
     * // Get one CustomerActivityLog
     * const customerActivityLog = await prisma.customerActivityLog.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends CustomerActivityLogFindUniqueArgs>(args: SelectSubset<T, CustomerActivityLogFindUniqueArgs<ExtArgs>>): Prisma__CustomerActivityLogClient<$Result.GetResult<Prisma.$CustomerActivityLogPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one CustomerActivityLog that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {CustomerActivityLogFindUniqueOrThrowArgs} args - Arguments to find a CustomerActivityLog
     * @example
     * // Get one CustomerActivityLog
     * const customerActivityLog = await prisma.customerActivityLog.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends CustomerActivityLogFindUniqueOrThrowArgs>(args: SelectSubset<T, CustomerActivityLogFindUniqueOrThrowArgs<ExtArgs>>): Prisma__CustomerActivityLogClient<$Result.GetResult<Prisma.$CustomerActivityLogPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first CustomerActivityLog that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {CustomerActivityLogFindFirstArgs} args - Arguments to find a CustomerActivityLog
     * @example
     * // Get one CustomerActivityLog
     * const customerActivityLog = await prisma.customerActivityLog.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends CustomerActivityLogFindFirstArgs>(args?: SelectSubset<T, CustomerActivityLogFindFirstArgs<ExtArgs>>): Prisma__CustomerActivityLogClient<$Result.GetResult<Prisma.$CustomerActivityLogPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first CustomerActivityLog 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 {CustomerActivityLogFindFirstOrThrowArgs} args - Arguments to find a CustomerActivityLog
     * @example
     * // Get one CustomerActivityLog
     * const customerActivityLog = await prisma.customerActivityLog.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends CustomerActivityLogFindFirstOrThrowArgs>(args?: SelectSubset<T, CustomerActivityLogFindFirstOrThrowArgs<ExtArgs>>): Prisma__CustomerActivityLogClient<$Result.GetResult<Prisma.$CustomerActivityLogPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more CustomerActivityLogs that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {CustomerActivityLogFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all CustomerActivityLogs
     * const customerActivityLogs = await prisma.customerActivityLog.findMany()
     * 
     * // Get first 10 CustomerActivityLogs
     * const customerActivityLogs = await prisma.customerActivityLog.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const customerActivityLogWithIdOnly = await prisma.customerActivityLog.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends CustomerActivityLogFindManyArgs>(args?: SelectSubset<T, CustomerActivityLogFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CustomerActivityLogPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a CustomerActivityLog.
     * @param {CustomerActivityLogCreateArgs} args - Arguments to create a CustomerActivityLog.
     * @example
     * // Create one CustomerActivityLog
     * const CustomerActivityLog = await prisma.customerActivityLog.create({
     *   data: {
     *     // ... data to create a CustomerActivityLog
     *   }
     * })
     * 
     */
    create<T extends CustomerActivityLogCreateArgs>(args: SelectSubset<T, CustomerActivityLogCreateArgs<ExtArgs>>): Prisma__CustomerActivityLogClient<$Result.GetResult<Prisma.$CustomerActivityLogPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many CustomerActivityLogs.
     * @param {CustomerActivityLogCreateManyArgs} args - Arguments to create many CustomerActivityLogs.
     * @example
     * // Create many CustomerActivityLogs
     * const customerActivityLog = await prisma.customerActivityLog.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends CustomerActivityLogCreateManyArgs>(args?: SelectSubset<T, CustomerActivityLogCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many CustomerActivityLogs and returns the data saved in the database.
     * @param {CustomerActivityLogCreateManyAndReturnArgs} args - Arguments to create many CustomerActivityLogs.
     * @example
     * // Create many CustomerActivityLogs
     * const customerActivityLog = await prisma.customerActivityLog.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many CustomerActivityLogs and only return the `id`
     * const customerActivityLogWithIdOnly = await prisma.customerActivityLog.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends CustomerActivityLogCreateManyAndReturnArgs>(args?: SelectSubset<T, CustomerActivityLogCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CustomerActivityLogPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a CustomerActivityLog.
     * @param {CustomerActivityLogDeleteArgs} args - Arguments to delete one CustomerActivityLog.
     * @example
     * // Delete one CustomerActivityLog
     * const CustomerActivityLog = await prisma.customerActivityLog.delete({
     *   where: {
     *     // ... filter to delete one CustomerActivityLog
     *   }
     * })
     * 
     */
    delete<T extends CustomerActivityLogDeleteArgs>(args: SelectSubset<T, CustomerActivityLogDeleteArgs<ExtArgs>>): Prisma__CustomerActivityLogClient<$Result.GetResult<Prisma.$CustomerActivityLogPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one CustomerActivityLog.
     * @param {CustomerActivityLogUpdateArgs} args - Arguments to update one CustomerActivityLog.
     * @example
     * // Update one CustomerActivityLog
     * const customerActivityLog = await prisma.customerActivityLog.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends CustomerActivityLogUpdateArgs>(args: SelectSubset<T, CustomerActivityLogUpdateArgs<ExtArgs>>): Prisma__CustomerActivityLogClient<$Result.GetResult<Prisma.$CustomerActivityLogPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more CustomerActivityLogs.
     * @param {CustomerActivityLogDeleteManyArgs} args - Arguments to filter CustomerActivityLogs to delete.
     * @example
     * // Delete a few CustomerActivityLogs
     * const { count } = await prisma.customerActivityLog.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends CustomerActivityLogDeleteManyArgs>(args?: SelectSubset<T, CustomerActivityLogDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more CustomerActivityLogs.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {CustomerActivityLogUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many CustomerActivityLogs
     * const customerActivityLog = await prisma.customerActivityLog.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends CustomerActivityLogUpdateManyArgs>(args: SelectSubset<T, CustomerActivityLogUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one CustomerActivityLog.
     * @param {CustomerActivityLogUpsertArgs} args - Arguments to update or create a CustomerActivityLog.
     * @example
     * // Update or create a CustomerActivityLog
     * const customerActivityLog = await prisma.customerActivityLog.upsert({
     *   create: {
     *     // ... data to create a CustomerActivityLog
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the CustomerActivityLog we want to update
     *   }
     * })
     */
    upsert<T extends CustomerActivityLogUpsertArgs>(args: SelectSubset<T, CustomerActivityLogUpsertArgs<ExtArgs>>): Prisma__CustomerActivityLogClient<$Result.GetResult<Prisma.$CustomerActivityLogPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of CustomerActivityLogs.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {CustomerActivityLogCountArgs} args - Arguments to filter CustomerActivityLogs to count.
     * @example
     * // Count the number of CustomerActivityLogs
     * const count = await prisma.customerActivityLog.count({
     *   where: {
     *     // ... the filter for the CustomerActivityLogs we want to count
     *   }
     * })
    **/
    count<T extends CustomerActivityLogCountArgs>(
      args?: Subset<T, CustomerActivityLogCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], CustomerActivityLogCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a CustomerActivityLog.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {CustomerActivityLogAggregateArgs} 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 CustomerActivityLogAggregateArgs>(args: Subset<T, CustomerActivityLogAggregateArgs>): Prisma.PrismaPromise<GetCustomerActivityLogAggregateType<T>>

    /**
     * Group by CustomerActivityLog.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {CustomerActivityLogGroupByArgs} 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 CustomerActivityLogGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: CustomerActivityLogGroupByArgs['orderBy'] }
        : { orderBy?: CustomerActivityLogGroupByArgs['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, CustomerActivityLogGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetCustomerActivityLogGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the CustomerActivityLog model
   */
  readonly fields: CustomerActivityLogFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for CustomerActivityLog.
   * 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__CustomerActivityLogClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    customer<T extends CustomerDefaultArgs<ExtArgs> = {}>(args?: Subset<T, CustomerDefaultArgs<ExtArgs>>): Prisma__CustomerClient<$Result.GetResult<Prisma.$CustomerPayload<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 CustomerActivityLog model
   */ 
  interface CustomerActivityLogFieldRefs {
    readonly id: FieldRef<"CustomerActivityLog", 'String'>
    readonly customerId: FieldRef<"CustomerActivityLog", 'String'>
    readonly action: FieldRef<"CustomerActivityLog", 'String'>
    readonly detail: FieldRef<"CustomerActivityLog", 'String'>
    readonly createdAt: FieldRef<"CustomerActivityLog", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * CustomerActivityLog findUnique
   */
  export type CustomerActivityLogFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerActivityLog
     */
    select?: CustomerActivityLogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerActivityLogInclude<ExtArgs> | null
    /**
     * Filter, which CustomerActivityLog to fetch.
     */
    where: CustomerActivityLogWhereUniqueInput
  }

  /**
   * CustomerActivityLog findUniqueOrThrow
   */
  export type CustomerActivityLogFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerActivityLog
     */
    select?: CustomerActivityLogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerActivityLogInclude<ExtArgs> | null
    /**
     * Filter, which CustomerActivityLog to fetch.
     */
    where: CustomerActivityLogWhereUniqueInput
  }

  /**
   * CustomerActivityLog findFirst
   */
  export type CustomerActivityLogFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerActivityLog
     */
    select?: CustomerActivityLogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerActivityLogInclude<ExtArgs> | null
    /**
     * Filter, which CustomerActivityLog to fetch.
     */
    where?: CustomerActivityLogWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CustomerActivityLogs to fetch.
     */
    orderBy?: CustomerActivityLogOrderByWithRelationInput | CustomerActivityLogOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for CustomerActivityLogs.
     */
    cursor?: CustomerActivityLogWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CustomerActivityLogs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` CustomerActivityLogs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of CustomerActivityLogs.
     */
    distinct?: CustomerActivityLogScalarFieldEnum | CustomerActivityLogScalarFieldEnum[]
  }

  /**
   * CustomerActivityLog findFirstOrThrow
   */
  export type CustomerActivityLogFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerActivityLog
     */
    select?: CustomerActivityLogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerActivityLogInclude<ExtArgs> | null
    /**
     * Filter, which CustomerActivityLog to fetch.
     */
    where?: CustomerActivityLogWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CustomerActivityLogs to fetch.
     */
    orderBy?: CustomerActivityLogOrderByWithRelationInput | CustomerActivityLogOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for CustomerActivityLogs.
     */
    cursor?: CustomerActivityLogWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CustomerActivityLogs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` CustomerActivityLogs.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of CustomerActivityLogs.
     */
    distinct?: CustomerActivityLogScalarFieldEnum | CustomerActivityLogScalarFieldEnum[]
  }

  /**
   * CustomerActivityLog findMany
   */
  export type CustomerActivityLogFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerActivityLog
     */
    select?: CustomerActivityLogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerActivityLogInclude<ExtArgs> | null
    /**
     * Filter, which CustomerActivityLogs to fetch.
     */
    where?: CustomerActivityLogWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CustomerActivityLogs to fetch.
     */
    orderBy?: CustomerActivityLogOrderByWithRelationInput | CustomerActivityLogOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing CustomerActivityLogs.
     */
    cursor?: CustomerActivityLogWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CustomerActivityLogs from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` CustomerActivityLogs.
     */
    skip?: number
    distinct?: CustomerActivityLogScalarFieldEnum | CustomerActivityLogScalarFieldEnum[]
  }

  /**
   * CustomerActivityLog create
   */
  export type CustomerActivityLogCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerActivityLog
     */
    select?: CustomerActivityLogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerActivityLogInclude<ExtArgs> | null
    /**
     * The data needed to create a CustomerActivityLog.
     */
    data: XOR<CustomerActivityLogCreateInput, CustomerActivityLogUncheckedCreateInput>
  }

  /**
   * CustomerActivityLog createMany
   */
  export type CustomerActivityLogCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many CustomerActivityLogs.
     */
    data: CustomerActivityLogCreateManyInput | CustomerActivityLogCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * CustomerActivityLog createManyAndReturn
   */
  export type CustomerActivityLogCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerActivityLog
     */
    select?: CustomerActivityLogSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many CustomerActivityLogs.
     */
    data: CustomerActivityLogCreateManyInput | CustomerActivityLogCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerActivityLogIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * CustomerActivityLog update
   */
  export type CustomerActivityLogUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerActivityLog
     */
    select?: CustomerActivityLogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerActivityLogInclude<ExtArgs> | null
    /**
     * The data needed to update a CustomerActivityLog.
     */
    data: XOR<CustomerActivityLogUpdateInput, CustomerActivityLogUncheckedUpdateInput>
    /**
     * Choose, which CustomerActivityLog to update.
     */
    where: CustomerActivityLogWhereUniqueInput
  }

  /**
   * CustomerActivityLog updateMany
   */
  export type CustomerActivityLogUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update CustomerActivityLogs.
     */
    data: XOR<CustomerActivityLogUpdateManyMutationInput, CustomerActivityLogUncheckedUpdateManyInput>
    /**
     * Filter which CustomerActivityLogs to update
     */
    where?: CustomerActivityLogWhereInput
  }

  /**
   * CustomerActivityLog upsert
   */
  export type CustomerActivityLogUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerActivityLog
     */
    select?: CustomerActivityLogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerActivityLogInclude<ExtArgs> | null
    /**
     * The filter to search for the CustomerActivityLog to update in case it exists.
     */
    where: CustomerActivityLogWhereUniqueInput
    /**
     * In case the CustomerActivityLog found by the `where` argument doesn't exist, create a new CustomerActivityLog with this data.
     */
    create: XOR<CustomerActivityLogCreateInput, CustomerActivityLogUncheckedCreateInput>
    /**
     * In case the CustomerActivityLog was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CustomerActivityLogUpdateInput, CustomerActivityLogUncheckedUpdateInput>
  }

  /**
   * CustomerActivityLog delete
   */
  export type CustomerActivityLogDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerActivityLog
     */
    select?: CustomerActivityLogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerActivityLogInclude<ExtArgs> | null
    /**
     * Filter which CustomerActivityLog to delete.
     */
    where: CustomerActivityLogWhereUniqueInput
  }

  /**
   * CustomerActivityLog deleteMany
   */
  export type CustomerActivityLogDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CustomerActivityLogs to delete
     */
    where?: CustomerActivityLogWhereInput
  }

  /**
   * CustomerActivityLog without action
   */
  export type CustomerActivityLogDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerActivityLog
     */
    select?: CustomerActivityLogSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerActivityLogInclude<ExtArgs> | null
  }


  /**
   * Model UploadedFile
   */

  export type AggregateUploadedFile = {
    _count: UploadedFileCountAggregateOutputType | null
    _avg: UploadedFileAvgAggregateOutputType | null
    _sum: UploadedFileSumAggregateOutputType | null
    _min: UploadedFileMinAggregateOutputType | null
    _max: UploadedFileMaxAggregateOutputType | null
  }

  export type UploadedFileAvgAggregateOutputType = {
    sizeBytes: number | null
  }

  export type UploadedFileSumAggregateOutputType = {
    sizeBytes: number | null
  }

  export type UploadedFileMinAggregateOutputType = {
    id: string | null
    url: string | null
    originalName: string | null
    mimeType: string | null
    sizeBytes: number | null
    purpose: string | null
    uploadedByAdminUserId: string | null
    createdAt: Date | null
  }

  export type UploadedFileMaxAggregateOutputType = {
    id: string | null
    url: string | null
    originalName: string | null
    mimeType: string | null
    sizeBytes: number | null
    purpose: string | null
    uploadedByAdminUserId: string | null
    createdAt: Date | null
  }

  export type UploadedFileCountAggregateOutputType = {
    id: number
    url: number
    originalName: number
    mimeType: number
    sizeBytes: number
    purpose: number
    uploadedByAdminUserId: number
    createdAt: number
    _all: number
  }


  export type UploadedFileAvgAggregateInputType = {
    sizeBytes?: true
  }

  export type UploadedFileSumAggregateInputType = {
    sizeBytes?: true
  }

  export type UploadedFileMinAggregateInputType = {
    id?: true
    url?: true
    originalName?: true
    mimeType?: true
    sizeBytes?: true
    purpose?: true
    uploadedByAdminUserId?: true
    createdAt?: true
  }

  export type UploadedFileMaxAggregateInputType = {
    id?: true
    url?: true
    originalName?: true
    mimeType?: true
    sizeBytes?: true
    purpose?: true
    uploadedByAdminUserId?: true
    createdAt?: true
  }

  export type UploadedFileCountAggregateInputType = {
    id?: true
    url?: true
    originalName?: true
    mimeType?: true
    sizeBytes?: true
    purpose?: true
    uploadedByAdminUserId?: true
    createdAt?: true
    _all?: true
  }

  export type UploadedFileAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which UploadedFile to aggregate.
     */
    where?: UploadedFileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of UploadedFiles to fetch.
     */
    orderBy?: UploadedFileOrderByWithRelationInput | UploadedFileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: UploadedFileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` UploadedFiles from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` UploadedFiles.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned UploadedFiles
    **/
    _count?: true | UploadedFileCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: UploadedFileAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: UploadedFileSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: UploadedFileMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: UploadedFileMaxAggregateInputType
  }

  export type GetUploadedFileAggregateType<T extends UploadedFileAggregateArgs> = {
        [P in keyof T & keyof AggregateUploadedFile]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateUploadedFile[P]>
      : GetScalarType<T[P], AggregateUploadedFile[P]>
  }




  export type UploadedFileGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: UploadedFileWhereInput
    orderBy?: UploadedFileOrderByWithAggregationInput | UploadedFileOrderByWithAggregationInput[]
    by: UploadedFileScalarFieldEnum[] | UploadedFileScalarFieldEnum
    having?: UploadedFileScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: UploadedFileCountAggregateInputType | true
    _avg?: UploadedFileAvgAggregateInputType
    _sum?: UploadedFileSumAggregateInputType
    _min?: UploadedFileMinAggregateInputType
    _max?: UploadedFileMaxAggregateInputType
  }

  export type UploadedFileGroupByOutputType = {
    id: string
    url: string
    originalName: string
    mimeType: string
    sizeBytes: number
    purpose: string | null
    uploadedByAdminUserId: string | null
    createdAt: Date
    _count: UploadedFileCountAggregateOutputType | null
    _avg: UploadedFileAvgAggregateOutputType | null
    _sum: UploadedFileSumAggregateOutputType | null
    _min: UploadedFileMinAggregateOutputType | null
    _max: UploadedFileMaxAggregateOutputType | null
  }

  type GetUploadedFileGroupByPayload<T extends UploadedFileGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<UploadedFileGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof UploadedFileGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], UploadedFileGroupByOutputType[P]>
            : GetScalarType<T[P], UploadedFileGroupByOutputType[P]>
        }
      >
    >


  export type UploadedFileSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    url?: boolean
    originalName?: boolean
    mimeType?: boolean
    sizeBytes?: boolean
    purpose?: boolean
    uploadedByAdminUserId?: boolean
    createdAt?: boolean
    uploadedByAdminUser?: boolean | UploadedFile$uploadedByAdminUserArgs<ExtArgs>
    customerAvatars?: boolean | UploadedFile$customerAvatarsArgs<ExtArgs>
    adminUserAvatars?: boolean | UploadedFile$adminUserAvatarsArgs<ExtArgs>
    _count?: boolean | UploadedFileCountOutputTypeDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["uploadedFile"]>

  export type UploadedFileSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    url?: boolean
    originalName?: boolean
    mimeType?: boolean
    sizeBytes?: boolean
    purpose?: boolean
    uploadedByAdminUserId?: boolean
    createdAt?: boolean
    uploadedByAdminUser?: boolean | UploadedFile$uploadedByAdminUserArgs<ExtArgs>
  }, ExtArgs["result"]["uploadedFile"]>

  export type UploadedFileSelectScalar = {
    id?: boolean
    url?: boolean
    originalName?: boolean
    mimeType?: boolean
    sizeBytes?: boolean
    purpose?: boolean
    uploadedByAdminUserId?: boolean
    createdAt?: boolean
  }

  export type UploadedFileInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    uploadedByAdminUser?: boolean | UploadedFile$uploadedByAdminUserArgs<ExtArgs>
    customerAvatars?: boolean | UploadedFile$customerAvatarsArgs<ExtArgs>
    adminUserAvatars?: boolean | UploadedFile$adminUserAvatarsArgs<ExtArgs>
    _count?: boolean | UploadedFileCountOutputTypeDefaultArgs<ExtArgs>
  }
  export type UploadedFileIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    uploadedByAdminUser?: boolean | UploadedFile$uploadedByAdminUserArgs<ExtArgs>
  }

  export type $UploadedFilePayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "UploadedFile"
    objects: {
      uploadedByAdminUser: Prisma.$AdminUserPayload<ExtArgs> | null
      customerAvatars: Prisma.$CustomerPayload<ExtArgs>[]
      adminUserAvatars: Prisma.$AdminUserPayload<ExtArgs>[]
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      /**
       * Public URL the stored file is served from.
       */
      url: string
      originalName: string
      mimeType: string
      sizeBytes: number
      /**
       * Free-form tag for what the file belongs to, e.g. 'product', 'category',
       * 'customer.nationalId'. Kept loose so a new form needs no schema change.
       */
      purpose: string | null
      uploadedByAdminUserId: string | null
      createdAt: Date
    }, ExtArgs["result"]["uploadedFile"]>
    composites: {}
  }

  type UploadedFileGetPayload<S extends boolean | null | undefined | UploadedFileDefaultArgs> = $Result.GetResult<Prisma.$UploadedFilePayload, S>

  type UploadedFileCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<UploadedFileFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: UploadedFileCountAggregateInputType | true
    }

  export interface UploadedFileDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['UploadedFile'], meta: { name: 'UploadedFile' } }
    /**
     * Find zero or one UploadedFile that matches the filter.
     * @param {UploadedFileFindUniqueArgs} args - Arguments to find a UploadedFile
     * @example
     * // Get one UploadedFile
     * const uploadedFile = await prisma.uploadedFile.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends UploadedFileFindUniqueArgs>(args: SelectSubset<T, UploadedFileFindUniqueArgs<ExtArgs>>): Prisma__UploadedFileClient<$Result.GetResult<Prisma.$UploadedFilePayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one UploadedFile that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {UploadedFileFindUniqueOrThrowArgs} args - Arguments to find a UploadedFile
     * @example
     * // Get one UploadedFile
     * const uploadedFile = await prisma.uploadedFile.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends UploadedFileFindUniqueOrThrowArgs>(args: SelectSubset<T, UploadedFileFindUniqueOrThrowArgs<ExtArgs>>): Prisma__UploadedFileClient<$Result.GetResult<Prisma.$UploadedFilePayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first UploadedFile that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {UploadedFileFindFirstArgs} args - Arguments to find a UploadedFile
     * @example
     * // Get one UploadedFile
     * const uploadedFile = await prisma.uploadedFile.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends UploadedFileFindFirstArgs>(args?: SelectSubset<T, UploadedFileFindFirstArgs<ExtArgs>>): Prisma__UploadedFileClient<$Result.GetResult<Prisma.$UploadedFilePayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first UploadedFile 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 {UploadedFileFindFirstOrThrowArgs} args - Arguments to find a UploadedFile
     * @example
     * // Get one UploadedFile
     * const uploadedFile = await prisma.uploadedFile.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends UploadedFileFindFirstOrThrowArgs>(args?: SelectSubset<T, UploadedFileFindFirstOrThrowArgs<ExtArgs>>): Prisma__UploadedFileClient<$Result.GetResult<Prisma.$UploadedFilePayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more UploadedFiles that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {UploadedFileFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all UploadedFiles
     * const uploadedFiles = await prisma.uploadedFile.findMany()
     * 
     * // Get first 10 UploadedFiles
     * const uploadedFiles = await prisma.uploadedFile.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const uploadedFileWithIdOnly = await prisma.uploadedFile.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends UploadedFileFindManyArgs>(args?: SelectSubset<T, UploadedFileFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UploadedFilePayload<ExtArgs>, T, "findMany">>

    /**
     * Create a UploadedFile.
     * @param {UploadedFileCreateArgs} args - Arguments to create a UploadedFile.
     * @example
     * // Create one UploadedFile
     * const UploadedFile = await prisma.uploadedFile.create({
     *   data: {
     *     // ... data to create a UploadedFile
     *   }
     * })
     * 
     */
    create<T extends UploadedFileCreateArgs>(args: SelectSubset<T, UploadedFileCreateArgs<ExtArgs>>): Prisma__UploadedFileClient<$Result.GetResult<Prisma.$UploadedFilePayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many UploadedFiles.
     * @param {UploadedFileCreateManyArgs} args - Arguments to create many UploadedFiles.
     * @example
     * // Create many UploadedFiles
     * const uploadedFile = await prisma.uploadedFile.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends UploadedFileCreateManyArgs>(args?: SelectSubset<T, UploadedFileCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many UploadedFiles and returns the data saved in the database.
     * @param {UploadedFileCreateManyAndReturnArgs} args - Arguments to create many UploadedFiles.
     * @example
     * // Create many UploadedFiles
     * const uploadedFile = await prisma.uploadedFile.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many UploadedFiles and only return the `id`
     * const uploadedFileWithIdOnly = await prisma.uploadedFile.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends UploadedFileCreateManyAndReturnArgs>(args?: SelectSubset<T, UploadedFileCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$UploadedFilePayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a UploadedFile.
     * @param {UploadedFileDeleteArgs} args - Arguments to delete one UploadedFile.
     * @example
     * // Delete one UploadedFile
     * const UploadedFile = await prisma.uploadedFile.delete({
     *   where: {
     *     // ... filter to delete one UploadedFile
     *   }
     * })
     * 
     */
    delete<T extends UploadedFileDeleteArgs>(args: SelectSubset<T, UploadedFileDeleteArgs<ExtArgs>>): Prisma__UploadedFileClient<$Result.GetResult<Prisma.$UploadedFilePayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one UploadedFile.
     * @param {UploadedFileUpdateArgs} args - Arguments to update one UploadedFile.
     * @example
     * // Update one UploadedFile
     * const uploadedFile = await prisma.uploadedFile.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends UploadedFileUpdateArgs>(args: SelectSubset<T, UploadedFileUpdateArgs<ExtArgs>>): Prisma__UploadedFileClient<$Result.GetResult<Prisma.$UploadedFilePayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more UploadedFiles.
     * @param {UploadedFileDeleteManyArgs} args - Arguments to filter UploadedFiles to delete.
     * @example
     * // Delete a few UploadedFiles
     * const { count } = await prisma.uploadedFile.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends UploadedFileDeleteManyArgs>(args?: SelectSubset<T, UploadedFileDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more UploadedFiles.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {UploadedFileUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many UploadedFiles
     * const uploadedFile = await prisma.uploadedFile.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends UploadedFileUpdateManyArgs>(args: SelectSubset<T, UploadedFileUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one UploadedFile.
     * @param {UploadedFileUpsertArgs} args - Arguments to update or create a UploadedFile.
     * @example
     * // Update or create a UploadedFile
     * const uploadedFile = await prisma.uploadedFile.upsert({
     *   create: {
     *     // ... data to create a UploadedFile
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the UploadedFile we want to update
     *   }
     * })
     */
    upsert<T extends UploadedFileUpsertArgs>(args: SelectSubset<T, UploadedFileUpsertArgs<ExtArgs>>): Prisma__UploadedFileClient<$Result.GetResult<Prisma.$UploadedFilePayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of UploadedFiles.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {UploadedFileCountArgs} args - Arguments to filter UploadedFiles to count.
     * @example
     * // Count the number of UploadedFiles
     * const count = await prisma.uploadedFile.count({
     *   where: {
     *     // ... the filter for the UploadedFiles we want to count
     *   }
     * })
    **/
    count<T extends UploadedFileCountArgs>(
      args?: Subset<T, UploadedFileCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], UploadedFileCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a UploadedFile.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {UploadedFileAggregateArgs} 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 UploadedFileAggregateArgs>(args: Subset<T, UploadedFileAggregateArgs>): Prisma.PrismaPromise<GetUploadedFileAggregateType<T>>

    /**
     * Group by UploadedFile.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {UploadedFileGroupByArgs} 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 UploadedFileGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: UploadedFileGroupByArgs['orderBy'] }
        : { orderBy?: UploadedFileGroupByArgs['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, UploadedFileGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetUploadedFileGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the UploadedFile model
   */
  readonly fields: UploadedFileFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for UploadedFile.
   * 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__UploadedFileClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    uploadedByAdminUser<T extends UploadedFile$uploadedByAdminUserArgs<ExtArgs> = {}>(args?: Subset<T, UploadedFile$uploadedByAdminUserArgs<ExtArgs>>): Prisma__AdminUserClient<$Result.GetResult<Prisma.$AdminUserPayload<ExtArgs>, T, "findUniqueOrThrow"> | null, null, ExtArgs>
    customerAvatars<T extends UploadedFile$customerAvatarsArgs<ExtArgs> = {}>(args?: Subset<T, UploadedFile$customerAvatarsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CustomerPayload<ExtArgs>, T, "findMany"> | Null>
    adminUserAvatars<T extends UploadedFile$adminUserAvatarsArgs<ExtArgs> = {}>(args?: Subset<T, UploadedFile$adminUserAvatarsArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$AdminUserPayload<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 UploadedFile model
   */ 
  interface UploadedFileFieldRefs {
    readonly id: FieldRef<"UploadedFile", 'String'>
    readonly url: FieldRef<"UploadedFile", 'String'>
    readonly originalName: FieldRef<"UploadedFile", 'String'>
    readonly mimeType: FieldRef<"UploadedFile", 'String'>
    readonly sizeBytes: FieldRef<"UploadedFile", 'Int'>
    readonly purpose: FieldRef<"UploadedFile", 'String'>
    readonly uploadedByAdminUserId: FieldRef<"UploadedFile", 'String'>
    readonly createdAt: FieldRef<"UploadedFile", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * UploadedFile findUnique
   */
  export type UploadedFileFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UploadedFile
     */
    select?: UploadedFileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UploadedFileInclude<ExtArgs> | null
    /**
     * Filter, which UploadedFile to fetch.
     */
    where: UploadedFileWhereUniqueInput
  }

  /**
   * UploadedFile findUniqueOrThrow
   */
  export type UploadedFileFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UploadedFile
     */
    select?: UploadedFileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UploadedFileInclude<ExtArgs> | null
    /**
     * Filter, which UploadedFile to fetch.
     */
    where: UploadedFileWhereUniqueInput
  }

  /**
   * UploadedFile findFirst
   */
  export type UploadedFileFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UploadedFile
     */
    select?: UploadedFileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UploadedFileInclude<ExtArgs> | null
    /**
     * Filter, which UploadedFile to fetch.
     */
    where?: UploadedFileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of UploadedFiles to fetch.
     */
    orderBy?: UploadedFileOrderByWithRelationInput | UploadedFileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for UploadedFiles.
     */
    cursor?: UploadedFileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` UploadedFiles from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` UploadedFiles.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of UploadedFiles.
     */
    distinct?: UploadedFileScalarFieldEnum | UploadedFileScalarFieldEnum[]
  }

  /**
   * UploadedFile findFirstOrThrow
   */
  export type UploadedFileFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UploadedFile
     */
    select?: UploadedFileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UploadedFileInclude<ExtArgs> | null
    /**
     * Filter, which UploadedFile to fetch.
     */
    where?: UploadedFileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of UploadedFiles to fetch.
     */
    orderBy?: UploadedFileOrderByWithRelationInput | UploadedFileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for UploadedFiles.
     */
    cursor?: UploadedFileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` UploadedFiles from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` UploadedFiles.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of UploadedFiles.
     */
    distinct?: UploadedFileScalarFieldEnum | UploadedFileScalarFieldEnum[]
  }

  /**
   * UploadedFile findMany
   */
  export type UploadedFileFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UploadedFile
     */
    select?: UploadedFileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UploadedFileInclude<ExtArgs> | null
    /**
     * Filter, which UploadedFiles to fetch.
     */
    where?: UploadedFileWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of UploadedFiles to fetch.
     */
    orderBy?: UploadedFileOrderByWithRelationInput | UploadedFileOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing UploadedFiles.
     */
    cursor?: UploadedFileWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` UploadedFiles from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` UploadedFiles.
     */
    skip?: number
    distinct?: UploadedFileScalarFieldEnum | UploadedFileScalarFieldEnum[]
  }

  /**
   * UploadedFile create
   */
  export type UploadedFileCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UploadedFile
     */
    select?: UploadedFileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UploadedFileInclude<ExtArgs> | null
    /**
     * The data needed to create a UploadedFile.
     */
    data: XOR<UploadedFileCreateInput, UploadedFileUncheckedCreateInput>
  }

  /**
   * UploadedFile createMany
   */
  export type UploadedFileCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many UploadedFiles.
     */
    data: UploadedFileCreateManyInput | UploadedFileCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * UploadedFile createManyAndReturn
   */
  export type UploadedFileCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UploadedFile
     */
    select?: UploadedFileSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many UploadedFiles.
     */
    data: UploadedFileCreateManyInput | UploadedFileCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UploadedFileIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * UploadedFile update
   */
  export type UploadedFileUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UploadedFile
     */
    select?: UploadedFileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UploadedFileInclude<ExtArgs> | null
    /**
     * The data needed to update a UploadedFile.
     */
    data: XOR<UploadedFileUpdateInput, UploadedFileUncheckedUpdateInput>
    /**
     * Choose, which UploadedFile to update.
     */
    where: UploadedFileWhereUniqueInput
  }

  /**
   * UploadedFile updateMany
   */
  export type UploadedFileUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update UploadedFiles.
     */
    data: XOR<UploadedFileUpdateManyMutationInput, UploadedFileUncheckedUpdateManyInput>
    /**
     * Filter which UploadedFiles to update
     */
    where?: UploadedFileWhereInput
  }

  /**
   * UploadedFile upsert
   */
  export type UploadedFileUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UploadedFile
     */
    select?: UploadedFileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UploadedFileInclude<ExtArgs> | null
    /**
     * The filter to search for the UploadedFile to update in case it exists.
     */
    where: UploadedFileWhereUniqueInput
    /**
     * In case the UploadedFile found by the `where` argument doesn't exist, create a new UploadedFile with this data.
     */
    create: XOR<UploadedFileCreateInput, UploadedFileUncheckedCreateInput>
    /**
     * In case the UploadedFile was found with the provided `where` argument, update it with this data.
     */
    update: XOR<UploadedFileUpdateInput, UploadedFileUncheckedUpdateInput>
  }

  /**
   * UploadedFile delete
   */
  export type UploadedFileDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UploadedFile
     */
    select?: UploadedFileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UploadedFileInclude<ExtArgs> | null
    /**
     * Filter which UploadedFile to delete.
     */
    where: UploadedFileWhereUniqueInput
  }

  /**
   * UploadedFile deleteMany
   */
  export type UploadedFileDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which UploadedFiles to delete
     */
    where?: UploadedFileWhereInput
  }

  /**
   * UploadedFile.uploadedByAdminUser
   */
  export type UploadedFile$uploadedByAdminUserArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AdminUser
     */
    select?: AdminUserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AdminUserInclude<ExtArgs> | null
    where?: AdminUserWhereInput
  }

  /**
   * UploadedFile.customerAvatars
   */
  export type UploadedFile$customerAvatarsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the Customer
     */
    select?: CustomerSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerInclude<ExtArgs> | null
    where?: CustomerWhereInput
    orderBy?: CustomerOrderByWithRelationInput | CustomerOrderByWithRelationInput[]
    cursor?: CustomerWhereUniqueInput
    take?: number
    skip?: number
    distinct?: CustomerScalarFieldEnum | CustomerScalarFieldEnum[]
  }

  /**
   * UploadedFile.adminUserAvatars
   */
  export type UploadedFile$adminUserAvatarsArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the AdminUser
     */
    select?: AdminUserSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: AdminUserInclude<ExtArgs> | null
    where?: AdminUserWhereInput
    orderBy?: AdminUserOrderByWithRelationInput | AdminUserOrderByWithRelationInput[]
    cursor?: AdminUserWhereUniqueInput
    take?: number
    skip?: number
    distinct?: AdminUserScalarFieldEnum | AdminUserScalarFieldEnum[]
  }

  /**
   * UploadedFile without action
   */
  export type UploadedFileDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the UploadedFile
     */
    select?: UploadedFileSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: UploadedFileInclude<ExtArgs> | null
  }


  /**
   * Model CustomerOtp
   */

  export type AggregateCustomerOtp = {
    _count: CustomerOtpCountAggregateOutputType | null
    _avg: CustomerOtpAvgAggregateOutputType | null
    _sum: CustomerOtpSumAggregateOutputType | null
    _min: CustomerOtpMinAggregateOutputType | null
    _max: CustomerOtpMaxAggregateOutputType | null
  }

  export type CustomerOtpAvgAggregateOutputType = {
    attempts: number | null
  }

  export type CustomerOtpSumAggregateOutputType = {
    attempts: number | null
  }

  export type CustomerOtpMinAggregateOutputType = {
    id: string | null
    mobile: string | null
    customerId: string | null
    codeHash: string | null
    expiresAt: Date | null
    attempts: number | null
    consumedAt: Date | null
    requestIp: string | null
    createdAt: Date | null
  }

  export type CustomerOtpMaxAggregateOutputType = {
    id: string | null
    mobile: string | null
    customerId: string | null
    codeHash: string | null
    expiresAt: Date | null
    attempts: number | null
    consumedAt: Date | null
    requestIp: string | null
    createdAt: Date | null
  }

  export type CustomerOtpCountAggregateOutputType = {
    id: number
    mobile: number
    customerId: number
    codeHash: number
    expiresAt: number
    attempts: number
    consumedAt: number
    requestIp: number
    createdAt: number
    _all: number
  }


  export type CustomerOtpAvgAggregateInputType = {
    attempts?: true
  }

  export type CustomerOtpSumAggregateInputType = {
    attempts?: true
  }

  export type CustomerOtpMinAggregateInputType = {
    id?: true
    mobile?: true
    customerId?: true
    codeHash?: true
    expiresAt?: true
    attempts?: true
    consumedAt?: true
    requestIp?: true
    createdAt?: true
  }

  export type CustomerOtpMaxAggregateInputType = {
    id?: true
    mobile?: true
    customerId?: true
    codeHash?: true
    expiresAt?: true
    attempts?: true
    consumedAt?: true
    requestIp?: true
    createdAt?: true
  }

  export type CustomerOtpCountAggregateInputType = {
    id?: true
    mobile?: true
    customerId?: true
    codeHash?: true
    expiresAt?: true
    attempts?: true
    consumedAt?: true
    requestIp?: true
    createdAt?: true
    _all?: true
  }

  export type CustomerOtpAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CustomerOtp to aggregate.
     */
    where?: CustomerOtpWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CustomerOtps to fetch.
     */
    orderBy?: CustomerOtpOrderByWithRelationInput | CustomerOtpOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the start position
     */
    cursor?: CustomerOtpWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CustomerOtps from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` CustomerOtps.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Count returned CustomerOtps
    **/
    _count?: true | CustomerOtpCountAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to average
    **/
    _avg?: CustomerOtpAvgAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to sum
    **/
    _sum?: CustomerOtpSumAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the minimum value
    **/
    _min?: CustomerOtpMinAggregateInputType
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
     * 
     * Select which fields to find the maximum value
    **/
    _max?: CustomerOtpMaxAggregateInputType
  }

  export type GetCustomerOtpAggregateType<T extends CustomerOtpAggregateArgs> = {
        [P in keyof T & keyof AggregateCustomerOtp]: P extends '_count' | 'count'
      ? T[P] extends true
        ? number
        : GetScalarType<T[P], AggregateCustomerOtp[P]>
      : GetScalarType<T[P], AggregateCustomerOtp[P]>
  }




  export type CustomerOtpGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    where?: CustomerOtpWhereInput
    orderBy?: CustomerOtpOrderByWithAggregationInput | CustomerOtpOrderByWithAggregationInput[]
    by: CustomerOtpScalarFieldEnum[] | CustomerOtpScalarFieldEnum
    having?: CustomerOtpScalarWhereWithAggregatesInput
    take?: number
    skip?: number
    _count?: CustomerOtpCountAggregateInputType | true
    _avg?: CustomerOtpAvgAggregateInputType
    _sum?: CustomerOtpSumAggregateInputType
    _min?: CustomerOtpMinAggregateInputType
    _max?: CustomerOtpMaxAggregateInputType
  }

  export type CustomerOtpGroupByOutputType = {
    id: string
    mobile: string
    customerId: string
    codeHash: string
    expiresAt: Date
    attempts: number
    consumedAt: Date | null
    requestIp: string | null
    createdAt: Date
    _count: CustomerOtpCountAggregateOutputType | null
    _avg: CustomerOtpAvgAggregateOutputType | null
    _sum: CustomerOtpSumAggregateOutputType | null
    _min: CustomerOtpMinAggregateOutputType | null
    _max: CustomerOtpMaxAggregateOutputType | null
  }

  type GetCustomerOtpGroupByPayload<T extends CustomerOtpGroupByArgs> = Prisma.PrismaPromise<
    Array<
      PickEnumerable<CustomerOtpGroupByOutputType, T['by']> &
        {
          [P in ((keyof T) & (keyof CustomerOtpGroupByOutputType))]: P extends '_count'
            ? T[P] extends boolean
              ? number
              : GetScalarType<T[P], CustomerOtpGroupByOutputType[P]>
            : GetScalarType<T[P], CustomerOtpGroupByOutputType[P]>
        }
      >
    >


  export type CustomerOtpSelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    mobile?: boolean
    customerId?: boolean
    codeHash?: boolean
    expiresAt?: boolean
    attempts?: boolean
    consumedAt?: boolean
    requestIp?: boolean
    createdAt?: boolean
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["customerOtp"]>

  export type CustomerOtpSelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
    id?: boolean
    mobile?: boolean
    customerId?: boolean
    codeHash?: boolean
    expiresAt?: boolean
    attempts?: boolean
    consumedAt?: boolean
    requestIp?: boolean
    createdAt?: boolean
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
  }, ExtArgs["result"]["customerOtp"]>

  export type CustomerOtpSelectScalar = {
    id?: boolean
    mobile?: boolean
    customerId?: boolean
    codeHash?: boolean
    expiresAt?: boolean
    attempts?: boolean
    consumedAt?: boolean
    requestIp?: boolean
    createdAt?: boolean
  }

  export type CustomerOtpInclude<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
  }
  export type CustomerOtpIncludeCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    customer?: boolean | CustomerDefaultArgs<ExtArgs>
  }

  export type $CustomerOtpPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    name: "CustomerOtp"
    objects: {
      customer: Prisma.$CustomerPayload<ExtArgs>
    }
    scalars: $Extensions.GetPayloadResult<{
      id: string
      /**
       * Normalised to English digits before storing, as the reference does with
       * Utility::faTOen() on both send and verify.
       */
      mobile: string
      customerId: string
      /**
       * bcrypt hash of the 4-digit code. Never the code itself.
       */
      codeHash: string
      expiresAt: Date
      /**
       * Failed verify attempts against THIS challenge.
       */
      attempts: number
      /**
       * Set when the code is accepted, so one challenge cannot be reused.
       */
      consumedAt: Date | null
      /**
       * Kept for the per-IP send throttle.
       */
      requestIp: string | null
      createdAt: Date
    }, ExtArgs["result"]["customerOtp"]>
    composites: {}
  }

  type CustomerOtpGetPayload<S extends boolean | null | undefined | CustomerOtpDefaultArgs> = $Result.GetResult<Prisma.$CustomerOtpPayload, S>

  type CustomerOtpCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = 
    Omit<CustomerOtpFindManyArgs, 'select' | 'include' | 'distinct'> & {
      select?: CustomerOtpCountAggregateInputType | true
    }

  export interface CustomerOtpDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> {
    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['CustomerOtp'], meta: { name: 'CustomerOtp' } }
    /**
     * Find zero or one CustomerOtp that matches the filter.
     * @param {CustomerOtpFindUniqueArgs} args - Arguments to find a CustomerOtp
     * @example
     * // Get one CustomerOtp
     * const customerOtp = await prisma.customerOtp.findUnique({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUnique<T extends CustomerOtpFindUniqueArgs>(args: SelectSubset<T, CustomerOtpFindUniqueArgs<ExtArgs>>): Prisma__CustomerOtpClient<$Result.GetResult<Prisma.$CustomerOtpPayload<ExtArgs>, T, "findUnique"> | null, null, ExtArgs>

    /**
     * Find one CustomerOtp that matches the filter or throw an error with `error.code='P2025'` 
     * if no matches were found.
     * @param {CustomerOtpFindUniqueOrThrowArgs} args - Arguments to find a CustomerOtp
     * @example
     * // Get one CustomerOtp
     * const customerOtp = await prisma.customerOtp.findUniqueOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findUniqueOrThrow<T extends CustomerOtpFindUniqueOrThrowArgs>(args: SelectSubset<T, CustomerOtpFindUniqueOrThrowArgs<ExtArgs>>): Prisma__CustomerOtpClient<$Result.GetResult<Prisma.$CustomerOtpPayload<ExtArgs>, T, "findUniqueOrThrow">, never, ExtArgs>

    /**
     * Find the first CustomerOtp that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {CustomerOtpFindFirstArgs} args - Arguments to find a CustomerOtp
     * @example
     * // Get one CustomerOtp
     * const customerOtp = await prisma.customerOtp.findFirst({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirst<T extends CustomerOtpFindFirstArgs>(args?: SelectSubset<T, CustomerOtpFindFirstArgs<ExtArgs>>): Prisma__CustomerOtpClient<$Result.GetResult<Prisma.$CustomerOtpPayload<ExtArgs>, T, "findFirst"> | null, null, ExtArgs>

    /**
     * Find the first CustomerOtp 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 {CustomerOtpFindFirstOrThrowArgs} args - Arguments to find a CustomerOtp
     * @example
     * // Get one CustomerOtp
     * const customerOtp = await prisma.customerOtp.findFirstOrThrow({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     */
    findFirstOrThrow<T extends CustomerOtpFindFirstOrThrowArgs>(args?: SelectSubset<T, CustomerOtpFindFirstOrThrowArgs<ExtArgs>>): Prisma__CustomerOtpClient<$Result.GetResult<Prisma.$CustomerOtpPayload<ExtArgs>, T, "findFirstOrThrow">, never, ExtArgs>

    /**
     * Find zero or more CustomerOtps that matches the filter.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {CustomerOtpFindManyArgs} args - Arguments to filter and select certain fields only.
     * @example
     * // Get all CustomerOtps
     * const customerOtps = await prisma.customerOtp.findMany()
     * 
     * // Get first 10 CustomerOtps
     * const customerOtps = await prisma.customerOtp.findMany({ take: 10 })
     * 
     * // Only select the `id`
     * const customerOtpWithIdOnly = await prisma.customerOtp.findMany({ select: { id: true } })
     * 
     */
    findMany<T extends CustomerOtpFindManyArgs>(args?: SelectSubset<T, CustomerOtpFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CustomerOtpPayload<ExtArgs>, T, "findMany">>

    /**
     * Create a CustomerOtp.
     * @param {CustomerOtpCreateArgs} args - Arguments to create a CustomerOtp.
     * @example
     * // Create one CustomerOtp
     * const CustomerOtp = await prisma.customerOtp.create({
     *   data: {
     *     // ... data to create a CustomerOtp
     *   }
     * })
     * 
     */
    create<T extends CustomerOtpCreateArgs>(args: SelectSubset<T, CustomerOtpCreateArgs<ExtArgs>>): Prisma__CustomerOtpClient<$Result.GetResult<Prisma.$CustomerOtpPayload<ExtArgs>, T, "create">, never, ExtArgs>

    /**
     * Create many CustomerOtps.
     * @param {CustomerOtpCreateManyArgs} args - Arguments to create many CustomerOtps.
     * @example
     * // Create many CustomerOtps
     * const customerOtp = await prisma.customerOtp.createMany({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     *     
     */
    createMany<T extends CustomerOtpCreateManyArgs>(args?: SelectSubset<T, CustomerOtpCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create many CustomerOtps and returns the data saved in the database.
     * @param {CustomerOtpCreateManyAndReturnArgs} args - Arguments to create many CustomerOtps.
     * @example
     * // Create many CustomerOtps
     * const customerOtp = await prisma.customerOtp.createManyAndReturn({
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * 
     * // Create many CustomerOtps and only return the `id`
     * const customerOtpWithIdOnly = await prisma.customerOtp.createManyAndReturn({ 
     *   select: { id: true },
     *   data: [
     *     // ... provide data here
     *   ]
     * })
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * 
     */
    createManyAndReturn<T extends CustomerOtpCreateManyAndReturnArgs>(args?: SelectSubset<T, CustomerOtpCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$CustomerOtpPayload<ExtArgs>, T, "createManyAndReturn">>

    /**
     * Delete a CustomerOtp.
     * @param {CustomerOtpDeleteArgs} args - Arguments to delete one CustomerOtp.
     * @example
     * // Delete one CustomerOtp
     * const CustomerOtp = await prisma.customerOtp.delete({
     *   where: {
     *     // ... filter to delete one CustomerOtp
     *   }
     * })
     * 
     */
    delete<T extends CustomerOtpDeleteArgs>(args: SelectSubset<T, CustomerOtpDeleteArgs<ExtArgs>>): Prisma__CustomerOtpClient<$Result.GetResult<Prisma.$CustomerOtpPayload<ExtArgs>, T, "delete">, never, ExtArgs>

    /**
     * Update one CustomerOtp.
     * @param {CustomerOtpUpdateArgs} args - Arguments to update one CustomerOtp.
     * @example
     * // Update one CustomerOtp
     * const customerOtp = await prisma.customerOtp.update({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    update<T extends CustomerOtpUpdateArgs>(args: SelectSubset<T, CustomerOtpUpdateArgs<ExtArgs>>): Prisma__CustomerOtpClient<$Result.GetResult<Prisma.$CustomerOtpPayload<ExtArgs>, T, "update">, never, ExtArgs>

    /**
     * Delete zero or more CustomerOtps.
     * @param {CustomerOtpDeleteManyArgs} args - Arguments to filter CustomerOtps to delete.
     * @example
     * // Delete a few CustomerOtps
     * const { count } = await prisma.customerOtp.deleteMany({
     *   where: {
     *     // ... provide filter here
     *   }
     * })
     * 
     */
    deleteMany<T extends CustomerOtpDeleteManyArgs>(args?: SelectSubset<T, CustomerOtpDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Update zero or more CustomerOtps.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {CustomerOtpUpdateManyArgs} args - Arguments to update one or more rows.
     * @example
     * // Update many CustomerOtps
     * const customerOtp = await prisma.customerOtp.updateMany({
     *   where: {
     *     // ... provide filter here
     *   },
     *   data: {
     *     // ... provide data here
     *   }
     * })
     * 
     */
    updateMany<T extends CustomerOtpUpdateManyArgs>(args: SelectSubset<T, CustomerOtpUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>

    /**
     * Create or update one CustomerOtp.
     * @param {CustomerOtpUpsertArgs} args - Arguments to update or create a CustomerOtp.
     * @example
     * // Update or create a CustomerOtp
     * const customerOtp = await prisma.customerOtp.upsert({
     *   create: {
     *     // ... data to create a CustomerOtp
     *   },
     *   update: {
     *     // ... in case it already exists, update
     *   },
     *   where: {
     *     // ... the filter for the CustomerOtp we want to update
     *   }
     * })
     */
    upsert<T extends CustomerOtpUpsertArgs>(args: SelectSubset<T, CustomerOtpUpsertArgs<ExtArgs>>): Prisma__CustomerOtpClient<$Result.GetResult<Prisma.$CustomerOtpPayload<ExtArgs>, T, "upsert">, never, ExtArgs>


    /**
     * Count the number of CustomerOtps.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {CustomerOtpCountArgs} args - Arguments to filter CustomerOtps to count.
     * @example
     * // Count the number of CustomerOtps
     * const count = await prisma.customerOtp.count({
     *   where: {
     *     // ... the filter for the CustomerOtps we want to count
     *   }
     * })
    **/
    count<T extends CustomerOtpCountArgs>(
      args?: Subset<T, CustomerOtpCountArgs>,
    ): Prisma.PrismaPromise<
      T extends $Utils.Record<'select', any>
        ? T['select'] extends true
          ? number
          : GetScalarType<T['select'], CustomerOtpCountAggregateOutputType>
        : number
    >

    /**
     * Allows you to perform aggregations operations on a CustomerOtp.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {CustomerOtpAggregateArgs} 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 CustomerOtpAggregateArgs>(args: Subset<T, CustomerOtpAggregateArgs>): Prisma.PrismaPromise<GetCustomerOtpAggregateType<T>>

    /**
     * Group by CustomerOtp.
     * Note, that providing `undefined` is treated as the value not being there.
     * Read more here: https://pris.ly/d/null-undefined
     * @param {CustomerOtpGroupByArgs} 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 CustomerOtpGroupByArgs,
      HasSelectOrTake extends Or<
        Extends<'skip', Keys<T>>,
        Extends<'take', Keys<T>>
      >,
      OrderByArg extends True extends HasSelectOrTake
        ? { orderBy: CustomerOtpGroupByArgs['orderBy'] }
        : { orderBy?: CustomerOtpGroupByArgs['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, CustomerOtpGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetCustomerOtpGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
  /**
   * Fields of the CustomerOtp model
   */
  readonly fields: CustomerOtpFieldRefs;
  }

  /**
   * The delegate class that acts as a "Promise-like" for CustomerOtp.
   * 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__CustomerOtpClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> extends Prisma.PrismaPromise<T> {
    readonly [Symbol.toStringTag]: "PrismaPromise"
    customer<T extends CustomerDefaultArgs<ExtArgs> = {}>(args?: Subset<T, CustomerDefaultArgs<ExtArgs>>): Prisma__CustomerClient<$Result.GetResult<Prisma.$CustomerPayload<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 CustomerOtp model
   */ 
  interface CustomerOtpFieldRefs {
    readonly id: FieldRef<"CustomerOtp", 'String'>
    readonly mobile: FieldRef<"CustomerOtp", 'String'>
    readonly customerId: FieldRef<"CustomerOtp", 'String'>
    readonly codeHash: FieldRef<"CustomerOtp", 'String'>
    readonly expiresAt: FieldRef<"CustomerOtp", 'DateTime'>
    readonly attempts: FieldRef<"CustomerOtp", 'Int'>
    readonly consumedAt: FieldRef<"CustomerOtp", 'DateTime'>
    readonly requestIp: FieldRef<"CustomerOtp", 'String'>
    readonly createdAt: FieldRef<"CustomerOtp", 'DateTime'>
  }
    

  // Custom InputTypes
  /**
   * CustomerOtp findUnique
   */
  export type CustomerOtpFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerOtp
     */
    select?: CustomerOtpSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerOtpInclude<ExtArgs> | null
    /**
     * Filter, which CustomerOtp to fetch.
     */
    where: CustomerOtpWhereUniqueInput
  }

  /**
   * CustomerOtp findUniqueOrThrow
   */
  export type CustomerOtpFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerOtp
     */
    select?: CustomerOtpSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerOtpInclude<ExtArgs> | null
    /**
     * Filter, which CustomerOtp to fetch.
     */
    where: CustomerOtpWhereUniqueInput
  }

  /**
   * CustomerOtp findFirst
   */
  export type CustomerOtpFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerOtp
     */
    select?: CustomerOtpSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerOtpInclude<ExtArgs> | null
    /**
     * Filter, which CustomerOtp to fetch.
     */
    where?: CustomerOtpWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CustomerOtps to fetch.
     */
    orderBy?: CustomerOtpOrderByWithRelationInput | CustomerOtpOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for CustomerOtps.
     */
    cursor?: CustomerOtpWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CustomerOtps from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` CustomerOtps.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of CustomerOtps.
     */
    distinct?: CustomerOtpScalarFieldEnum | CustomerOtpScalarFieldEnum[]
  }

  /**
   * CustomerOtp findFirstOrThrow
   */
  export type CustomerOtpFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerOtp
     */
    select?: CustomerOtpSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerOtpInclude<ExtArgs> | null
    /**
     * Filter, which CustomerOtp to fetch.
     */
    where?: CustomerOtpWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CustomerOtps to fetch.
     */
    orderBy?: CustomerOtpOrderByWithRelationInput | CustomerOtpOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for searching for CustomerOtps.
     */
    cursor?: CustomerOtpWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CustomerOtps from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` CustomerOtps.
     */
    skip?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
     * 
     * Filter by unique combinations of CustomerOtps.
     */
    distinct?: CustomerOtpScalarFieldEnum | CustomerOtpScalarFieldEnum[]
  }

  /**
   * CustomerOtp findMany
   */
  export type CustomerOtpFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerOtp
     */
    select?: CustomerOtpSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerOtpInclude<ExtArgs> | null
    /**
     * Filter, which CustomerOtps to fetch.
     */
    where?: CustomerOtpWhereInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
     * 
     * Determine the order of CustomerOtps to fetch.
     */
    orderBy?: CustomerOtpOrderByWithRelationInput | CustomerOtpOrderByWithRelationInput[]
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
     * 
     * Sets the position for listing CustomerOtps.
     */
    cursor?: CustomerOtpWhereUniqueInput
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Take `±n` CustomerOtps from the position of the cursor.
     */
    take?: number
    /**
     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
     * 
     * Skip the first `n` CustomerOtps.
     */
    skip?: number
    distinct?: CustomerOtpScalarFieldEnum | CustomerOtpScalarFieldEnum[]
  }

  /**
   * CustomerOtp create
   */
  export type CustomerOtpCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerOtp
     */
    select?: CustomerOtpSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerOtpInclude<ExtArgs> | null
    /**
     * The data needed to create a CustomerOtp.
     */
    data: XOR<CustomerOtpCreateInput, CustomerOtpUncheckedCreateInput>
  }

  /**
   * CustomerOtp createMany
   */
  export type CustomerOtpCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to create many CustomerOtps.
     */
    data: CustomerOtpCreateManyInput | CustomerOtpCreateManyInput[]
    skipDuplicates?: boolean
  }

  /**
   * CustomerOtp createManyAndReturn
   */
  export type CustomerOtpCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerOtp
     */
    select?: CustomerOtpSelectCreateManyAndReturn<ExtArgs> | null
    /**
     * The data used to create many CustomerOtps.
     */
    data: CustomerOtpCreateManyInput | CustomerOtpCreateManyInput[]
    skipDuplicates?: boolean
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerOtpIncludeCreateManyAndReturn<ExtArgs> | null
  }

  /**
   * CustomerOtp update
   */
  export type CustomerOtpUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerOtp
     */
    select?: CustomerOtpSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerOtpInclude<ExtArgs> | null
    /**
     * The data needed to update a CustomerOtp.
     */
    data: XOR<CustomerOtpUpdateInput, CustomerOtpUncheckedUpdateInput>
    /**
     * Choose, which CustomerOtp to update.
     */
    where: CustomerOtpWhereUniqueInput
  }

  /**
   * CustomerOtp updateMany
   */
  export type CustomerOtpUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * The data used to update CustomerOtps.
     */
    data: XOR<CustomerOtpUpdateManyMutationInput, CustomerOtpUncheckedUpdateManyInput>
    /**
     * Filter which CustomerOtps to update
     */
    where?: CustomerOtpWhereInput
  }

  /**
   * CustomerOtp upsert
   */
  export type CustomerOtpUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerOtp
     */
    select?: CustomerOtpSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerOtpInclude<ExtArgs> | null
    /**
     * The filter to search for the CustomerOtp to update in case it exists.
     */
    where: CustomerOtpWhereUniqueInput
    /**
     * In case the CustomerOtp found by the `where` argument doesn't exist, create a new CustomerOtp with this data.
     */
    create: XOR<CustomerOtpCreateInput, CustomerOtpUncheckedCreateInput>
    /**
     * In case the CustomerOtp was found with the provided `where` argument, update it with this data.
     */
    update: XOR<CustomerOtpUpdateInput, CustomerOtpUncheckedUpdateInput>
  }

  /**
   * CustomerOtp delete
   */
  export type CustomerOtpDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerOtp
     */
    select?: CustomerOtpSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerOtpInclude<ExtArgs> | null
    /**
     * Filter which CustomerOtp to delete.
     */
    where: CustomerOtpWhereUniqueInput
  }

  /**
   * CustomerOtp deleteMany
   */
  export type CustomerOtpDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Filter which CustomerOtps to delete
     */
    where?: CustomerOtpWhereInput
  }

  /**
   * CustomerOtp without action
   */
  export type CustomerOtpDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
    /**
     * Select specific fields to fetch from the CustomerOtp
     */
    select?: CustomerOtpSelect<ExtArgs> | null
    /**
     * Choose, which related nodes to fetch as well
     */
    include?: CustomerOtpInclude<ExtArgs> | null
  }


  /**
   * Enums
   */

  export const TransactionIsolationLevel: {
    ReadUncommitted: 'ReadUncommitted',
    ReadCommitted: 'ReadCommitted',
    RepeatableRead: 'RepeatableRead',
    Serializable: 'Serializable'
  };

  export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel]


  export const CityScalarFieldEnum: {
    id: 'id',
    name: 'name',
    province: 'province',
    percent: 'percent',
    percentAux: 'percentAux'
  };

  export type CityScalarFieldEnum = (typeof CityScalarFieldEnum)[keyof typeof CityScalarFieldEnum]


  export const AdminUserScalarFieldEnum: {
    id: 'id',
    fullName: 'fullName',
    firstName: 'firstName',
    lastName: 'lastName',
    mobile: 'mobile',
    passwordHash: 'passwordHash',
    role: 'role',
    userTypeId: 'userTypeId',
    branchId: 'branchId',
    wagePercent: 'wagePercent',
    isActive: 'isActive',
    createdAt: 'createdAt',
    avatarFileId: 'avatarFileId',
    address: 'address',
    storeName: 'storeName',
    pasazhName: 'pasazhName',
    memberCode: 'memberCode'
  };

  export type AdminUserScalarFieldEnum = (typeof AdminUserScalarFieldEnum)[keyof typeof AdminUserScalarFieldEnum]


  export const AppSessionScalarFieldEnum: {
    id: 'id',
    jti: 'jti',
    subjectId: 'subjectId',
    subjectType: 'subjectType',
    mobile: 'mobile',
    iamSessionId: 'iamSessionId',
    iamSub: 'iamSub',
    ipAddress: 'ipAddress',
    userAgent: 'userAgent',
    createdAt: 'createdAt',
    expiresAt: 'expiresAt',
    lastSeenAt: 'lastSeenAt',
    revokedAt: 'revokedAt',
    revokedReason: 'revokedReason'
  };

  export type AppSessionScalarFieldEnum = (typeof AppSessionScalarFieldEnum)[keyof typeof AppSessionScalarFieldEnum]


  export const AdminSessionScalarFieldEnum: {
    id: 'id',
    jti: 'jti',
    adminUserId: 'adminUserId',
    iamSessionId: 'iamSessionId',
    iamSub: 'iamSub',
    ipAddress: 'ipAddress',
    userAgent: 'userAgent',
    createdAt: 'createdAt',
    expiresAt: 'expiresAt',
    lastSeenAt: 'lastSeenAt',
    revokedAt: 'revokedAt',
    revokedReason: 'revokedReason'
  };

  export type AdminSessionScalarFieldEnum = (typeof AdminSessionScalarFieldEnum)[keyof typeof AdminSessionScalarFieldEnum]


  export const SalesExpertProfileScalarFieldEnum: {
    id: 'id',
    adminUserId: 'adminUserId',
    cityId: 'cityId',
    gramLevel: 'gramLevel',
    phone: 'phone',
    nationalCode: 'nationalCode',
    tradingCustomerId: 'tradingCustomerId',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

  export type SalesExpertProfileScalarFieldEnum = (typeof SalesExpertProfileScalarFieldEnum)[keyof typeof SalesExpertProfileScalarFieldEnum]


  export const CustomerScalarFieldEnum: {
    id: 'id',
    fullName: 'fullName',
    firstName: 'firstName',
    lastName: 'lastName',
    mobile: 'mobile',
    nationalCode: 'nationalCode',
    passwordHash: 'passwordHash',
    cityId: 'cityId',
    kind: 'kind',
    phone: 'phone',
    address: 'address',
    storeName: 'storeName',
    pasazhName: 'pasazhName',
    zone: 'zone',
    memberCode: 'memberCode',
    referredByAgentId: 'referredByAgentId',
    goldCreditLimitGrams: 'goldCreditLimitGrams',
    goldDebtGrams: 'goldDebtGrams',
    fiatDebtRial: 'fiatDebtRial',
    makingChargeOffsetPercent: 'makingChargeOffsetPercent',
    verificationStep: 'verificationStep',
    nationalIdImageUrl: 'nationalIdImageUrl',
    businessLicenseUrl: 'businessLicenseUrl',
    shopImageUrl: 'shopImageUrl',
    avatarFileId: 'avatarFileId',
    canPlaceOrders: 'canPlaceOrders',
    isActive: 'isActive',
    isArchived: 'isArchived',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

  export type CustomerScalarFieldEnum = (typeof CustomerScalarFieldEnum)[keyof typeof CustomerScalarFieldEnum]


  export const CustomerAddressScalarFieldEnum: {
    id: 'id',
    customerId: 'customerId',
    cityId: 'cityId',
    addressLine: 'addressLine',
    isDefault: 'isDefault'
  };

  export type CustomerAddressScalarFieldEnum = (typeof CustomerAddressScalarFieldEnum)[keyof typeof CustomerAddressScalarFieldEnum]


  export const BranchScalarFieldEnum: {
    id: 'id',
    name: 'name',
    address: 'address',
    phone: 'phone',
    isActive: 'isActive',
    cityId: 'cityId'
  };

  export type BranchScalarFieldEnum = (typeof BranchScalarFieldEnum)[keyof typeof BranchScalarFieldEnum]


  export const WorkshopScalarFieldEnum: {
    id: 'id',
    name: 'name',
    address: 'address',
    phone: 'phone',
    supervisorId: 'supervisorId',
    isActive: 'isActive'
  };

  export type WorkshopScalarFieldEnum = (typeof WorkshopScalarFieldEnum)[keyof typeof WorkshopScalarFieldEnum]


  export const CategoryScalarFieldEnum: {
    id: 'id',
    title: 'title',
    type: 'type',
    imageUrl: 'imageUrl',
    iconUrl: 'iconUrl',
    metaTag: 'metaTag',
    description: 'description',
    parentId: 'parentId'
  };

  export type CategoryScalarFieldEnum = (typeof CategoryScalarFieldEnum)[keyof typeof CategoryScalarFieldEnum]


  export const BrandScalarFieldEnum: {
    id: 'id',
    title: 'title'
  };

  export type BrandScalarFieldEnum = (typeof BrandScalarFieldEnum)[keyof typeof BrandScalarFieldEnum]


  export const CollectionScalarFieldEnum: {
    id: 'id',
    title: 'title',
    description: 'description',
    isActive: 'isActive'
  };

  export type CollectionScalarFieldEnum = (typeof CollectionScalarFieldEnum)[keyof typeof CollectionScalarFieldEnum]


  export const CollectionProductScalarFieldEnum: {
    collectionId: 'collectionId',
    productId: 'productId'
  };

  export type CollectionProductScalarFieldEnum = (typeof CollectionProductScalarFieldEnum)[keyof typeof CollectionProductScalarFieldEnum]


  export const ProductScalarFieldEnum: {
    id: 'id',
    title: 'title',
    description: 'description',
    categoryId: 'categoryId',
    brandId: 'brandId',
    productCode: 'productCode',
    showType: 'showType',
    isActive: 'isActive',
    createdAt: 'createdAt'
  };

  export type ProductScalarFieldEnum = (typeof ProductScalarFieldEnum)[keyof typeof ProductScalarFieldEnum]


  export const ProductImageScalarFieldEnum: {
    id: 'id',
    productId: 'productId',
    url: 'url',
    sortOrder: 'sortOrder',
    role: 'role'
  };

  export type ProductImageScalarFieldEnum = (typeof ProductImageScalarFieldEnum)[keyof typeof ProductImageScalarFieldEnum]


  export const ProductVariantScalarFieldEnum: {
    id: 'id',
    productId: 'productId',
    title: 'title',
    sku: 'sku',
    rashWeightGrams: 'rashWeightGrams',
    defaultWagePercent: 'defaultWagePercent',
    qty: 'qty',
    isPreOrder: 'isPreOrder',
    isActive: 'isActive',
    imageId: 'imageId'
  };

  export type ProductVariantScalarFieldEnum = (typeof ProductVariantScalarFieldEnum)[keyof typeof ProductVariantScalarFieldEnum]


  export const OrderScalarFieldEnum: {
    id: 'id',
    orderNumber: 'orderNumber',
    customerId: 'customerId',
    branchId: 'branchId',
    channel: 'channel',
    status: 'status',
    totalGoldWeightGrams: 'totalGoldWeightGrams',
    wageWeightGrams: 'wageWeightGrams',
    flatRialCharge: 'flatRialCharge',
    isSuspendedOverCreditLimit: 'isSuspendedOverCreditLimit',
    deliveredAt: 'deliveredAt',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

  export type OrderScalarFieldEnum = (typeof OrderScalarFieldEnum)[keyof typeof OrderScalarFieldEnum]


  export const OrderItemScalarFieldEnum: {
    id: 'id',
    orderId: 'orderId',
    productVariantId: 'productVariantId',
    quantity: 'quantity',
    rashWeightGramsSnapshot: 'rashWeightGramsSnapshot',
    wagePercentSnapshot: 'wagePercentSnapshot',
    discountPercentSnapshot: 'discountPercentSnapshot',
    computedWeightGrams: 'computedWeightGrams',
    flatRialCharge: 'flatRialCharge'
  };

  export type OrderItemScalarFieldEnum = (typeof OrderItemScalarFieldEnum)[keyof typeof OrderItemScalarFieldEnum]


  export const OrderStatusEventScalarFieldEnum: {
    id: 'id',
    orderId: 'orderId',
    fromStatus: 'fromStatus',
    toStatus: 'toStatus',
    note: 'note',
    actorAdminUserId: 'actorAdminUserId',
    createdAt: 'createdAt'
  };

  export type OrderStatusEventScalarFieldEnum = (typeof OrderStatusEventScalarFieldEnum)[keyof typeof OrderStatusEventScalarFieldEnum]


  export const PreOrderScalarFieldEnum: {
    id: 'id',
    customerId: 'customerId',
    cityId: 'cityId',
    workshopId: 'workshopId',
    status: 'status',
    designImageUrl: 'designImageUrl',
    colorName: 'colorName',
    sizeSpec: 'sizeSpec',
    stoneColor: 'stoneColor',
    minaColor: 'minaColor',
    estimatedWeightGrams: 'estimatedWeightGrams',
    estimatedPriceRial: 'estimatedPriceRial',
    description: 'description',
    convertedOrderId: 'convertedOrderId',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

  export type PreOrderScalarFieldEnum = (typeof PreOrderScalarFieldEnum)[keyof typeof PreOrderScalarFieldEnum]


  export const PreOrderStatusEventScalarFieldEnum: {
    id: 'id',
    preOrderId: 'preOrderId',
    changes: 'changes',
    actorAdminUserId: 'actorAdminUserId',
    ipAddress: 'ipAddress',
    createdAt: 'createdAt'
  };

  export type PreOrderStatusEventScalarFieldEnum = (typeof PreOrderStatusEventScalarFieldEnum)[keyof typeof PreOrderStatusEventScalarFieldEnum]


  export const LedgerEntryScalarFieldEnum: {
    id: 'id',
    customerId: 'customerId',
    currency: 'currency',
    direction: 'direction',
    sourceType: 'sourceType',
    amount: 'amount',
    karatPerMille: 'karatPerMille',
    pricePerGramRialAtEntry: 'pricePerGramRialAtEntry',
    orderId: 'orderId',
    confirmed: 'confirmed',
    confirmedAt: 'confirmedAt',
    postedByAdminUserId: 'postedByAdminUserId',
    labName: 'labName',
    hallmark: 'hallmark',
    accountName: 'accountName',
    bankName: 'bankName',
    transferTo: 'transferTo',
    originalValue: 'originalValue',
    priceRial: 'priceRial',
    receivedAt: 'receivedAt',
    note: 'note',
    createdAt: 'createdAt'
  };

  export type LedgerEntryScalarFieldEnum = (typeof LedgerEntryScalarFieldEnum)[keyof typeof LedgerEntryScalarFieldEnum]


  export const GoldPriceQuoteScalarFieldEnum: {
    id: 'id',
    karatPerMille: 'karatPerMille',
    pricePerGramRial: 'pricePerGramRial',
    source: 'source',
    quotedAt: 'quotedAt'
  };

  export type GoldPriceQuoteScalarFieldEnum = (typeof GoldPriceQuoteScalarFieldEnum)[keyof typeof GoldPriceQuoteScalarFieldEnum]


  export const WalletBonusScalarFieldEnum: {
    id: 'id',
    customerId: 'customerId',
    orderId: 'orderId',
    goldGrams: 'goldGrams',
    grantedAt: 'grantedAt',
    expiresAt: 'expiresAt',
    consumedAt: 'consumedAt',
    isActive: 'isActive'
  };

  export type WalletBonusScalarFieldEnum = (typeof WalletBonusScalarFieldEnum)[keyof typeof WalletBonusScalarFieldEnum]


  export const UserTypeScalarFieldEnum: {
    id: 'id',
    title: 'title',
    isActive: 'isActive',
    createdAt: 'createdAt'
  };

  export type UserTypeScalarFieldEnum = (typeof UserTypeScalarFieldEnum)[keyof typeof UserTypeScalarFieldEnum]


  export const PermissionScalarFieldEnum: {
    rid: 'rid',
    userTypeId: 'userTypeId'
  };

  export type PermissionScalarFieldEnum = (typeof PermissionScalarFieldEnum)[keyof typeof PermissionScalarFieldEnum]


  export const CommentScalarFieldEnum: {
    id: 'id',
    productId: 'productId',
    customerId: 'customerId',
    body: 'body',
    status: 'status',
    replyToId: 'replyToId',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

  export type CommentScalarFieldEnum = (typeof CommentScalarFieldEnum)[keyof typeof CommentScalarFieldEnum]


  export const SettingScalarFieldEnum: {
    key: 'key',
    value: 'value',
    updatedAt: 'updatedAt'
  };

  export type SettingScalarFieldEnum = (typeof SettingScalarFieldEnum)[keyof typeof SettingScalarFieldEnum]


  export const PromotionScalarFieldEnum: {
    id: 'id',
    title: 'title',
    description: 'description',
    scope: 'scope',
    usage: 'usage',
    discountPercent: 'discountPercent',
    isActive: 'isActive',
    platform: 'platform',
    startsAt: 'startsAt',
    endsAt: 'endsAt',
    productId: 'productId',
    categoryId: 'categoryId',
    customerId: 'customerId',
    brandId: 'brandId',
    createdAt: 'createdAt',
    updatedAt: 'updatedAt'
  };

  export type PromotionScalarFieldEnum = (typeof PromotionScalarFieldEnum)[keyof typeof PromotionScalarFieldEnum]


  export const PromotionExclusionScalarFieldEnum: {
    id: 'id',
    type: 'type',
    itemId: 'itemId',
    createdAt: 'createdAt'
  };

  export type PromotionExclusionScalarFieldEnum = (typeof PromotionExclusionScalarFieldEnum)[keyof typeof PromotionExclusionScalarFieldEnum]


  export const BranchAllocationScalarFieldEnum: {
    id: 'id',
    branchId: 'branchId',
    allocatorAdminUserId: 'allocatorAdminUserId',
    note: 'note',
    createdAt: 'createdAt'
  };

  export type BranchAllocationScalarFieldEnum = (typeof BranchAllocationScalarFieldEnum)[keyof typeof BranchAllocationScalarFieldEnum]


  export const BranchAllocationItemScalarFieldEnum: {
    id: 'id',
    allocationId: 'allocationId',
    productId: 'productId',
    weightGrams: 'weightGrams'
  };

  export type BranchAllocationItemScalarFieldEnum = (typeof BranchAllocationItemScalarFieldEnum)[keyof typeof BranchAllocationItemScalarFieldEnum]


  export const SmsMessageScalarFieldEnum: {
    id: 'id',
    audience: 'audience',
    recipients: 'recipients',
    body: 'body',
    sentCount: 'sentCount',
    sentByAdminUserId: 'sentByAdminUserId',
    createdAt: 'createdAt'
  };

  export type SmsMessageScalarFieldEnum = (typeof SmsMessageScalarFieldEnum)[keyof typeof SmsMessageScalarFieldEnum]


  export const NotificationScalarFieldEnum: {
    id: 'id',
    title: 'title',
    body: 'body',
    audience: 'audience',
    sentByAdminUserId: 'sentByAdminUserId',
    createdAt: 'createdAt'
  };

  export type NotificationScalarFieldEnum = (typeof NotificationScalarFieldEnum)[keyof typeof NotificationScalarFieldEnum]


  export const NotificationRecipientScalarFieldEnum: {
    id: 'id',
    notificationId: 'notificationId',
    customerId: 'customerId',
    readAt: 'readAt'
  };

  export type NotificationRecipientScalarFieldEnum = (typeof NotificationRecipientScalarFieldEnum)[keyof typeof NotificationRecipientScalarFieldEnum]


  export const NewsletterSubscriberScalarFieldEnum: {
    id: 'id',
    email: 'email',
    mobile: 'mobile',
    createdAt: 'createdAt'
  };

  export type NewsletterSubscriberScalarFieldEnum = (typeof NewsletterSubscriberScalarFieldEnum)[keyof typeof NewsletterSubscriberScalarFieldEnum]


  export const CustomerActivityLogScalarFieldEnum: {
    id: 'id',
    customerId: 'customerId',
    action: 'action',
    detail: 'detail',
    createdAt: 'createdAt'
  };

  export type CustomerActivityLogScalarFieldEnum = (typeof CustomerActivityLogScalarFieldEnum)[keyof typeof CustomerActivityLogScalarFieldEnum]


  export const UploadedFileScalarFieldEnum: {
    id: 'id',
    url: 'url',
    originalName: 'originalName',
    mimeType: 'mimeType',
    sizeBytes: 'sizeBytes',
    purpose: 'purpose',
    uploadedByAdminUserId: 'uploadedByAdminUserId',
    createdAt: 'createdAt'
  };

  export type UploadedFileScalarFieldEnum = (typeof UploadedFileScalarFieldEnum)[keyof typeof UploadedFileScalarFieldEnum]


  export const CustomerOtpScalarFieldEnum: {
    id: 'id',
    mobile: 'mobile',
    customerId: 'customerId',
    codeHash: 'codeHash',
    expiresAt: 'expiresAt',
    attempts: 'attempts',
    consumedAt: 'consumedAt',
    requestIp: 'requestIp',
    createdAt: 'createdAt'
  };

  export type CustomerOtpScalarFieldEnum = (typeof CustomerOtpScalarFieldEnum)[keyof typeof CustomerOtpScalarFieldEnum]


  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 QueryMode: {
    default: 'default',
    insensitive: 'insensitive'
  };

  export type QueryMode = (typeof QueryMode)[keyof typeof QueryMode]


  export const NullsOrder: {
    first: 'first',
    last: 'last'
  };

  export type NullsOrder = (typeof NullsOrder)[keyof typeof NullsOrder]


  export const JsonNullValueFilter: {
    DbNull: typeof DbNull,
    JsonNull: typeof JsonNull,
    AnyNull: typeof AnyNull
  };

  export type JsonNullValueFilter = (typeof JsonNullValueFilter)[keyof typeof JsonNullValueFilter]


  /**
   * Field references 
   */


  /**
   * Reference to a field of type 'String'
   */
  export type StringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String'>
    


  /**
   * Reference to a field of type 'String[]'
   */
  export type ListStringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String[]'>
    


  /**
   * Reference to a field of type 'Decimal'
   */
  export type DecimalFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Decimal'>
    


  /**
   * Reference to a field of type 'Decimal[]'
   */
  export type ListDecimalFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Decimal[]'>
    


  /**
   * Reference to a field of type 'AdminRole'
   */
  export type EnumAdminRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'AdminRole'>
    


  /**
   * Reference to a field of type 'AdminRole[]'
   */
  export type ListEnumAdminRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'AdminRole[]'>
    


  /**
   * Reference to a field of type 'Int'
   */
  export type IntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int'>
    


  /**
   * Reference to a field of type 'Int[]'
   */
  export type ListIntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int[]'>
    


  /**
   * Reference to a field of type 'Boolean'
   */
  export type BooleanFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Boolean'>
    


  /**
   * Reference to a field of type 'DateTime'
   */
  export type DateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime'>
    


  /**
   * Reference to a field of type 'DateTime[]'
   */
  export type ListDateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime[]'>
    


  /**
   * Reference to a field of type 'CustomerKind'
   */
  export type EnumCustomerKindFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'CustomerKind'>
    


  /**
   * Reference to a field of type 'CustomerKind[]'
   */
  export type ListEnumCustomerKindFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'CustomerKind[]'>
    


  /**
   * Reference to a field of type 'VerificationStep'
   */
  export type EnumVerificationStepFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'VerificationStep'>
    


  /**
   * Reference to a field of type 'VerificationStep[]'
   */
  export type ListEnumVerificationStepFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'VerificationStep[]'>
    


  /**
   * Reference to a field of type 'ProductImageRole'
   */
  export type EnumProductImageRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ProductImageRole'>
    


  /**
   * Reference to a field of type 'ProductImageRole[]'
   */
  export type ListEnumProductImageRoleFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'ProductImageRole[]'>
    


  /**
   * Reference to a field of type 'OrderChannel'
   */
  export type EnumOrderChannelFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'OrderChannel'>
    


  /**
   * Reference to a field of type 'OrderChannel[]'
   */
  export type ListEnumOrderChannelFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'OrderChannel[]'>
    


  /**
   * Reference to a field of type 'OrderStatus'
   */
  export type EnumOrderStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'OrderStatus'>
    


  /**
   * Reference to a field of type 'OrderStatus[]'
   */
  export type ListEnumOrderStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'OrderStatus[]'>
    


  /**
   * Reference to a field of type 'PreOrderStatus'
   */
  export type EnumPreOrderStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'PreOrderStatus'>
    


  /**
   * Reference to a field of type 'PreOrderStatus[]'
   */
  export type ListEnumPreOrderStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'PreOrderStatus[]'>
    


  /**
   * Reference to a field of type 'Json'
   */
  export type JsonFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Json'>
    


  /**
   * Reference to a field of type 'LedgerCurrency'
   */
  export type EnumLedgerCurrencyFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'LedgerCurrency'>
    


  /**
   * Reference to a field of type 'LedgerCurrency[]'
   */
  export type ListEnumLedgerCurrencyFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'LedgerCurrency[]'>
    


  /**
   * Reference to a field of type 'LedgerDirection'
   */
  export type EnumLedgerDirectionFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'LedgerDirection'>
    


  /**
   * Reference to a field of type 'LedgerDirection[]'
   */
  export type ListEnumLedgerDirectionFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'LedgerDirection[]'>
    


  /**
   * Reference to a field of type 'LedgerSourceType'
   */
  export type EnumLedgerSourceTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'LedgerSourceType'>
    


  /**
   * Reference to a field of type 'LedgerSourceType[]'
   */
  export type ListEnumLedgerSourceTypeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'LedgerSourceType[]'>
    


  /**
   * Reference to a field of type 'CommentStatus'
   */
  export type EnumCommentStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'CommentStatus'>
    


  /**
   * Reference to a field of type 'CommentStatus[]'
   */
  export type ListEnumCommentStatusFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'CommentStatus[]'>
    


  /**
   * Reference to a field of type 'PromotionScope'
   */
  export type EnumPromotionScopeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'PromotionScope'>
    


  /**
   * Reference to a field of type 'PromotionScope[]'
   */
  export type ListEnumPromotionScopeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'PromotionScope[]'>
    


  /**
   * Reference to a field of type 'PromotionUsage'
   */
  export type EnumPromotionUsageFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'PromotionUsage'>
    


  /**
   * Reference to a field of type 'PromotionUsage[]'
   */
  export type ListEnumPromotionUsageFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'PromotionUsage[]'>
    


  /**
   * Reference to a field of type 'MessageAudience'
   */
  export type EnumMessageAudienceFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'MessageAudience'>
    


  /**
   * Reference to a field of type 'MessageAudience[]'
   */
  export type ListEnumMessageAudienceFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'MessageAudience[]'>
    


  /**
   * Reference to a field of type 'Float'
   */
  export type FloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float'>
    


  /**
   * Reference to a field of type 'Float[]'
   */
  export type ListFloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float[]'>
    
  /**
   * Deep Input Types
   */


  export type CityWhereInput = {
    AND?: CityWhereInput | CityWhereInput[]
    OR?: CityWhereInput[]
    NOT?: CityWhereInput | CityWhereInput[]
    id?: StringFilter<"City"> | string
    name?: StringFilter<"City"> | string
    province?: StringNullableFilter<"City"> | string | null
    percent?: DecimalNullableFilter<"City"> | Decimal | DecimalJsLike | number | string | null
    percentAux?: DecimalNullableFilter<"City"> | Decimal | DecimalJsLike | number | string | null
    customers?: CustomerListRelationFilter
    addresses?: CustomerAddressListRelationFilter
    branches?: BranchListRelationFilter
    preOrders?: PreOrderListRelationFilter
    salesExpertProfiles?: SalesExpertProfileListRelationFilter
  }

  export type CityOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    province?: SortOrderInput | SortOrder
    percent?: SortOrderInput | SortOrder
    percentAux?: SortOrderInput | SortOrder
    customers?: CustomerOrderByRelationAggregateInput
    addresses?: CustomerAddressOrderByRelationAggregateInput
    branches?: BranchOrderByRelationAggregateInput
    preOrders?: PreOrderOrderByRelationAggregateInput
    salesExpertProfiles?: SalesExpertProfileOrderByRelationAggregateInput
  }

  export type CityWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: CityWhereInput | CityWhereInput[]
    OR?: CityWhereInput[]
    NOT?: CityWhereInput | CityWhereInput[]
    name?: StringFilter<"City"> | string
    province?: StringNullableFilter<"City"> | string | null
    percent?: DecimalNullableFilter<"City"> | Decimal | DecimalJsLike | number | string | null
    percentAux?: DecimalNullableFilter<"City"> | Decimal | DecimalJsLike | number | string | null
    customers?: CustomerListRelationFilter
    addresses?: CustomerAddressListRelationFilter
    branches?: BranchListRelationFilter
    preOrders?: PreOrderListRelationFilter
    salesExpertProfiles?: SalesExpertProfileListRelationFilter
  }, "id">

  export type CityOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    province?: SortOrderInput | SortOrder
    percent?: SortOrderInput | SortOrder
    percentAux?: SortOrderInput | SortOrder
    _count?: CityCountOrderByAggregateInput
    _avg?: CityAvgOrderByAggregateInput
    _max?: CityMaxOrderByAggregateInput
    _min?: CityMinOrderByAggregateInput
    _sum?: CitySumOrderByAggregateInput
  }

  export type CityScalarWhereWithAggregatesInput = {
    AND?: CityScalarWhereWithAggregatesInput | CityScalarWhereWithAggregatesInput[]
    OR?: CityScalarWhereWithAggregatesInput[]
    NOT?: CityScalarWhereWithAggregatesInput | CityScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"City"> | string
    name?: StringWithAggregatesFilter<"City"> | string
    province?: StringNullableWithAggregatesFilter<"City"> | string | null
    percent?: DecimalNullableWithAggregatesFilter<"City"> | Decimal | DecimalJsLike | number | string | null
    percentAux?: DecimalNullableWithAggregatesFilter<"City"> | Decimal | DecimalJsLike | number | string | null
  }

  export type AdminUserWhereInput = {
    AND?: AdminUserWhereInput | AdminUserWhereInput[]
    OR?: AdminUserWhereInput[]
    NOT?: AdminUserWhereInput | AdminUserWhereInput[]
    id?: StringFilter<"AdminUser"> | string
    fullName?: StringFilter<"AdminUser"> | string
    firstName?: StringNullableFilter<"AdminUser"> | string | null
    lastName?: StringNullableFilter<"AdminUser"> | string | null
    mobile?: StringFilter<"AdminUser"> | string
    passwordHash?: StringFilter<"AdminUser"> | string
    role?: EnumAdminRoleFilter<"AdminUser"> | $Enums.AdminRole
    userTypeId?: IntNullableFilter<"AdminUser"> | number | null
    branchId?: StringNullableFilter<"AdminUser"> | string | null
    wagePercent?: DecimalNullableFilter<"AdminUser"> | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFilter<"AdminUser"> | boolean
    createdAt?: DateTimeFilter<"AdminUser"> | Date | string
    avatarFileId?: StringNullableFilter<"AdminUser"> | string | null
    address?: StringNullableFilter<"AdminUser"> | string | null
    storeName?: StringNullableFilter<"AdminUser"> | string | null
    pasazhName?: StringNullableFilter<"AdminUser"> | string | null
    memberCode?: StringNullableFilter<"AdminUser"> | string | null
    userType?: XOR<UserTypeNullableRelationFilter, UserTypeWhereInput> | null
    branch?: XOR<BranchNullableRelationFilter, BranchWhereInput> | null
    avatarFile?: XOR<UploadedFileNullableRelationFilter, UploadedFileWhereInput> | null
    referredCustomers?: CustomerListRelationFilter
    supervisedWorkshops?: WorkshopListRelationFilter
    branchAllocations?: BranchAllocationListRelationFilter
    postedLedgerEntries?: LedgerEntryListRelationFilter
    orderStatusEvents?: OrderStatusEventListRelationFilter
    preOrderStatusEvents?: PreOrderStatusEventListRelationFilter
    sentSmsMessages?: SmsMessageListRelationFilter
    sentNotifications?: NotificationListRelationFilter
    uploadedFiles?: UploadedFileListRelationFilter
    salesExpertProfile?: XOR<SalesExpertProfileNullableRelationFilter, SalesExpertProfileWhereInput> | null
    sessions?: AdminSessionListRelationFilter
  }

  export type AdminUserOrderByWithRelationInput = {
    id?: SortOrder
    fullName?: SortOrder
    firstName?: SortOrderInput | SortOrder
    lastName?: SortOrderInput | SortOrder
    mobile?: SortOrder
    passwordHash?: SortOrder
    role?: SortOrder
    userTypeId?: SortOrderInput | SortOrder
    branchId?: SortOrderInput | SortOrder
    wagePercent?: SortOrderInput | SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    avatarFileId?: SortOrderInput | SortOrder
    address?: SortOrderInput | SortOrder
    storeName?: SortOrderInput | SortOrder
    pasazhName?: SortOrderInput | SortOrder
    memberCode?: SortOrderInput | SortOrder
    userType?: UserTypeOrderByWithRelationInput
    branch?: BranchOrderByWithRelationInput
    avatarFile?: UploadedFileOrderByWithRelationInput
    referredCustomers?: CustomerOrderByRelationAggregateInput
    supervisedWorkshops?: WorkshopOrderByRelationAggregateInput
    branchAllocations?: BranchAllocationOrderByRelationAggregateInput
    postedLedgerEntries?: LedgerEntryOrderByRelationAggregateInput
    orderStatusEvents?: OrderStatusEventOrderByRelationAggregateInput
    preOrderStatusEvents?: PreOrderStatusEventOrderByRelationAggregateInput
    sentSmsMessages?: SmsMessageOrderByRelationAggregateInput
    sentNotifications?: NotificationOrderByRelationAggregateInput
    uploadedFiles?: UploadedFileOrderByRelationAggregateInput
    salesExpertProfile?: SalesExpertProfileOrderByWithRelationInput
    sessions?: AdminSessionOrderByRelationAggregateInput
  }

  export type AdminUserWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    mobile?: string
    AND?: AdminUserWhereInput | AdminUserWhereInput[]
    OR?: AdminUserWhereInput[]
    NOT?: AdminUserWhereInput | AdminUserWhereInput[]
    fullName?: StringFilter<"AdminUser"> | string
    firstName?: StringNullableFilter<"AdminUser"> | string | null
    lastName?: StringNullableFilter<"AdminUser"> | string | null
    passwordHash?: StringFilter<"AdminUser"> | string
    role?: EnumAdminRoleFilter<"AdminUser"> | $Enums.AdminRole
    userTypeId?: IntNullableFilter<"AdminUser"> | number | null
    branchId?: StringNullableFilter<"AdminUser"> | string | null
    wagePercent?: DecimalNullableFilter<"AdminUser"> | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFilter<"AdminUser"> | boolean
    createdAt?: DateTimeFilter<"AdminUser"> | Date | string
    avatarFileId?: StringNullableFilter<"AdminUser"> | string | null
    address?: StringNullableFilter<"AdminUser"> | string | null
    storeName?: StringNullableFilter<"AdminUser"> | string | null
    pasazhName?: StringNullableFilter<"AdminUser"> | string | null
    memberCode?: StringNullableFilter<"AdminUser"> | string | null
    userType?: XOR<UserTypeNullableRelationFilter, UserTypeWhereInput> | null
    branch?: XOR<BranchNullableRelationFilter, BranchWhereInput> | null
    avatarFile?: XOR<UploadedFileNullableRelationFilter, UploadedFileWhereInput> | null
    referredCustomers?: CustomerListRelationFilter
    supervisedWorkshops?: WorkshopListRelationFilter
    branchAllocations?: BranchAllocationListRelationFilter
    postedLedgerEntries?: LedgerEntryListRelationFilter
    orderStatusEvents?: OrderStatusEventListRelationFilter
    preOrderStatusEvents?: PreOrderStatusEventListRelationFilter
    sentSmsMessages?: SmsMessageListRelationFilter
    sentNotifications?: NotificationListRelationFilter
    uploadedFiles?: UploadedFileListRelationFilter
    salesExpertProfile?: XOR<SalesExpertProfileNullableRelationFilter, SalesExpertProfileWhereInput> | null
    sessions?: AdminSessionListRelationFilter
  }, "id" | "mobile">

  export type AdminUserOrderByWithAggregationInput = {
    id?: SortOrder
    fullName?: SortOrder
    firstName?: SortOrderInput | SortOrder
    lastName?: SortOrderInput | SortOrder
    mobile?: SortOrder
    passwordHash?: SortOrder
    role?: SortOrder
    userTypeId?: SortOrderInput | SortOrder
    branchId?: SortOrderInput | SortOrder
    wagePercent?: SortOrderInput | SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    avatarFileId?: SortOrderInput | SortOrder
    address?: SortOrderInput | SortOrder
    storeName?: SortOrderInput | SortOrder
    pasazhName?: SortOrderInput | SortOrder
    memberCode?: SortOrderInput | SortOrder
    _count?: AdminUserCountOrderByAggregateInput
    _avg?: AdminUserAvgOrderByAggregateInput
    _max?: AdminUserMaxOrderByAggregateInput
    _min?: AdminUserMinOrderByAggregateInput
    _sum?: AdminUserSumOrderByAggregateInput
  }

  export type AdminUserScalarWhereWithAggregatesInput = {
    AND?: AdminUserScalarWhereWithAggregatesInput | AdminUserScalarWhereWithAggregatesInput[]
    OR?: AdminUserScalarWhereWithAggregatesInput[]
    NOT?: AdminUserScalarWhereWithAggregatesInput | AdminUserScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"AdminUser"> | string
    fullName?: StringWithAggregatesFilter<"AdminUser"> | string
    firstName?: StringNullableWithAggregatesFilter<"AdminUser"> | string | null
    lastName?: StringNullableWithAggregatesFilter<"AdminUser"> | string | null
    mobile?: StringWithAggregatesFilter<"AdminUser"> | string
    passwordHash?: StringWithAggregatesFilter<"AdminUser"> | string
    role?: EnumAdminRoleWithAggregatesFilter<"AdminUser"> | $Enums.AdminRole
    userTypeId?: IntNullableWithAggregatesFilter<"AdminUser"> | number | null
    branchId?: StringNullableWithAggregatesFilter<"AdminUser"> | string | null
    wagePercent?: DecimalNullableWithAggregatesFilter<"AdminUser"> | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolWithAggregatesFilter<"AdminUser"> | boolean
    createdAt?: DateTimeWithAggregatesFilter<"AdminUser"> | Date | string
    avatarFileId?: StringNullableWithAggregatesFilter<"AdminUser"> | string | null
    address?: StringNullableWithAggregatesFilter<"AdminUser"> | string | null
    storeName?: StringNullableWithAggregatesFilter<"AdminUser"> | string | null
    pasazhName?: StringNullableWithAggregatesFilter<"AdminUser"> | string | null
    memberCode?: StringNullableWithAggregatesFilter<"AdminUser"> | string | null
  }

  export type AppSessionWhereInput = {
    AND?: AppSessionWhereInput | AppSessionWhereInput[]
    OR?: AppSessionWhereInput[]
    NOT?: AppSessionWhereInput | AppSessionWhereInput[]
    id?: StringFilter<"AppSession"> | string
    jti?: StringFilter<"AppSession"> | string
    subjectId?: StringFilter<"AppSession"> | string
    subjectType?: StringFilter<"AppSession"> | string
    mobile?: StringNullableFilter<"AppSession"> | string | null
    iamSessionId?: StringNullableFilter<"AppSession"> | string | null
    iamSub?: StringNullableFilter<"AppSession"> | string | null
    ipAddress?: StringNullableFilter<"AppSession"> | string | null
    userAgent?: StringNullableFilter<"AppSession"> | string | null
    createdAt?: DateTimeFilter<"AppSession"> | Date | string
    expiresAt?: DateTimeNullableFilter<"AppSession"> | Date | string | null
    lastSeenAt?: DateTimeNullableFilter<"AppSession"> | Date | string | null
    revokedAt?: DateTimeNullableFilter<"AppSession"> | Date | string | null
    revokedReason?: StringNullableFilter<"AppSession"> | string | null
  }

  export type AppSessionOrderByWithRelationInput = {
    id?: SortOrder
    jti?: SortOrder
    subjectId?: SortOrder
    subjectType?: SortOrder
    mobile?: SortOrderInput | SortOrder
    iamSessionId?: SortOrderInput | SortOrder
    iamSub?: SortOrderInput | SortOrder
    ipAddress?: SortOrderInput | SortOrder
    userAgent?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrderInput | SortOrder
    lastSeenAt?: SortOrderInput | SortOrder
    revokedAt?: SortOrderInput | SortOrder
    revokedReason?: SortOrderInput | SortOrder
  }

  export type AppSessionWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    jti?: string
    AND?: AppSessionWhereInput | AppSessionWhereInput[]
    OR?: AppSessionWhereInput[]
    NOT?: AppSessionWhereInput | AppSessionWhereInput[]
    subjectId?: StringFilter<"AppSession"> | string
    subjectType?: StringFilter<"AppSession"> | string
    mobile?: StringNullableFilter<"AppSession"> | string | null
    iamSessionId?: StringNullableFilter<"AppSession"> | string | null
    iamSub?: StringNullableFilter<"AppSession"> | string | null
    ipAddress?: StringNullableFilter<"AppSession"> | string | null
    userAgent?: StringNullableFilter<"AppSession"> | string | null
    createdAt?: DateTimeFilter<"AppSession"> | Date | string
    expiresAt?: DateTimeNullableFilter<"AppSession"> | Date | string | null
    lastSeenAt?: DateTimeNullableFilter<"AppSession"> | Date | string | null
    revokedAt?: DateTimeNullableFilter<"AppSession"> | Date | string | null
    revokedReason?: StringNullableFilter<"AppSession"> | string | null
  }, "id" | "jti">

  export type AppSessionOrderByWithAggregationInput = {
    id?: SortOrder
    jti?: SortOrder
    subjectId?: SortOrder
    subjectType?: SortOrder
    mobile?: SortOrderInput | SortOrder
    iamSessionId?: SortOrderInput | SortOrder
    iamSub?: SortOrderInput | SortOrder
    ipAddress?: SortOrderInput | SortOrder
    userAgent?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrderInput | SortOrder
    lastSeenAt?: SortOrderInput | SortOrder
    revokedAt?: SortOrderInput | SortOrder
    revokedReason?: SortOrderInput | SortOrder
    _count?: AppSessionCountOrderByAggregateInput
    _max?: AppSessionMaxOrderByAggregateInput
    _min?: AppSessionMinOrderByAggregateInput
  }

  export type AppSessionScalarWhereWithAggregatesInput = {
    AND?: AppSessionScalarWhereWithAggregatesInput | AppSessionScalarWhereWithAggregatesInput[]
    OR?: AppSessionScalarWhereWithAggregatesInput[]
    NOT?: AppSessionScalarWhereWithAggregatesInput | AppSessionScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"AppSession"> | string
    jti?: StringWithAggregatesFilter<"AppSession"> | string
    subjectId?: StringWithAggregatesFilter<"AppSession"> | string
    subjectType?: StringWithAggregatesFilter<"AppSession"> | string
    mobile?: StringNullableWithAggregatesFilter<"AppSession"> | string | null
    iamSessionId?: StringNullableWithAggregatesFilter<"AppSession"> | string | null
    iamSub?: StringNullableWithAggregatesFilter<"AppSession"> | string | null
    ipAddress?: StringNullableWithAggregatesFilter<"AppSession"> | string | null
    userAgent?: StringNullableWithAggregatesFilter<"AppSession"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"AppSession"> | Date | string
    expiresAt?: DateTimeNullableWithAggregatesFilter<"AppSession"> | Date | string | null
    lastSeenAt?: DateTimeNullableWithAggregatesFilter<"AppSession"> | Date | string | null
    revokedAt?: DateTimeNullableWithAggregatesFilter<"AppSession"> | Date | string | null
    revokedReason?: StringNullableWithAggregatesFilter<"AppSession"> | string | null
  }

  export type AdminSessionWhereInput = {
    AND?: AdminSessionWhereInput | AdminSessionWhereInput[]
    OR?: AdminSessionWhereInput[]
    NOT?: AdminSessionWhereInput | AdminSessionWhereInput[]
    id?: StringFilter<"AdminSession"> | string
    jti?: StringFilter<"AdminSession"> | string
    adminUserId?: StringFilter<"AdminSession"> | string
    iamSessionId?: StringNullableFilter<"AdminSession"> | string | null
    iamSub?: StringNullableFilter<"AdminSession"> | string | null
    ipAddress?: StringNullableFilter<"AdminSession"> | string | null
    userAgent?: StringNullableFilter<"AdminSession"> | string | null
    createdAt?: DateTimeFilter<"AdminSession"> | Date | string
    expiresAt?: DateTimeNullableFilter<"AdminSession"> | Date | string | null
    lastSeenAt?: DateTimeNullableFilter<"AdminSession"> | Date | string | null
    revokedAt?: DateTimeNullableFilter<"AdminSession"> | Date | string | null
    revokedReason?: StringNullableFilter<"AdminSession"> | string | null
    adminUser?: XOR<AdminUserRelationFilter, AdminUserWhereInput>
  }

  export type AdminSessionOrderByWithRelationInput = {
    id?: SortOrder
    jti?: SortOrder
    adminUserId?: SortOrder
    iamSessionId?: SortOrderInput | SortOrder
    iamSub?: SortOrderInput | SortOrder
    ipAddress?: SortOrderInput | SortOrder
    userAgent?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrderInput | SortOrder
    lastSeenAt?: SortOrderInput | SortOrder
    revokedAt?: SortOrderInput | SortOrder
    revokedReason?: SortOrderInput | SortOrder
    adminUser?: AdminUserOrderByWithRelationInput
  }

  export type AdminSessionWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    jti?: string
    AND?: AdminSessionWhereInput | AdminSessionWhereInput[]
    OR?: AdminSessionWhereInput[]
    NOT?: AdminSessionWhereInput | AdminSessionWhereInput[]
    adminUserId?: StringFilter<"AdminSession"> | string
    iamSessionId?: StringNullableFilter<"AdminSession"> | string | null
    iamSub?: StringNullableFilter<"AdminSession"> | string | null
    ipAddress?: StringNullableFilter<"AdminSession"> | string | null
    userAgent?: StringNullableFilter<"AdminSession"> | string | null
    createdAt?: DateTimeFilter<"AdminSession"> | Date | string
    expiresAt?: DateTimeNullableFilter<"AdminSession"> | Date | string | null
    lastSeenAt?: DateTimeNullableFilter<"AdminSession"> | Date | string | null
    revokedAt?: DateTimeNullableFilter<"AdminSession"> | Date | string | null
    revokedReason?: StringNullableFilter<"AdminSession"> | string | null
    adminUser?: XOR<AdminUserRelationFilter, AdminUserWhereInput>
  }, "id" | "jti">

  export type AdminSessionOrderByWithAggregationInput = {
    id?: SortOrder
    jti?: SortOrder
    adminUserId?: SortOrder
    iamSessionId?: SortOrderInput | SortOrder
    iamSub?: SortOrderInput | SortOrder
    ipAddress?: SortOrderInput | SortOrder
    userAgent?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrderInput | SortOrder
    lastSeenAt?: SortOrderInput | SortOrder
    revokedAt?: SortOrderInput | SortOrder
    revokedReason?: SortOrderInput | SortOrder
    _count?: AdminSessionCountOrderByAggregateInput
    _max?: AdminSessionMaxOrderByAggregateInput
    _min?: AdminSessionMinOrderByAggregateInput
  }

  export type AdminSessionScalarWhereWithAggregatesInput = {
    AND?: AdminSessionScalarWhereWithAggregatesInput | AdminSessionScalarWhereWithAggregatesInput[]
    OR?: AdminSessionScalarWhereWithAggregatesInput[]
    NOT?: AdminSessionScalarWhereWithAggregatesInput | AdminSessionScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"AdminSession"> | string
    jti?: StringWithAggregatesFilter<"AdminSession"> | string
    adminUserId?: StringWithAggregatesFilter<"AdminSession"> | string
    iamSessionId?: StringNullableWithAggregatesFilter<"AdminSession"> | string | null
    iamSub?: StringNullableWithAggregatesFilter<"AdminSession"> | string | null
    ipAddress?: StringNullableWithAggregatesFilter<"AdminSession"> | string | null
    userAgent?: StringNullableWithAggregatesFilter<"AdminSession"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"AdminSession"> | Date | string
    expiresAt?: DateTimeNullableWithAggregatesFilter<"AdminSession"> | Date | string | null
    lastSeenAt?: DateTimeNullableWithAggregatesFilter<"AdminSession"> | Date | string | null
    revokedAt?: DateTimeNullableWithAggregatesFilter<"AdminSession"> | Date | string | null
    revokedReason?: StringNullableWithAggregatesFilter<"AdminSession"> | string | null
  }

  export type SalesExpertProfileWhereInput = {
    AND?: SalesExpertProfileWhereInput | SalesExpertProfileWhereInput[]
    OR?: SalesExpertProfileWhereInput[]
    NOT?: SalesExpertProfileWhereInput | SalesExpertProfileWhereInput[]
    id?: StringFilter<"SalesExpertProfile"> | string
    adminUserId?: StringFilter<"SalesExpertProfile"> | string
    cityId?: StringNullableFilter<"SalesExpertProfile"> | string | null
    gramLevel?: DecimalFilter<"SalesExpertProfile"> | Decimal | DecimalJsLike | number | string
    phone?: StringNullableFilter<"SalesExpertProfile"> | string | null
    nationalCode?: StringNullableFilter<"SalesExpertProfile"> | string | null
    tradingCustomerId?: StringNullableFilter<"SalesExpertProfile"> | string | null
    createdAt?: DateTimeFilter<"SalesExpertProfile"> | Date | string
    updatedAt?: DateTimeFilter<"SalesExpertProfile"> | Date | string
    adminUser?: XOR<AdminUserRelationFilter, AdminUserWhereInput>
    city?: XOR<CityNullableRelationFilter, CityWhereInput> | null
    tradingCustomer?: XOR<CustomerNullableRelationFilter, CustomerWhereInput> | null
  }

  export type SalesExpertProfileOrderByWithRelationInput = {
    id?: SortOrder
    adminUserId?: SortOrder
    cityId?: SortOrderInput | SortOrder
    gramLevel?: SortOrder
    phone?: SortOrderInput | SortOrder
    nationalCode?: SortOrderInput | SortOrder
    tradingCustomerId?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    adminUser?: AdminUserOrderByWithRelationInput
    city?: CityOrderByWithRelationInput
    tradingCustomer?: CustomerOrderByWithRelationInput
  }

  export type SalesExpertProfileWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    adminUserId?: string
    tradingCustomerId?: string
    AND?: SalesExpertProfileWhereInput | SalesExpertProfileWhereInput[]
    OR?: SalesExpertProfileWhereInput[]
    NOT?: SalesExpertProfileWhereInput | SalesExpertProfileWhereInput[]
    cityId?: StringNullableFilter<"SalesExpertProfile"> | string | null
    gramLevel?: DecimalFilter<"SalesExpertProfile"> | Decimal | DecimalJsLike | number | string
    phone?: StringNullableFilter<"SalesExpertProfile"> | string | null
    nationalCode?: StringNullableFilter<"SalesExpertProfile"> | string | null
    createdAt?: DateTimeFilter<"SalesExpertProfile"> | Date | string
    updatedAt?: DateTimeFilter<"SalesExpertProfile"> | Date | string
    adminUser?: XOR<AdminUserRelationFilter, AdminUserWhereInput>
    city?: XOR<CityNullableRelationFilter, CityWhereInput> | null
    tradingCustomer?: XOR<CustomerNullableRelationFilter, CustomerWhereInput> | null
  }, "id" | "adminUserId" | "tradingCustomerId">

  export type SalesExpertProfileOrderByWithAggregationInput = {
    id?: SortOrder
    adminUserId?: SortOrder
    cityId?: SortOrderInput | SortOrder
    gramLevel?: SortOrder
    phone?: SortOrderInput | SortOrder
    nationalCode?: SortOrderInput | SortOrder
    tradingCustomerId?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: SalesExpertProfileCountOrderByAggregateInput
    _avg?: SalesExpertProfileAvgOrderByAggregateInput
    _max?: SalesExpertProfileMaxOrderByAggregateInput
    _min?: SalesExpertProfileMinOrderByAggregateInput
    _sum?: SalesExpertProfileSumOrderByAggregateInput
  }

  export type SalesExpertProfileScalarWhereWithAggregatesInput = {
    AND?: SalesExpertProfileScalarWhereWithAggregatesInput | SalesExpertProfileScalarWhereWithAggregatesInput[]
    OR?: SalesExpertProfileScalarWhereWithAggregatesInput[]
    NOT?: SalesExpertProfileScalarWhereWithAggregatesInput | SalesExpertProfileScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"SalesExpertProfile"> | string
    adminUserId?: StringWithAggregatesFilter<"SalesExpertProfile"> | string
    cityId?: StringNullableWithAggregatesFilter<"SalesExpertProfile"> | string | null
    gramLevel?: DecimalWithAggregatesFilter<"SalesExpertProfile"> | Decimal | DecimalJsLike | number | string
    phone?: StringNullableWithAggregatesFilter<"SalesExpertProfile"> | string | null
    nationalCode?: StringNullableWithAggregatesFilter<"SalesExpertProfile"> | string | null
    tradingCustomerId?: StringNullableWithAggregatesFilter<"SalesExpertProfile"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"SalesExpertProfile"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"SalesExpertProfile"> | Date | string
  }

  export type CustomerWhereInput = {
    AND?: CustomerWhereInput | CustomerWhereInput[]
    OR?: CustomerWhereInput[]
    NOT?: CustomerWhereInput | CustomerWhereInput[]
    id?: StringFilter<"Customer"> | string
    fullName?: StringFilter<"Customer"> | string
    firstName?: StringNullableFilter<"Customer"> | string | null
    lastName?: StringNullableFilter<"Customer"> | string | null
    mobile?: StringFilter<"Customer"> | string
    nationalCode?: StringFilter<"Customer"> | string
    passwordHash?: StringFilter<"Customer"> | string
    cityId?: StringNullableFilter<"Customer"> | string | null
    kind?: EnumCustomerKindFilter<"Customer"> | $Enums.CustomerKind
    phone?: StringNullableFilter<"Customer"> | string | null
    address?: StringNullableFilter<"Customer"> | string | null
    storeName?: StringNullableFilter<"Customer"> | string | null
    pasazhName?: StringNullableFilter<"Customer"> | string | null
    zone?: StringNullableFilter<"Customer"> | string | null
    memberCode?: StringNullableFilter<"Customer"> | string | null
    referredByAgentId?: StringNullableFilter<"Customer"> | string | null
    goldCreditLimitGrams?: DecimalFilter<"Customer"> | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFilter<"Customer"> | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFilter<"Customer"> | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFilter<"Customer"> | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFilter<"Customer"> | $Enums.VerificationStep
    nationalIdImageUrl?: StringNullableFilter<"Customer"> | string | null
    businessLicenseUrl?: StringNullableFilter<"Customer"> | string | null
    shopImageUrl?: StringNullableFilter<"Customer"> | string | null
    avatarFileId?: StringNullableFilter<"Customer"> | string | null
    canPlaceOrders?: BoolFilter<"Customer"> | boolean
    isActive?: BoolFilter<"Customer"> | boolean
    isArchived?: BoolFilter<"Customer"> | boolean
    createdAt?: DateTimeFilter<"Customer"> | Date | string
    updatedAt?: DateTimeFilter<"Customer"> | Date | string
    city?: XOR<CityNullableRelationFilter, CityWhereInput> | null
    referredByAgent?: XOR<AdminUserNullableRelationFilter, AdminUserWhereInput> | null
    salesExpertTradingFor?: XOR<SalesExpertProfileNullableRelationFilter, SalesExpertProfileWhereInput> | null
    avatarFile?: XOR<UploadedFileNullableRelationFilter, UploadedFileWhereInput> | null
    addresses?: CustomerAddressListRelationFilter
    orders?: OrderListRelationFilter
    preOrders?: PreOrderListRelationFilter
    ledgerEntries?: LedgerEntryListRelationFilter
    walletBonuses?: WalletBonusListRelationFilter
    comments?: CommentListRelationFilter
    promotions?: PromotionListRelationFilter
    notifications?: NotificationRecipientListRelationFilter
    activityLogs?: CustomerActivityLogListRelationFilter
    otpChallenges?: CustomerOtpListRelationFilter
  }

  export type CustomerOrderByWithRelationInput = {
    id?: SortOrder
    fullName?: SortOrder
    firstName?: SortOrderInput | SortOrder
    lastName?: SortOrderInput | SortOrder
    mobile?: SortOrder
    nationalCode?: SortOrder
    passwordHash?: SortOrder
    cityId?: SortOrderInput | SortOrder
    kind?: SortOrder
    phone?: SortOrderInput | SortOrder
    address?: SortOrderInput | SortOrder
    storeName?: SortOrderInput | SortOrder
    pasazhName?: SortOrderInput | SortOrder
    zone?: SortOrderInput | SortOrder
    memberCode?: SortOrderInput | SortOrder
    referredByAgentId?: SortOrderInput | SortOrder
    goldCreditLimitGrams?: SortOrder
    goldDebtGrams?: SortOrder
    fiatDebtRial?: SortOrder
    makingChargeOffsetPercent?: SortOrder
    verificationStep?: SortOrder
    nationalIdImageUrl?: SortOrderInput | SortOrder
    businessLicenseUrl?: SortOrderInput | SortOrder
    shopImageUrl?: SortOrderInput | SortOrder
    avatarFileId?: SortOrderInput | SortOrder
    canPlaceOrders?: SortOrder
    isActive?: SortOrder
    isArchived?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    city?: CityOrderByWithRelationInput
    referredByAgent?: AdminUserOrderByWithRelationInput
    salesExpertTradingFor?: SalesExpertProfileOrderByWithRelationInput
    avatarFile?: UploadedFileOrderByWithRelationInput
    addresses?: CustomerAddressOrderByRelationAggregateInput
    orders?: OrderOrderByRelationAggregateInput
    preOrders?: PreOrderOrderByRelationAggregateInput
    ledgerEntries?: LedgerEntryOrderByRelationAggregateInput
    walletBonuses?: WalletBonusOrderByRelationAggregateInput
    comments?: CommentOrderByRelationAggregateInput
    promotions?: PromotionOrderByRelationAggregateInput
    notifications?: NotificationRecipientOrderByRelationAggregateInput
    activityLogs?: CustomerActivityLogOrderByRelationAggregateInput
    otpChallenges?: CustomerOtpOrderByRelationAggregateInput
  }

  export type CustomerWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    mobile?: string
    nationalCode?: string
    AND?: CustomerWhereInput | CustomerWhereInput[]
    OR?: CustomerWhereInput[]
    NOT?: CustomerWhereInput | CustomerWhereInput[]
    fullName?: StringFilter<"Customer"> | string
    firstName?: StringNullableFilter<"Customer"> | string | null
    lastName?: StringNullableFilter<"Customer"> | string | null
    passwordHash?: StringFilter<"Customer"> | string
    cityId?: StringNullableFilter<"Customer"> | string | null
    kind?: EnumCustomerKindFilter<"Customer"> | $Enums.CustomerKind
    phone?: StringNullableFilter<"Customer"> | string | null
    address?: StringNullableFilter<"Customer"> | string | null
    storeName?: StringNullableFilter<"Customer"> | string | null
    pasazhName?: StringNullableFilter<"Customer"> | string | null
    zone?: StringNullableFilter<"Customer"> | string | null
    memberCode?: StringNullableFilter<"Customer"> | string | null
    referredByAgentId?: StringNullableFilter<"Customer"> | string | null
    goldCreditLimitGrams?: DecimalFilter<"Customer"> | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFilter<"Customer"> | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFilter<"Customer"> | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFilter<"Customer"> | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFilter<"Customer"> | $Enums.VerificationStep
    nationalIdImageUrl?: StringNullableFilter<"Customer"> | string | null
    businessLicenseUrl?: StringNullableFilter<"Customer"> | string | null
    shopImageUrl?: StringNullableFilter<"Customer"> | string | null
    avatarFileId?: StringNullableFilter<"Customer"> | string | null
    canPlaceOrders?: BoolFilter<"Customer"> | boolean
    isActive?: BoolFilter<"Customer"> | boolean
    isArchived?: BoolFilter<"Customer"> | boolean
    createdAt?: DateTimeFilter<"Customer"> | Date | string
    updatedAt?: DateTimeFilter<"Customer"> | Date | string
    city?: XOR<CityNullableRelationFilter, CityWhereInput> | null
    referredByAgent?: XOR<AdminUserNullableRelationFilter, AdminUserWhereInput> | null
    salesExpertTradingFor?: XOR<SalesExpertProfileNullableRelationFilter, SalesExpertProfileWhereInput> | null
    avatarFile?: XOR<UploadedFileNullableRelationFilter, UploadedFileWhereInput> | null
    addresses?: CustomerAddressListRelationFilter
    orders?: OrderListRelationFilter
    preOrders?: PreOrderListRelationFilter
    ledgerEntries?: LedgerEntryListRelationFilter
    walletBonuses?: WalletBonusListRelationFilter
    comments?: CommentListRelationFilter
    promotions?: PromotionListRelationFilter
    notifications?: NotificationRecipientListRelationFilter
    activityLogs?: CustomerActivityLogListRelationFilter
    otpChallenges?: CustomerOtpListRelationFilter
  }, "id" | "mobile" | "nationalCode">

  export type CustomerOrderByWithAggregationInput = {
    id?: SortOrder
    fullName?: SortOrder
    firstName?: SortOrderInput | SortOrder
    lastName?: SortOrderInput | SortOrder
    mobile?: SortOrder
    nationalCode?: SortOrder
    passwordHash?: SortOrder
    cityId?: SortOrderInput | SortOrder
    kind?: SortOrder
    phone?: SortOrderInput | SortOrder
    address?: SortOrderInput | SortOrder
    storeName?: SortOrderInput | SortOrder
    pasazhName?: SortOrderInput | SortOrder
    zone?: SortOrderInput | SortOrder
    memberCode?: SortOrderInput | SortOrder
    referredByAgentId?: SortOrderInput | SortOrder
    goldCreditLimitGrams?: SortOrder
    goldDebtGrams?: SortOrder
    fiatDebtRial?: SortOrder
    makingChargeOffsetPercent?: SortOrder
    verificationStep?: SortOrder
    nationalIdImageUrl?: SortOrderInput | SortOrder
    businessLicenseUrl?: SortOrderInput | SortOrder
    shopImageUrl?: SortOrderInput | SortOrder
    avatarFileId?: SortOrderInput | SortOrder
    canPlaceOrders?: SortOrder
    isActive?: SortOrder
    isArchived?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: CustomerCountOrderByAggregateInput
    _avg?: CustomerAvgOrderByAggregateInput
    _max?: CustomerMaxOrderByAggregateInput
    _min?: CustomerMinOrderByAggregateInput
    _sum?: CustomerSumOrderByAggregateInput
  }

  export type CustomerScalarWhereWithAggregatesInput = {
    AND?: CustomerScalarWhereWithAggregatesInput | CustomerScalarWhereWithAggregatesInput[]
    OR?: CustomerScalarWhereWithAggregatesInput[]
    NOT?: CustomerScalarWhereWithAggregatesInput | CustomerScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Customer"> | string
    fullName?: StringWithAggregatesFilter<"Customer"> | string
    firstName?: StringNullableWithAggregatesFilter<"Customer"> | string | null
    lastName?: StringNullableWithAggregatesFilter<"Customer"> | string | null
    mobile?: StringWithAggregatesFilter<"Customer"> | string
    nationalCode?: StringWithAggregatesFilter<"Customer"> | string
    passwordHash?: StringWithAggregatesFilter<"Customer"> | string
    cityId?: StringNullableWithAggregatesFilter<"Customer"> | string | null
    kind?: EnumCustomerKindWithAggregatesFilter<"Customer"> | $Enums.CustomerKind
    phone?: StringNullableWithAggregatesFilter<"Customer"> | string | null
    address?: StringNullableWithAggregatesFilter<"Customer"> | string | null
    storeName?: StringNullableWithAggregatesFilter<"Customer"> | string | null
    pasazhName?: StringNullableWithAggregatesFilter<"Customer"> | string | null
    zone?: StringNullableWithAggregatesFilter<"Customer"> | string | null
    memberCode?: StringNullableWithAggregatesFilter<"Customer"> | string | null
    referredByAgentId?: StringNullableWithAggregatesFilter<"Customer"> | string | null
    goldCreditLimitGrams?: DecimalWithAggregatesFilter<"Customer"> | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalWithAggregatesFilter<"Customer"> | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalWithAggregatesFilter<"Customer"> | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalWithAggregatesFilter<"Customer"> | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepWithAggregatesFilter<"Customer"> | $Enums.VerificationStep
    nationalIdImageUrl?: StringNullableWithAggregatesFilter<"Customer"> | string | null
    businessLicenseUrl?: StringNullableWithAggregatesFilter<"Customer"> | string | null
    shopImageUrl?: StringNullableWithAggregatesFilter<"Customer"> | string | null
    avatarFileId?: StringNullableWithAggregatesFilter<"Customer"> | string | null
    canPlaceOrders?: BoolWithAggregatesFilter<"Customer"> | boolean
    isActive?: BoolWithAggregatesFilter<"Customer"> | boolean
    isArchived?: BoolWithAggregatesFilter<"Customer"> | boolean
    createdAt?: DateTimeWithAggregatesFilter<"Customer"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Customer"> | Date | string
  }

  export type CustomerAddressWhereInput = {
    AND?: CustomerAddressWhereInput | CustomerAddressWhereInput[]
    OR?: CustomerAddressWhereInput[]
    NOT?: CustomerAddressWhereInput | CustomerAddressWhereInput[]
    id?: StringFilter<"CustomerAddress"> | string
    customerId?: StringFilter<"CustomerAddress"> | string
    cityId?: StringNullableFilter<"CustomerAddress"> | string | null
    addressLine?: StringFilter<"CustomerAddress"> | string
    isDefault?: BoolFilter<"CustomerAddress"> | boolean
    customer?: XOR<CustomerRelationFilter, CustomerWhereInput>
    city?: XOR<CityNullableRelationFilter, CityWhereInput> | null
  }

  export type CustomerAddressOrderByWithRelationInput = {
    id?: SortOrder
    customerId?: SortOrder
    cityId?: SortOrderInput | SortOrder
    addressLine?: SortOrder
    isDefault?: SortOrder
    customer?: CustomerOrderByWithRelationInput
    city?: CityOrderByWithRelationInput
  }

  export type CustomerAddressWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: CustomerAddressWhereInput | CustomerAddressWhereInput[]
    OR?: CustomerAddressWhereInput[]
    NOT?: CustomerAddressWhereInput | CustomerAddressWhereInput[]
    customerId?: StringFilter<"CustomerAddress"> | string
    cityId?: StringNullableFilter<"CustomerAddress"> | string | null
    addressLine?: StringFilter<"CustomerAddress"> | string
    isDefault?: BoolFilter<"CustomerAddress"> | boolean
    customer?: XOR<CustomerRelationFilter, CustomerWhereInput>
    city?: XOR<CityNullableRelationFilter, CityWhereInput> | null
  }, "id">

  export type CustomerAddressOrderByWithAggregationInput = {
    id?: SortOrder
    customerId?: SortOrder
    cityId?: SortOrderInput | SortOrder
    addressLine?: SortOrder
    isDefault?: SortOrder
    _count?: CustomerAddressCountOrderByAggregateInput
    _max?: CustomerAddressMaxOrderByAggregateInput
    _min?: CustomerAddressMinOrderByAggregateInput
  }

  export type CustomerAddressScalarWhereWithAggregatesInput = {
    AND?: CustomerAddressScalarWhereWithAggregatesInput | CustomerAddressScalarWhereWithAggregatesInput[]
    OR?: CustomerAddressScalarWhereWithAggregatesInput[]
    NOT?: CustomerAddressScalarWhereWithAggregatesInput | CustomerAddressScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"CustomerAddress"> | string
    customerId?: StringWithAggregatesFilter<"CustomerAddress"> | string
    cityId?: StringNullableWithAggregatesFilter<"CustomerAddress"> | string | null
    addressLine?: StringWithAggregatesFilter<"CustomerAddress"> | string
    isDefault?: BoolWithAggregatesFilter<"CustomerAddress"> | boolean
  }

  export type BranchWhereInput = {
    AND?: BranchWhereInput | BranchWhereInput[]
    OR?: BranchWhereInput[]
    NOT?: BranchWhereInput | BranchWhereInput[]
    id?: StringFilter<"Branch"> | string
    name?: StringFilter<"Branch"> | string
    address?: StringNullableFilter<"Branch"> | string | null
    phone?: StringNullableFilter<"Branch"> | string | null
    isActive?: BoolFilter<"Branch"> | boolean
    cityId?: StringNullableFilter<"Branch"> | string | null
    city?: XOR<CityNullableRelationFilter, CityWhereInput> | null
    adminUsers?: AdminUserListRelationFilter
    orders?: OrderListRelationFilter
    allocations?: BranchAllocationListRelationFilter
  }

  export type BranchOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    address?: SortOrderInput | SortOrder
    phone?: SortOrderInput | SortOrder
    isActive?: SortOrder
    cityId?: SortOrderInput | SortOrder
    city?: CityOrderByWithRelationInput
    adminUsers?: AdminUserOrderByRelationAggregateInput
    orders?: OrderOrderByRelationAggregateInput
    allocations?: BranchAllocationOrderByRelationAggregateInput
  }

  export type BranchWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: BranchWhereInput | BranchWhereInput[]
    OR?: BranchWhereInput[]
    NOT?: BranchWhereInput | BranchWhereInput[]
    name?: StringFilter<"Branch"> | string
    address?: StringNullableFilter<"Branch"> | string | null
    phone?: StringNullableFilter<"Branch"> | string | null
    isActive?: BoolFilter<"Branch"> | boolean
    cityId?: StringNullableFilter<"Branch"> | string | null
    city?: XOR<CityNullableRelationFilter, CityWhereInput> | null
    adminUsers?: AdminUserListRelationFilter
    orders?: OrderListRelationFilter
    allocations?: BranchAllocationListRelationFilter
  }, "id">

  export type BranchOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    address?: SortOrderInput | SortOrder
    phone?: SortOrderInput | SortOrder
    isActive?: SortOrder
    cityId?: SortOrderInput | SortOrder
    _count?: BranchCountOrderByAggregateInput
    _max?: BranchMaxOrderByAggregateInput
    _min?: BranchMinOrderByAggregateInput
  }

  export type BranchScalarWhereWithAggregatesInput = {
    AND?: BranchScalarWhereWithAggregatesInput | BranchScalarWhereWithAggregatesInput[]
    OR?: BranchScalarWhereWithAggregatesInput[]
    NOT?: BranchScalarWhereWithAggregatesInput | BranchScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Branch"> | string
    name?: StringWithAggregatesFilter<"Branch"> | string
    address?: StringNullableWithAggregatesFilter<"Branch"> | string | null
    phone?: StringNullableWithAggregatesFilter<"Branch"> | string | null
    isActive?: BoolWithAggregatesFilter<"Branch"> | boolean
    cityId?: StringNullableWithAggregatesFilter<"Branch"> | string | null
  }

  export type WorkshopWhereInput = {
    AND?: WorkshopWhereInput | WorkshopWhereInput[]
    OR?: WorkshopWhereInput[]
    NOT?: WorkshopWhereInput | WorkshopWhereInput[]
    id?: StringFilter<"Workshop"> | string
    name?: StringFilter<"Workshop"> | string
    address?: StringNullableFilter<"Workshop"> | string | null
    phone?: StringNullableFilter<"Workshop"> | string | null
    supervisorId?: StringNullableFilter<"Workshop"> | string | null
    isActive?: BoolFilter<"Workshop"> | boolean
    supervisor?: XOR<AdminUserNullableRelationFilter, AdminUserWhereInput> | null
    preOrders?: PreOrderListRelationFilter
  }

  export type WorkshopOrderByWithRelationInput = {
    id?: SortOrder
    name?: SortOrder
    address?: SortOrderInput | SortOrder
    phone?: SortOrderInput | SortOrder
    supervisorId?: SortOrderInput | SortOrder
    isActive?: SortOrder
    supervisor?: AdminUserOrderByWithRelationInput
    preOrders?: PreOrderOrderByRelationAggregateInput
  }

  export type WorkshopWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: WorkshopWhereInput | WorkshopWhereInput[]
    OR?: WorkshopWhereInput[]
    NOT?: WorkshopWhereInput | WorkshopWhereInput[]
    name?: StringFilter<"Workshop"> | string
    address?: StringNullableFilter<"Workshop"> | string | null
    phone?: StringNullableFilter<"Workshop"> | string | null
    supervisorId?: StringNullableFilter<"Workshop"> | string | null
    isActive?: BoolFilter<"Workshop"> | boolean
    supervisor?: XOR<AdminUserNullableRelationFilter, AdminUserWhereInput> | null
    preOrders?: PreOrderListRelationFilter
  }, "id">

  export type WorkshopOrderByWithAggregationInput = {
    id?: SortOrder
    name?: SortOrder
    address?: SortOrderInput | SortOrder
    phone?: SortOrderInput | SortOrder
    supervisorId?: SortOrderInput | SortOrder
    isActive?: SortOrder
    _count?: WorkshopCountOrderByAggregateInput
    _max?: WorkshopMaxOrderByAggregateInput
    _min?: WorkshopMinOrderByAggregateInput
  }

  export type WorkshopScalarWhereWithAggregatesInput = {
    AND?: WorkshopScalarWhereWithAggregatesInput | WorkshopScalarWhereWithAggregatesInput[]
    OR?: WorkshopScalarWhereWithAggregatesInput[]
    NOT?: WorkshopScalarWhereWithAggregatesInput | WorkshopScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Workshop"> | string
    name?: StringWithAggregatesFilter<"Workshop"> | string
    address?: StringNullableWithAggregatesFilter<"Workshop"> | string | null
    phone?: StringNullableWithAggregatesFilter<"Workshop"> | string | null
    supervisorId?: StringNullableWithAggregatesFilter<"Workshop"> | string | null
    isActive?: BoolWithAggregatesFilter<"Workshop"> | boolean
  }

  export type CategoryWhereInput = {
    AND?: CategoryWhereInput | CategoryWhereInput[]
    OR?: CategoryWhereInput[]
    NOT?: CategoryWhereInput | CategoryWhereInput[]
    id?: StringFilter<"Category"> | string
    title?: StringFilter<"Category"> | string
    type?: IntFilter<"Category"> | number
    imageUrl?: StringNullableFilter<"Category"> | string | null
    iconUrl?: StringNullableFilter<"Category"> | string | null
    metaTag?: StringNullableFilter<"Category"> | string | null
    description?: StringNullableFilter<"Category"> | string | null
    parentId?: StringNullableFilter<"Category"> | string | null
    parent?: XOR<CategoryNullableRelationFilter, CategoryWhereInput> | null
    children?: CategoryListRelationFilter
    products?: ProductListRelationFilter
    promotions?: PromotionListRelationFilter
  }

  export type CategoryOrderByWithRelationInput = {
    id?: SortOrder
    title?: SortOrder
    type?: SortOrder
    imageUrl?: SortOrderInput | SortOrder
    iconUrl?: SortOrderInput | SortOrder
    metaTag?: SortOrderInput | SortOrder
    description?: SortOrderInput | SortOrder
    parentId?: SortOrderInput | SortOrder
    parent?: CategoryOrderByWithRelationInput
    children?: CategoryOrderByRelationAggregateInput
    products?: ProductOrderByRelationAggregateInput
    promotions?: PromotionOrderByRelationAggregateInput
  }

  export type CategoryWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: CategoryWhereInput | CategoryWhereInput[]
    OR?: CategoryWhereInput[]
    NOT?: CategoryWhereInput | CategoryWhereInput[]
    title?: StringFilter<"Category"> | string
    type?: IntFilter<"Category"> | number
    imageUrl?: StringNullableFilter<"Category"> | string | null
    iconUrl?: StringNullableFilter<"Category"> | string | null
    metaTag?: StringNullableFilter<"Category"> | string | null
    description?: StringNullableFilter<"Category"> | string | null
    parentId?: StringNullableFilter<"Category"> | string | null
    parent?: XOR<CategoryNullableRelationFilter, CategoryWhereInput> | null
    children?: CategoryListRelationFilter
    products?: ProductListRelationFilter
    promotions?: PromotionListRelationFilter
  }, "id">

  export type CategoryOrderByWithAggregationInput = {
    id?: SortOrder
    title?: SortOrder
    type?: SortOrder
    imageUrl?: SortOrderInput | SortOrder
    iconUrl?: SortOrderInput | SortOrder
    metaTag?: SortOrderInput | SortOrder
    description?: SortOrderInput | SortOrder
    parentId?: SortOrderInput | SortOrder
    _count?: CategoryCountOrderByAggregateInput
    _avg?: CategoryAvgOrderByAggregateInput
    _max?: CategoryMaxOrderByAggregateInput
    _min?: CategoryMinOrderByAggregateInput
    _sum?: CategorySumOrderByAggregateInput
  }

  export type CategoryScalarWhereWithAggregatesInput = {
    AND?: CategoryScalarWhereWithAggregatesInput | CategoryScalarWhereWithAggregatesInput[]
    OR?: CategoryScalarWhereWithAggregatesInput[]
    NOT?: CategoryScalarWhereWithAggregatesInput | CategoryScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Category"> | string
    title?: StringWithAggregatesFilter<"Category"> | string
    type?: IntWithAggregatesFilter<"Category"> | number
    imageUrl?: StringNullableWithAggregatesFilter<"Category"> | string | null
    iconUrl?: StringNullableWithAggregatesFilter<"Category"> | string | null
    metaTag?: StringNullableWithAggregatesFilter<"Category"> | string | null
    description?: StringNullableWithAggregatesFilter<"Category"> | string | null
    parentId?: StringNullableWithAggregatesFilter<"Category"> | string | null
  }

  export type BrandWhereInput = {
    AND?: BrandWhereInput | BrandWhereInput[]
    OR?: BrandWhereInput[]
    NOT?: BrandWhereInput | BrandWhereInput[]
    id?: StringFilter<"Brand"> | string
    title?: StringFilter<"Brand"> | string
    products?: ProductListRelationFilter
    promotions?: PromotionListRelationFilter
  }

  export type BrandOrderByWithRelationInput = {
    id?: SortOrder
    title?: SortOrder
    products?: ProductOrderByRelationAggregateInput
    promotions?: PromotionOrderByRelationAggregateInput
  }

  export type BrandWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: BrandWhereInput | BrandWhereInput[]
    OR?: BrandWhereInput[]
    NOT?: BrandWhereInput | BrandWhereInput[]
    title?: StringFilter<"Brand"> | string
    products?: ProductListRelationFilter
    promotions?: PromotionListRelationFilter
  }, "id">

  export type BrandOrderByWithAggregationInput = {
    id?: SortOrder
    title?: SortOrder
    _count?: BrandCountOrderByAggregateInput
    _max?: BrandMaxOrderByAggregateInput
    _min?: BrandMinOrderByAggregateInput
  }

  export type BrandScalarWhereWithAggregatesInput = {
    AND?: BrandScalarWhereWithAggregatesInput | BrandScalarWhereWithAggregatesInput[]
    OR?: BrandScalarWhereWithAggregatesInput[]
    NOT?: BrandScalarWhereWithAggregatesInput | BrandScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Brand"> | string
    title?: StringWithAggregatesFilter<"Brand"> | string
  }

  export type CollectionWhereInput = {
    AND?: CollectionWhereInput | CollectionWhereInput[]
    OR?: CollectionWhereInput[]
    NOT?: CollectionWhereInput | CollectionWhereInput[]
    id?: StringFilter<"Collection"> | string
    title?: StringFilter<"Collection"> | string
    description?: StringNullableFilter<"Collection"> | string | null
    isActive?: BoolFilter<"Collection"> | boolean
    products?: CollectionProductListRelationFilter
  }

  export type CollectionOrderByWithRelationInput = {
    id?: SortOrder
    title?: SortOrder
    description?: SortOrderInput | SortOrder
    isActive?: SortOrder
    products?: CollectionProductOrderByRelationAggregateInput
  }

  export type CollectionWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: CollectionWhereInput | CollectionWhereInput[]
    OR?: CollectionWhereInput[]
    NOT?: CollectionWhereInput | CollectionWhereInput[]
    title?: StringFilter<"Collection"> | string
    description?: StringNullableFilter<"Collection"> | string | null
    isActive?: BoolFilter<"Collection"> | boolean
    products?: CollectionProductListRelationFilter
  }, "id">

  export type CollectionOrderByWithAggregationInput = {
    id?: SortOrder
    title?: SortOrder
    description?: SortOrderInput | SortOrder
    isActive?: SortOrder
    _count?: CollectionCountOrderByAggregateInput
    _max?: CollectionMaxOrderByAggregateInput
    _min?: CollectionMinOrderByAggregateInput
  }

  export type CollectionScalarWhereWithAggregatesInput = {
    AND?: CollectionScalarWhereWithAggregatesInput | CollectionScalarWhereWithAggregatesInput[]
    OR?: CollectionScalarWhereWithAggregatesInput[]
    NOT?: CollectionScalarWhereWithAggregatesInput | CollectionScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Collection"> | string
    title?: StringWithAggregatesFilter<"Collection"> | string
    description?: StringNullableWithAggregatesFilter<"Collection"> | string | null
    isActive?: BoolWithAggregatesFilter<"Collection"> | boolean
  }

  export type CollectionProductWhereInput = {
    AND?: CollectionProductWhereInput | CollectionProductWhereInput[]
    OR?: CollectionProductWhereInput[]
    NOT?: CollectionProductWhereInput | CollectionProductWhereInput[]
    collectionId?: StringFilter<"CollectionProduct"> | string
    productId?: StringFilter<"CollectionProduct"> | string
    collection?: XOR<CollectionRelationFilter, CollectionWhereInput>
    product?: XOR<ProductRelationFilter, ProductWhereInput>
  }

  export type CollectionProductOrderByWithRelationInput = {
    collectionId?: SortOrder
    productId?: SortOrder
    collection?: CollectionOrderByWithRelationInput
    product?: ProductOrderByWithRelationInput
  }

  export type CollectionProductWhereUniqueInput = Prisma.AtLeast<{
    collectionId_productId?: CollectionProductCollectionIdProductIdCompoundUniqueInput
    AND?: CollectionProductWhereInput | CollectionProductWhereInput[]
    OR?: CollectionProductWhereInput[]
    NOT?: CollectionProductWhereInput | CollectionProductWhereInput[]
    collectionId?: StringFilter<"CollectionProduct"> | string
    productId?: StringFilter<"CollectionProduct"> | string
    collection?: XOR<CollectionRelationFilter, CollectionWhereInput>
    product?: XOR<ProductRelationFilter, ProductWhereInput>
  }, "collectionId_productId">

  export type CollectionProductOrderByWithAggregationInput = {
    collectionId?: SortOrder
    productId?: SortOrder
    _count?: CollectionProductCountOrderByAggregateInput
    _max?: CollectionProductMaxOrderByAggregateInput
    _min?: CollectionProductMinOrderByAggregateInput
  }

  export type CollectionProductScalarWhereWithAggregatesInput = {
    AND?: CollectionProductScalarWhereWithAggregatesInput | CollectionProductScalarWhereWithAggregatesInput[]
    OR?: CollectionProductScalarWhereWithAggregatesInput[]
    NOT?: CollectionProductScalarWhereWithAggregatesInput | CollectionProductScalarWhereWithAggregatesInput[]
    collectionId?: StringWithAggregatesFilter<"CollectionProduct"> | string
    productId?: StringWithAggregatesFilter<"CollectionProduct"> | string
  }

  export type ProductWhereInput = {
    AND?: ProductWhereInput | ProductWhereInput[]
    OR?: ProductWhereInput[]
    NOT?: ProductWhereInput | ProductWhereInput[]
    id?: StringFilter<"Product"> | string
    title?: StringFilter<"Product"> | string
    description?: StringNullableFilter<"Product"> | string | null
    categoryId?: StringNullableFilter<"Product"> | string | null
    brandId?: StringNullableFilter<"Product"> | string | null
    productCode?: StringNullableFilter<"Product"> | string | null
    showType?: IntFilter<"Product"> | number
    isActive?: BoolFilter<"Product"> | boolean
    createdAt?: DateTimeFilter<"Product"> | Date | string
    category?: XOR<CategoryNullableRelationFilter, CategoryWhereInput> | null
    brand?: XOR<BrandNullableRelationFilter, BrandWhereInput> | null
    variants?: ProductVariantListRelationFilter
    images?: ProductImageListRelationFilter
    collections?: CollectionProductListRelationFilter
    comments?: CommentListRelationFilter
    promotions?: PromotionListRelationFilter
    allocationItems?: BranchAllocationItemListRelationFilter
  }

  export type ProductOrderByWithRelationInput = {
    id?: SortOrder
    title?: SortOrder
    description?: SortOrderInput | SortOrder
    categoryId?: SortOrderInput | SortOrder
    brandId?: SortOrderInput | SortOrder
    productCode?: SortOrderInput | SortOrder
    showType?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    category?: CategoryOrderByWithRelationInput
    brand?: BrandOrderByWithRelationInput
    variants?: ProductVariantOrderByRelationAggregateInput
    images?: ProductImageOrderByRelationAggregateInput
    collections?: CollectionProductOrderByRelationAggregateInput
    comments?: CommentOrderByRelationAggregateInput
    promotions?: PromotionOrderByRelationAggregateInput
    allocationItems?: BranchAllocationItemOrderByRelationAggregateInput
  }

  export type ProductWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    productCode?: string
    AND?: ProductWhereInput | ProductWhereInput[]
    OR?: ProductWhereInput[]
    NOT?: ProductWhereInput | ProductWhereInput[]
    title?: StringFilter<"Product"> | string
    description?: StringNullableFilter<"Product"> | string | null
    categoryId?: StringNullableFilter<"Product"> | string | null
    brandId?: StringNullableFilter<"Product"> | string | null
    showType?: IntFilter<"Product"> | number
    isActive?: BoolFilter<"Product"> | boolean
    createdAt?: DateTimeFilter<"Product"> | Date | string
    category?: XOR<CategoryNullableRelationFilter, CategoryWhereInput> | null
    brand?: XOR<BrandNullableRelationFilter, BrandWhereInput> | null
    variants?: ProductVariantListRelationFilter
    images?: ProductImageListRelationFilter
    collections?: CollectionProductListRelationFilter
    comments?: CommentListRelationFilter
    promotions?: PromotionListRelationFilter
    allocationItems?: BranchAllocationItemListRelationFilter
  }, "id" | "productCode">

  export type ProductOrderByWithAggregationInput = {
    id?: SortOrder
    title?: SortOrder
    description?: SortOrderInput | SortOrder
    categoryId?: SortOrderInput | SortOrder
    brandId?: SortOrderInput | SortOrder
    productCode?: SortOrderInput | SortOrder
    showType?: SortOrder
    isActive?: SortOrder
    createdAt?: 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
    title?: StringWithAggregatesFilter<"Product"> | string
    description?: StringNullableWithAggregatesFilter<"Product"> | string | null
    categoryId?: StringNullableWithAggregatesFilter<"Product"> | string | null
    brandId?: StringNullableWithAggregatesFilter<"Product"> | string | null
    productCode?: StringNullableWithAggregatesFilter<"Product"> | string | null
    showType?: IntWithAggregatesFilter<"Product"> | number
    isActive?: BoolWithAggregatesFilter<"Product"> | boolean
    createdAt?: DateTimeWithAggregatesFilter<"Product"> | Date | string
  }

  export type ProductImageWhereInput = {
    AND?: ProductImageWhereInput | ProductImageWhereInput[]
    OR?: ProductImageWhereInput[]
    NOT?: ProductImageWhereInput | ProductImageWhereInput[]
    id?: StringFilter<"ProductImage"> | string
    productId?: StringFilter<"ProductImage"> | string
    url?: StringFilter<"ProductImage"> | string
    sortOrder?: IntFilter<"ProductImage"> | number
    role?: EnumProductImageRoleFilter<"ProductImage"> | $Enums.ProductImageRole
    product?: XOR<ProductRelationFilter, ProductWhereInput>
    variants?: ProductVariantListRelationFilter
  }

  export type ProductImageOrderByWithRelationInput = {
    id?: SortOrder
    productId?: SortOrder
    url?: SortOrder
    sortOrder?: SortOrder
    role?: SortOrder
    product?: ProductOrderByWithRelationInput
    variants?: ProductVariantOrderByRelationAggregateInput
  }

  export type ProductImageWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: ProductImageWhereInput | ProductImageWhereInput[]
    OR?: ProductImageWhereInput[]
    NOT?: ProductImageWhereInput | ProductImageWhereInput[]
    productId?: StringFilter<"ProductImage"> | string
    url?: StringFilter<"ProductImage"> | string
    sortOrder?: IntFilter<"ProductImage"> | number
    role?: EnumProductImageRoleFilter<"ProductImage"> | $Enums.ProductImageRole
    product?: XOR<ProductRelationFilter, ProductWhereInput>
    variants?: ProductVariantListRelationFilter
  }, "id">

  export type ProductImageOrderByWithAggregationInput = {
    id?: SortOrder
    productId?: SortOrder
    url?: SortOrder
    sortOrder?: SortOrder
    role?: SortOrder
    _count?: ProductImageCountOrderByAggregateInput
    _avg?: ProductImageAvgOrderByAggregateInput
    _max?: ProductImageMaxOrderByAggregateInput
    _min?: ProductImageMinOrderByAggregateInput
    _sum?: ProductImageSumOrderByAggregateInput
  }

  export type ProductImageScalarWhereWithAggregatesInput = {
    AND?: ProductImageScalarWhereWithAggregatesInput | ProductImageScalarWhereWithAggregatesInput[]
    OR?: ProductImageScalarWhereWithAggregatesInput[]
    NOT?: ProductImageScalarWhereWithAggregatesInput | ProductImageScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"ProductImage"> | string
    productId?: StringWithAggregatesFilter<"ProductImage"> | string
    url?: StringWithAggregatesFilter<"ProductImage"> | string
    sortOrder?: IntWithAggregatesFilter<"ProductImage"> | number
    role?: EnumProductImageRoleWithAggregatesFilter<"ProductImage"> | $Enums.ProductImageRole
  }

  export type ProductVariantWhereInput = {
    AND?: ProductVariantWhereInput | ProductVariantWhereInput[]
    OR?: ProductVariantWhereInput[]
    NOT?: ProductVariantWhereInput | ProductVariantWhereInput[]
    id?: StringFilter<"ProductVariant"> | string
    productId?: StringFilter<"ProductVariant"> | string
    title?: StringFilter<"ProductVariant"> | string
    sku?: StringNullableFilter<"ProductVariant"> | string | null
    rashWeightGrams?: DecimalFilter<"ProductVariant"> | Decimal | DecimalJsLike | number | string
    defaultWagePercent?: DecimalFilter<"ProductVariant"> | Decimal | DecimalJsLike | number | string
    qty?: IntFilter<"ProductVariant"> | number
    isPreOrder?: BoolFilter<"ProductVariant"> | boolean
    isActive?: BoolFilter<"ProductVariant"> | boolean
    imageId?: StringNullableFilter<"ProductVariant"> | string | null
    product?: XOR<ProductRelationFilter, ProductWhereInput>
    image?: XOR<ProductImageNullableRelationFilter, ProductImageWhereInput> | null
    orderItems?: OrderItemListRelationFilter
  }

  export type ProductVariantOrderByWithRelationInput = {
    id?: SortOrder
    productId?: SortOrder
    title?: SortOrder
    sku?: SortOrderInput | SortOrder
    rashWeightGrams?: SortOrder
    defaultWagePercent?: SortOrder
    qty?: SortOrder
    isPreOrder?: SortOrder
    isActive?: SortOrder
    imageId?: SortOrderInput | SortOrder
    product?: ProductOrderByWithRelationInput
    image?: ProductImageOrderByWithRelationInput
    orderItems?: OrderItemOrderByRelationAggregateInput
  }

  export type ProductVariantWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    sku?: string
    AND?: ProductVariantWhereInput | ProductVariantWhereInput[]
    OR?: ProductVariantWhereInput[]
    NOT?: ProductVariantWhereInput | ProductVariantWhereInput[]
    productId?: StringFilter<"ProductVariant"> | string
    title?: StringFilter<"ProductVariant"> | string
    rashWeightGrams?: DecimalFilter<"ProductVariant"> | Decimal | DecimalJsLike | number | string
    defaultWagePercent?: DecimalFilter<"ProductVariant"> | Decimal | DecimalJsLike | number | string
    qty?: IntFilter<"ProductVariant"> | number
    isPreOrder?: BoolFilter<"ProductVariant"> | boolean
    isActive?: BoolFilter<"ProductVariant"> | boolean
    imageId?: StringNullableFilter<"ProductVariant"> | string | null
    product?: XOR<ProductRelationFilter, ProductWhereInput>
    image?: XOR<ProductImageNullableRelationFilter, ProductImageWhereInput> | null
    orderItems?: OrderItemListRelationFilter
  }, "id" | "sku">

  export type ProductVariantOrderByWithAggregationInput = {
    id?: SortOrder
    productId?: SortOrder
    title?: SortOrder
    sku?: SortOrderInput | SortOrder
    rashWeightGrams?: SortOrder
    defaultWagePercent?: SortOrder
    qty?: SortOrder
    isPreOrder?: SortOrder
    isActive?: SortOrder
    imageId?: SortOrderInput | SortOrder
    _count?: ProductVariantCountOrderByAggregateInput
    _avg?: ProductVariantAvgOrderByAggregateInput
    _max?: ProductVariantMaxOrderByAggregateInput
    _min?: ProductVariantMinOrderByAggregateInput
    _sum?: ProductVariantSumOrderByAggregateInput
  }

  export type ProductVariantScalarWhereWithAggregatesInput = {
    AND?: ProductVariantScalarWhereWithAggregatesInput | ProductVariantScalarWhereWithAggregatesInput[]
    OR?: ProductVariantScalarWhereWithAggregatesInput[]
    NOT?: ProductVariantScalarWhereWithAggregatesInput | ProductVariantScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"ProductVariant"> | string
    productId?: StringWithAggregatesFilter<"ProductVariant"> | string
    title?: StringWithAggregatesFilter<"ProductVariant"> | string
    sku?: StringNullableWithAggregatesFilter<"ProductVariant"> | string | null
    rashWeightGrams?: DecimalWithAggregatesFilter<"ProductVariant"> | Decimal | DecimalJsLike | number | string
    defaultWagePercent?: DecimalWithAggregatesFilter<"ProductVariant"> | Decimal | DecimalJsLike | number | string
    qty?: IntWithAggregatesFilter<"ProductVariant"> | number
    isPreOrder?: BoolWithAggregatesFilter<"ProductVariant"> | boolean
    isActive?: BoolWithAggregatesFilter<"ProductVariant"> | boolean
    imageId?: StringNullableWithAggregatesFilter<"ProductVariant"> | string | null
  }

  export type OrderWhereInput = {
    AND?: OrderWhereInput | OrderWhereInput[]
    OR?: OrderWhereInput[]
    NOT?: OrderWhereInput | OrderWhereInput[]
    id?: StringFilter<"Order"> | string
    orderNumber?: StringFilter<"Order"> | string
    customerId?: StringFilter<"Order"> | string
    branchId?: StringNullableFilter<"Order"> | string | null
    channel?: EnumOrderChannelFilter<"Order"> | $Enums.OrderChannel
    status?: EnumOrderStatusFilter<"Order"> | $Enums.OrderStatus
    totalGoldWeightGrams?: DecimalFilter<"Order"> | Decimal | DecimalJsLike | number | string
    wageWeightGrams?: DecimalFilter<"Order"> | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFilter<"Order"> | Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: BoolFilter<"Order"> | boolean
    deliveredAt?: DateTimeNullableFilter<"Order"> | Date | string | null
    createdAt?: DateTimeFilter<"Order"> | Date | string
    updatedAt?: DateTimeFilter<"Order"> | Date | string
    customer?: XOR<CustomerRelationFilter, CustomerWhereInput>
    branch?: XOR<BranchNullableRelationFilter, BranchWhereInput> | null
    items?: OrderItemListRelationFilter
    statusEvents?: OrderStatusEventListRelationFilter
    ledgerEntries?: LedgerEntryListRelationFilter
    convertedFromPreOrder?: XOR<PreOrderNullableRelationFilter, PreOrderWhereInput> | null
  }

  export type OrderOrderByWithRelationInput = {
    id?: SortOrder
    orderNumber?: SortOrder
    customerId?: SortOrder
    branchId?: SortOrderInput | SortOrder
    channel?: SortOrder
    status?: SortOrder
    totalGoldWeightGrams?: SortOrder
    wageWeightGrams?: SortOrder
    flatRialCharge?: SortOrder
    isSuspendedOverCreditLimit?: SortOrder
    deliveredAt?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    customer?: CustomerOrderByWithRelationInput
    branch?: BranchOrderByWithRelationInput
    items?: OrderItemOrderByRelationAggregateInput
    statusEvents?: OrderStatusEventOrderByRelationAggregateInput
    ledgerEntries?: LedgerEntryOrderByRelationAggregateInput
    convertedFromPreOrder?: PreOrderOrderByWithRelationInput
  }

  export type OrderWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    orderNumber?: string
    AND?: OrderWhereInput | OrderWhereInput[]
    OR?: OrderWhereInput[]
    NOT?: OrderWhereInput | OrderWhereInput[]
    customerId?: StringFilter<"Order"> | string
    branchId?: StringNullableFilter<"Order"> | string | null
    channel?: EnumOrderChannelFilter<"Order"> | $Enums.OrderChannel
    status?: EnumOrderStatusFilter<"Order"> | $Enums.OrderStatus
    totalGoldWeightGrams?: DecimalFilter<"Order"> | Decimal | DecimalJsLike | number | string
    wageWeightGrams?: DecimalFilter<"Order"> | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFilter<"Order"> | Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: BoolFilter<"Order"> | boolean
    deliveredAt?: DateTimeNullableFilter<"Order"> | Date | string | null
    createdAt?: DateTimeFilter<"Order"> | Date | string
    updatedAt?: DateTimeFilter<"Order"> | Date | string
    customer?: XOR<CustomerRelationFilter, CustomerWhereInput>
    branch?: XOR<BranchNullableRelationFilter, BranchWhereInput> | null
    items?: OrderItemListRelationFilter
    statusEvents?: OrderStatusEventListRelationFilter
    ledgerEntries?: LedgerEntryListRelationFilter
    convertedFromPreOrder?: XOR<PreOrderNullableRelationFilter, PreOrderWhereInput> | null
  }, "id" | "orderNumber">

  export type OrderOrderByWithAggregationInput = {
    id?: SortOrder
    orderNumber?: SortOrder
    customerId?: SortOrder
    branchId?: SortOrderInput | SortOrder
    channel?: SortOrder
    status?: SortOrder
    totalGoldWeightGrams?: SortOrder
    wageWeightGrams?: SortOrder
    flatRialCharge?: SortOrder
    isSuspendedOverCreditLimit?: SortOrder
    deliveredAt?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: OrderCountOrderByAggregateInput
    _avg?: OrderAvgOrderByAggregateInput
    _max?: OrderMaxOrderByAggregateInput
    _min?: OrderMinOrderByAggregateInput
    _sum?: OrderSumOrderByAggregateInput
  }

  export type OrderScalarWhereWithAggregatesInput = {
    AND?: OrderScalarWhereWithAggregatesInput | OrderScalarWhereWithAggregatesInput[]
    OR?: OrderScalarWhereWithAggregatesInput[]
    NOT?: OrderScalarWhereWithAggregatesInput | OrderScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Order"> | string
    orderNumber?: StringWithAggregatesFilter<"Order"> | string
    customerId?: StringWithAggregatesFilter<"Order"> | string
    branchId?: StringNullableWithAggregatesFilter<"Order"> | string | null
    channel?: EnumOrderChannelWithAggregatesFilter<"Order"> | $Enums.OrderChannel
    status?: EnumOrderStatusWithAggregatesFilter<"Order"> | $Enums.OrderStatus
    totalGoldWeightGrams?: DecimalWithAggregatesFilter<"Order"> | Decimal | DecimalJsLike | number | string
    wageWeightGrams?: DecimalWithAggregatesFilter<"Order"> | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalWithAggregatesFilter<"Order"> | Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: BoolWithAggregatesFilter<"Order"> | boolean
    deliveredAt?: DateTimeNullableWithAggregatesFilter<"Order"> | Date | string | null
    createdAt?: DateTimeWithAggregatesFilter<"Order"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Order"> | Date | string
  }

  export type OrderItemWhereInput = {
    AND?: OrderItemWhereInput | OrderItemWhereInput[]
    OR?: OrderItemWhereInput[]
    NOT?: OrderItemWhereInput | OrderItemWhereInput[]
    id?: StringFilter<"OrderItem"> | string
    orderId?: StringFilter<"OrderItem"> | string
    productVariantId?: StringFilter<"OrderItem"> | string
    quantity?: IntFilter<"OrderItem"> | number
    rashWeightGramsSnapshot?: DecimalFilter<"OrderItem"> | Decimal | DecimalJsLike | number | string
    wagePercentSnapshot?: DecimalFilter<"OrderItem"> | Decimal | DecimalJsLike | number | string
    discountPercentSnapshot?: DecimalFilter<"OrderItem"> | Decimal | DecimalJsLike | number | string
    computedWeightGrams?: DecimalFilter<"OrderItem"> | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFilter<"OrderItem"> | Decimal | DecimalJsLike | number | string
    order?: XOR<OrderRelationFilter, OrderWhereInput>
    productVariant?: XOR<ProductVariantRelationFilter, ProductVariantWhereInput>
  }

  export type OrderItemOrderByWithRelationInput = {
    id?: SortOrder
    orderId?: SortOrder
    productVariantId?: SortOrder
    quantity?: SortOrder
    rashWeightGramsSnapshot?: SortOrder
    wagePercentSnapshot?: SortOrder
    discountPercentSnapshot?: SortOrder
    computedWeightGrams?: SortOrder
    flatRialCharge?: SortOrder
    order?: OrderOrderByWithRelationInput
    productVariant?: ProductVariantOrderByWithRelationInput
  }

  export type OrderItemWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: OrderItemWhereInput | OrderItemWhereInput[]
    OR?: OrderItemWhereInput[]
    NOT?: OrderItemWhereInput | OrderItemWhereInput[]
    orderId?: StringFilter<"OrderItem"> | string
    productVariantId?: StringFilter<"OrderItem"> | string
    quantity?: IntFilter<"OrderItem"> | number
    rashWeightGramsSnapshot?: DecimalFilter<"OrderItem"> | Decimal | DecimalJsLike | number | string
    wagePercentSnapshot?: DecimalFilter<"OrderItem"> | Decimal | DecimalJsLike | number | string
    discountPercentSnapshot?: DecimalFilter<"OrderItem"> | Decimal | DecimalJsLike | number | string
    computedWeightGrams?: DecimalFilter<"OrderItem"> | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFilter<"OrderItem"> | Decimal | DecimalJsLike | number | string
    order?: XOR<OrderRelationFilter, OrderWhereInput>
    productVariant?: XOR<ProductVariantRelationFilter, ProductVariantWhereInput>
  }, "id">

  export type OrderItemOrderByWithAggregationInput = {
    id?: SortOrder
    orderId?: SortOrder
    productVariantId?: SortOrder
    quantity?: SortOrder
    rashWeightGramsSnapshot?: SortOrder
    wagePercentSnapshot?: SortOrder
    discountPercentSnapshot?: SortOrder
    computedWeightGrams?: SortOrder
    flatRialCharge?: SortOrder
    _count?: OrderItemCountOrderByAggregateInput
    _avg?: OrderItemAvgOrderByAggregateInput
    _max?: OrderItemMaxOrderByAggregateInput
    _min?: OrderItemMinOrderByAggregateInput
    _sum?: OrderItemSumOrderByAggregateInput
  }

  export type OrderItemScalarWhereWithAggregatesInput = {
    AND?: OrderItemScalarWhereWithAggregatesInput | OrderItemScalarWhereWithAggregatesInput[]
    OR?: OrderItemScalarWhereWithAggregatesInput[]
    NOT?: OrderItemScalarWhereWithAggregatesInput | OrderItemScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"OrderItem"> | string
    orderId?: StringWithAggregatesFilter<"OrderItem"> | string
    productVariantId?: StringWithAggregatesFilter<"OrderItem"> | string
    quantity?: IntWithAggregatesFilter<"OrderItem"> | number
    rashWeightGramsSnapshot?: DecimalWithAggregatesFilter<"OrderItem"> | Decimal | DecimalJsLike | number | string
    wagePercentSnapshot?: DecimalWithAggregatesFilter<"OrderItem"> | Decimal | DecimalJsLike | number | string
    discountPercentSnapshot?: DecimalWithAggregatesFilter<"OrderItem"> | Decimal | DecimalJsLike | number | string
    computedWeightGrams?: DecimalWithAggregatesFilter<"OrderItem"> | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalWithAggregatesFilter<"OrderItem"> | Decimal | DecimalJsLike | number | string
  }

  export type OrderStatusEventWhereInput = {
    AND?: OrderStatusEventWhereInput | OrderStatusEventWhereInput[]
    OR?: OrderStatusEventWhereInput[]
    NOT?: OrderStatusEventWhereInput | OrderStatusEventWhereInput[]
    id?: StringFilter<"OrderStatusEvent"> | string
    orderId?: StringFilter<"OrderStatusEvent"> | string
    fromStatus?: EnumOrderStatusNullableFilter<"OrderStatusEvent"> | $Enums.OrderStatus | null
    toStatus?: EnumOrderStatusFilter<"OrderStatusEvent"> | $Enums.OrderStatus
    note?: StringNullableFilter<"OrderStatusEvent"> | string | null
    actorAdminUserId?: StringNullableFilter<"OrderStatusEvent"> | string | null
    createdAt?: DateTimeFilter<"OrderStatusEvent"> | Date | string
    order?: XOR<OrderRelationFilter, OrderWhereInput>
    actorAdminUser?: XOR<AdminUserNullableRelationFilter, AdminUserWhereInput> | null
  }

  export type OrderStatusEventOrderByWithRelationInput = {
    id?: SortOrder
    orderId?: SortOrder
    fromStatus?: SortOrderInput | SortOrder
    toStatus?: SortOrder
    note?: SortOrderInput | SortOrder
    actorAdminUserId?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    order?: OrderOrderByWithRelationInput
    actorAdminUser?: AdminUserOrderByWithRelationInput
  }

  export type OrderStatusEventWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: OrderStatusEventWhereInput | OrderStatusEventWhereInput[]
    OR?: OrderStatusEventWhereInput[]
    NOT?: OrderStatusEventWhereInput | OrderStatusEventWhereInput[]
    orderId?: StringFilter<"OrderStatusEvent"> | string
    fromStatus?: EnumOrderStatusNullableFilter<"OrderStatusEvent"> | $Enums.OrderStatus | null
    toStatus?: EnumOrderStatusFilter<"OrderStatusEvent"> | $Enums.OrderStatus
    note?: StringNullableFilter<"OrderStatusEvent"> | string | null
    actorAdminUserId?: StringNullableFilter<"OrderStatusEvent"> | string | null
    createdAt?: DateTimeFilter<"OrderStatusEvent"> | Date | string
    order?: XOR<OrderRelationFilter, OrderWhereInput>
    actorAdminUser?: XOR<AdminUserNullableRelationFilter, AdminUserWhereInput> | null
  }, "id">

  export type OrderStatusEventOrderByWithAggregationInput = {
    id?: SortOrder
    orderId?: SortOrder
    fromStatus?: SortOrderInput | SortOrder
    toStatus?: SortOrder
    note?: SortOrderInput | SortOrder
    actorAdminUserId?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    _count?: OrderStatusEventCountOrderByAggregateInput
    _max?: OrderStatusEventMaxOrderByAggregateInput
    _min?: OrderStatusEventMinOrderByAggregateInput
  }

  export type OrderStatusEventScalarWhereWithAggregatesInput = {
    AND?: OrderStatusEventScalarWhereWithAggregatesInput | OrderStatusEventScalarWhereWithAggregatesInput[]
    OR?: OrderStatusEventScalarWhereWithAggregatesInput[]
    NOT?: OrderStatusEventScalarWhereWithAggregatesInput | OrderStatusEventScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"OrderStatusEvent"> | string
    orderId?: StringWithAggregatesFilter<"OrderStatusEvent"> | string
    fromStatus?: EnumOrderStatusNullableWithAggregatesFilter<"OrderStatusEvent"> | $Enums.OrderStatus | null
    toStatus?: EnumOrderStatusWithAggregatesFilter<"OrderStatusEvent"> | $Enums.OrderStatus
    note?: StringNullableWithAggregatesFilter<"OrderStatusEvent"> | string | null
    actorAdminUserId?: StringNullableWithAggregatesFilter<"OrderStatusEvent"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"OrderStatusEvent"> | Date | string
  }

  export type PreOrderWhereInput = {
    AND?: PreOrderWhereInput | PreOrderWhereInput[]
    OR?: PreOrderWhereInput[]
    NOT?: PreOrderWhereInput | PreOrderWhereInput[]
    id?: StringFilter<"PreOrder"> | string
    customerId?: StringFilter<"PreOrder"> | string
    cityId?: StringNullableFilter<"PreOrder"> | string | null
    workshopId?: StringNullableFilter<"PreOrder"> | string | null
    status?: EnumPreOrderStatusFilter<"PreOrder"> | $Enums.PreOrderStatus
    designImageUrl?: StringNullableFilter<"PreOrder"> | string | null
    colorName?: StringNullableFilter<"PreOrder"> | string | null
    sizeSpec?: StringNullableFilter<"PreOrder"> | string | null
    stoneColor?: StringNullableFilter<"PreOrder"> | string | null
    minaColor?: StringNullableFilter<"PreOrder"> | string | null
    estimatedWeightGrams?: DecimalNullableFilter<"PreOrder"> | Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: DecimalNullableFilter<"PreOrder"> | Decimal | DecimalJsLike | number | string | null
    description?: StringNullableFilter<"PreOrder"> | string | null
    convertedOrderId?: StringNullableFilter<"PreOrder"> | string | null
    createdAt?: DateTimeFilter<"PreOrder"> | Date | string
    updatedAt?: DateTimeFilter<"PreOrder"> | Date | string
    customer?: XOR<CustomerRelationFilter, CustomerWhereInput>
    city?: XOR<CityNullableRelationFilter, CityWhereInput> | null
    workshop?: XOR<WorkshopNullableRelationFilter, WorkshopWhereInput> | null
    convertedOrder?: XOR<OrderNullableRelationFilter, OrderWhereInput> | null
    statusEvents?: PreOrderStatusEventListRelationFilter
  }

  export type PreOrderOrderByWithRelationInput = {
    id?: SortOrder
    customerId?: SortOrder
    cityId?: SortOrderInput | SortOrder
    workshopId?: SortOrderInput | SortOrder
    status?: SortOrder
    designImageUrl?: SortOrderInput | SortOrder
    colorName?: SortOrderInput | SortOrder
    sizeSpec?: SortOrderInput | SortOrder
    stoneColor?: SortOrderInput | SortOrder
    minaColor?: SortOrderInput | SortOrder
    estimatedWeightGrams?: SortOrderInput | SortOrder
    estimatedPriceRial?: SortOrderInput | SortOrder
    description?: SortOrderInput | SortOrder
    convertedOrderId?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    customer?: CustomerOrderByWithRelationInput
    city?: CityOrderByWithRelationInput
    workshop?: WorkshopOrderByWithRelationInput
    convertedOrder?: OrderOrderByWithRelationInput
    statusEvents?: PreOrderStatusEventOrderByRelationAggregateInput
  }

  export type PreOrderWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    convertedOrderId?: string
    AND?: PreOrderWhereInput | PreOrderWhereInput[]
    OR?: PreOrderWhereInput[]
    NOT?: PreOrderWhereInput | PreOrderWhereInput[]
    customerId?: StringFilter<"PreOrder"> | string
    cityId?: StringNullableFilter<"PreOrder"> | string | null
    workshopId?: StringNullableFilter<"PreOrder"> | string | null
    status?: EnumPreOrderStatusFilter<"PreOrder"> | $Enums.PreOrderStatus
    designImageUrl?: StringNullableFilter<"PreOrder"> | string | null
    colorName?: StringNullableFilter<"PreOrder"> | string | null
    sizeSpec?: StringNullableFilter<"PreOrder"> | string | null
    stoneColor?: StringNullableFilter<"PreOrder"> | string | null
    minaColor?: StringNullableFilter<"PreOrder"> | string | null
    estimatedWeightGrams?: DecimalNullableFilter<"PreOrder"> | Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: DecimalNullableFilter<"PreOrder"> | Decimal | DecimalJsLike | number | string | null
    description?: StringNullableFilter<"PreOrder"> | string | null
    createdAt?: DateTimeFilter<"PreOrder"> | Date | string
    updatedAt?: DateTimeFilter<"PreOrder"> | Date | string
    customer?: XOR<CustomerRelationFilter, CustomerWhereInput>
    city?: XOR<CityNullableRelationFilter, CityWhereInput> | null
    workshop?: XOR<WorkshopNullableRelationFilter, WorkshopWhereInput> | null
    convertedOrder?: XOR<OrderNullableRelationFilter, OrderWhereInput> | null
    statusEvents?: PreOrderStatusEventListRelationFilter
  }, "id" | "convertedOrderId">

  export type PreOrderOrderByWithAggregationInput = {
    id?: SortOrder
    customerId?: SortOrder
    cityId?: SortOrderInput | SortOrder
    workshopId?: SortOrderInput | SortOrder
    status?: SortOrder
    designImageUrl?: SortOrderInput | SortOrder
    colorName?: SortOrderInput | SortOrder
    sizeSpec?: SortOrderInput | SortOrder
    stoneColor?: SortOrderInput | SortOrder
    minaColor?: SortOrderInput | SortOrder
    estimatedWeightGrams?: SortOrderInput | SortOrder
    estimatedPriceRial?: SortOrderInput | SortOrder
    description?: SortOrderInput | SortOrder
    convertedOrderId?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: PreOrderCountOrderByAggregateInput
    _avg?: PreOrderAvgOrderByAggregateInput
    _max?: PreOrderMaxOrderByAggregateInput
    _min?: PreOrderMinOrderByAggregateInput
    _sum?: PreOrderSumOrderByAggregateInput
  }

  export type PreOrderScalarWhereWithAggregatesInput = {
    AND?: PreOrderScalarWhereWithAggregatesInput | PreOrderScalarWhereWithAggregatesInput[]
    OR?: PreOrderScalarWhereWithAggregatesInput[]
    NOT?: PreOrderScalarWhereWithAggregatesInput | PreOrderScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"PreOrder"> | string
    customerId?: StringWithAggregatesFilter<"PreOrder"> | string
    cityId?: StringNullableWithAggregatesFilter<"PreOrder"> | string | null
    workshopId?: StringNullableWithAggregatesFilter<"PreOrder"> | string | null
    status?: EnumPreOrderStatusWithAggregatesFilter<"PreOrder"> | $Enums.PreOrderStatus
    designImageUrl?: StringNullableWithAggregatesFilter<"PreOrder"> | string | null
    colorName?: StringNullableWithAggregatesFilter<"PreOrder"> | string | null
    sizeSpec?: StringNullableWithAggregatesFilter<"PreOrder"> | string | null
    stoneColor?: StringNullableWithAggregatesFilter<"PreOrder"> | string | null
    minaColor?: StringNullableWithAggregatesFilter<"PreOrder"> | string | null
    estimatedWeightGrams?: DecimalNullableWithAggregatesFilter<"PreOrder"> | Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: DecimalNullableWithAggregatesFilter<"PreOrder"> | Decimal | DecimalJsLike | number | string | null
    description?: StringNullableWithAggregatesFilter<"PreOrder"> | string | null
    convertedOrderId?: StringNullableWithAggregatesFilter<"PreOrder"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"PreOrder"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"PreOrder"> | Date | string
  }

  export type PreOrderStatusEventWhereInput = {
    AND?: PreOrderStatusEventWhereInput | PreOrderStatusEventWhereInput[]
    OR?: PreOrderStatusEventWhereInput[]
    NOT?: PreOrderStatusEventWhereInput | PreOrderStatusEventWhereInput[]
    id?: StringFilter<"PreOrderStatusEvent"> | string
    preOrderId?: StringFilter<"PreOrderStatusEvent"> | string
    changes?: JsonFilter<"PreOrderStatusEvent">
    actorAdminUserId?: StringNullableFilter<"PreOrderStatusEvent"> | string | null
    ipAddress?: StringNullableFilter<"PreOrderStatusEvent"> | string | null
    createdAt?: DateTimeFilter<"PreOrderStatusEvent"> | Date | string
    preOrder?: XOR<PreOrderRelationFilter, PreOrderWhereInput>
    actorAdminUser?: XOR<AdminUserNullableRelationFilter, AdminUserWhereInput> | null
  }

  export type PreOrderStatusEventOrderByWithRelationInput = {
    id?: SortOrder
    preOrderId?: SortOrder
    changes?: SortOrder
    actorAdminUserId?: SortOrderInput | SortOrder
    ipAddress?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    preOrder?: PreOrderOrderByWithRelationInput
    actorAdminUser?: AdminUserOrderByWithRelationInput
  }

  export type PreOrderStatusEventWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: PreOrderStatusEventWhereInput | PreOrderStatusEventWhereInput[]
    OR?: PreOrderStatusEventWhereInput[]
    NOT?: PreOrderStatusEventWhereInput | PreOrderStatusEventWhereInput[]
    preOrderId?: StringFilter<"PreOrderStatusEvent"> | string
    changes?: JsonFilter<"PreOrderStatusEvent">
    actorAdminUserId?: StringNullableFilter<"PreOrderStatusEvent"> | string | null
    ipAddress?: StringNullableFilter<"PreOrderStatusEvent"> | string | null
    createdAt?: DateTimeFilter<"PreOrderStatusEvent"> | Date | string
    preOrder?: XOR<PreOrderRelationFilter, PreOrderWhereInput>
    actorAdminUser?: XOR<AdminUserNullableRelationFilter, AdminUserWhereInput> | null
  }, "id">

  export type PreOrderStatusEventOrderByWithAggregationInput = {
    id?: SortOrder
    preOrderId?: SortOrder
    changes?: SortOrder
    actorAdminUserId?: SortOrderInput | SortOrder
    ipAddress?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    _count?: PreOrderStatusEventCountOrderByAggregateInput
    _max?: PreOrderStatusEventMaxOrderByAggregateInput
    _min?: PreOrderStatusEventMinOrderByAggregateInput
  }

  export type PreOrderStatusEventScalarWhereWithAggregatesInput = {
    AND?: PreOrderStatusEventScalarWhereWithAggregatesInput | PreOrderStatusEventScalarWhereWithAggregatesInput[]
    OR?: PreOrderStatusEventScalarWhereWithAggregatesInput[]
    NOT?: PreOrderStatusEventScalarWhereWithAggregatesInput | PreOrderStatusEventScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"PreOrderStatusEvent"> | string
    preOrderId?: StringWithAggregatesFilter<"PreOrderStatusEvent"> | string
    changes?: JsonWithAggregatesFilter<"PreOrderStatusEvent">
    actorAdminUserId?: StringNullableWithAggregatesFilter<"PreOrderStatusEvent"> | string | null
    ipAddress?: StringNullableWithAggregatesFilter<"PreOrderStatusEvent"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"PreOrderStatusEvent"> | Date | string
  }

  export type LedgerEntryWhereInput = {
    AND?: LedgerEntryWhereInput | LedgerEntryWhereInput[]
    OR?: LedgerEntryWhereInput[]
    NOT?: LedgerEntryWhereInput | LedgerEntryWhereInput[]
    id?: StringFilter<"LedgerEntry"> | string
    customerId?: StringFilter<"LedgerEntry"> | string
    currency?: EnumLedgerCurrencyFilter<"LedgerEntry"> | $Enums.LedgerCurrency
    direction?: EnumLedgerDirectionFilter<"LedgerEntry"> | $Enums.LedgerDirection
    sourceType?: EnumLedgerSourceTypeFilter<"LedgerEntry"> | $Enums.LedgerSourceType
    amount?: DecimalFilter<"LedgerEntry"> | Decimal | DecimalJsLike | number | string
    karatPerMille?: IntNullableFilter<"LedgerEntry"> | number | null
    pricePerGramRialAtEntry?: DecimalNullableFilter<"LedgerEntry"> | Decimal | DecimalJsLike | number | string | null
    orderId?: StringNullableFilter<"LedgerEntry"> | string | null
    confirmed?: BoolFilter<"LedgerEntry"> | boolean
    confirmedAt?: DateTimeNullableFilter<"LedgerEntry"> | Date | string | null
    postedByAdminUserId?: StringNullableFilter<"LedgerEntry"> | string | null
    labName?: StringNullableFilter<"LedgerEntry"> | string | null
    hallmark?: StringNullableFilter<"LedgerEntry"> | string | null
    accountName?: StringNullableFilter<"LedgerEntry"> | string | null
    bankName?: StringNullableFilter<"LedgerEntry"> | string | null
    transferTo?: StringNullableFilter<"LedgerEntry"> | string | null
    originalValue?: DecimalNullableFilter<"LedgerEntry"> | Decimal | DecimalJsLike | number | string | null
    priceRial?: DecimalNullableFilter<"LedgerEntry"> | Decimal | DecimalJsLike | number | string | null
    receivedAt?: DateTimeNullableFilter<"LedgerEntry"> | Date | string | null
    note?: StringNullableFilter<"LedgerEntry"> | string | null
    createdAt?: DateTimeFilter<"LedgerEntry"> | Date | string
    customer?: XOR<CustomerRelationFilter, CustomerWhereInput>
    order?: XOR<OrderNullableRelationFilter, OrderWhereInput> | null
    postedByAdminUser?: XOR<AdminUserNullableRelationFilter, AdminUserWhereInput> | null
  }

  export type LedgerEntryOrderByWithRelationInput = {
    id?: SortOrder
    customerId?: SortOrder
    currency?: SortOrder
    direction?: SortOrder
    sourceType?: SortOrder
    amount?: SortOrder
    karatPerMille?: SortOrderInput | SortOrder
    pricePerGramRialAtEntry?: SortOrderInput | SortOrder
    orderId?: SortOrderInput | SortOrder
    confirmed?: SortOrder
    confirmedAt?: SortOrderInput | SortOrder
    postedByAdminUserId?: SortOrderInput | SortOrder
    labName?: SortOrderInput | SortOrder
    hallmark?: SortOrderInput | SortOrder
    accountName?: SortOrderInput | SortOrder
    bankName?: SortOrderInput | SortOrder
    transferTo?: SortOrderInput | SortOrder
    originalValue?: SortOrderInput | SortOrder
    priceRial?: SortOrderInput | SortOrder
    receivedAt?: SortOrderInput | SortOrder
    note?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    customer?: CustomerOrderByWithRelationInput
    order?: OrderOrderByWithRelationInput
    postedByAdminUser?: AdminUserOrderByWithRelationInput
  }

  export type LedgerEntryWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: LedgerEntryWhereInput | LedgerEntryWhereInput[]
    OR?: LedgerEntryWhereInput[]
    NOT?: LedgerEntryWhereInput | LedgerEntryWhereInput[]
    customerId?: StringFilter<"LedgerEntry"> | string
    currency?: EnumLedgerCurrencyFilter<"LedgerEntry"> | $Enums.LedgerCurrency
    direction?: EnumLedgerDirectionFilter<"LedgerEntry"> | $Enums.LedgerDirection
    sourceType?: EnumLedgerSourceTypeFilter<"LedgerEntry"> | $Enums.LedgerSourceType
    amount?: DecimalFilter<"LedgerEntry"> | Decimal | DecimalJsLike | number | string
    karatPerMille?: IntNullableFilter<"LedgerEntry"> | number | null
    pricePerGramRialAtEntry?: DecimalNullableFilter<"LedgerEntry"> | Decimal | DecimalJsLike | number | string | null
    orderId?: StringNullableFilter<"LedgerEntry"> | string | null
    confirmed?: BoolFilter<"LedgerEntry"> | boolean
    confirmedAt?: DateTimeNullableFilter<"LedgerEntry"> | Date | string | null
    postedByAdminUserId?: StringNullableFilter<"LedgerEntry"> | string | null
    labName?: StringNullableFilter<"LedgerEntry"> | string | null
    hallmark?: StringNullableFilter<"LedgerEntry"> | string | null
    accountName?: StringNullableFilter<"LedgerEntry"> | string | null
    bankName?: StringNullableFilter<"LedgerEntry"> | string | null
    transferTo?: StringNullableFilter<"LedgerEntry"> | string | null
    originalValue?: DecimalNullableFilter<"LedgerEntry"> | Decimal | DecimalJsLike | number | string | null
    priceRial?: DecimalNullableFilter<"LedgerEntry"> | Decimal | DecimalJsLike | number | string | null
    receivedAt?: DateTimeNullableFilter<"LedgerEntry"> | Date | string | null
    note?: StringNullableFilter<"LedgerEntry"> | string | null
    createdAt?: DateTimeFilter<"LedgerEntry"> | Date | string
    customer?: XOR<CustomerRelationFilter, CustomerWhereInput>
    order?: XOR<OrderNullableRelationFilter, OrderWhereInput> | null
    postedByAdminUser?: XOR<AdminUserNullableRelationFilter, AdminUserWhereInput> | null
  }, "id">

  export type LedgerEntryOrderByWithAggregationInput = {
    id?: SortOrder
    customerId?: SortOrder
    currency?: SortOrder
    direction?: SortOrder
    sourceType?: SortOrder
    amount?: SortOrder
    karatPerMille?: SortOrderInput | SortOrder
    pricePerGramRialAtEntry?: SortOrderInput | SortOrder
    orderId?: SortOrderInput | SortOrder
    confirmed?: SortOrder
    confirmedAt?: SortOrderInput | SortOrder
    postedByAdminUserId?: SortOrderInput | SortOrder
    labName?: SortOrderInput | SortOrder
    hallmark?: SortOrderInput | SortOrder
    accountName?: SortOrderInput | SortOrder
    bankName?: SortOrderInput | SortOrder
    transferTo?: SortOrderInput | SortOrder
    originalValue?: SortOrderInput | SortOrder
    priceRial?: SortOrderInput | SortOrder
    receivedAt?: SortOrderInput | SortOrder
    note?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    _count?: LedgerEntryCountOrderByAggregateInput
    _avg?: LedgerEntryAvgOrderByAggregateInput
    _max?: LedgerEntryMaxOrderByAggregateInput
    _min?: LedgerEntryMinOrderByAggregateInput
    _sum?: LedgerEntrySumOrderByAggregateInput
  }

  export type LedgerEntryScalarWhereWithAggregatesInput = {
    AND?: LedgerEntryScalarWhereWithAggregatesInput | LedgerEntryScalarWhereWithAggregatesInput[]
    OR?: LedgerEntryScalarWhereWithAggregatesInput[]
    NOT?: LedgerEntryScalarWhereWithAggregatesInput | LedgerEntryScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"LedgerEntry"> | string
    customerId?: StringWithAggregatesFilter<"LedgerEntry"> | string
    currency?: EnumLedgerCurrencyWithAggregatesFilter<"LedgerEntry"> | $Enums.LedgerCurrency
    direction?: EnumLedgerDirectionWithAggregatesFilter<"LedgerEntry"> | $Enums.LedgerDirection
    sourceType?: EnumLedgerSourceTypeWithAggregatesFilter<"LedgerEntry"> | $Enums.LedgerSourceType
    amount?: DecimalWithAggregatesFilter<"LedgerEntry"> | Decimal | DecimalJsLike | number | string
    karatPerMille?: IntNullableWithAggregatesFilter<"LedgerEntry"> | number | null
    pricePerGramRialAtEntry?: DecimalNullableWithAggregatesFilter<"LedgerEntry"> | Decimal | DecimalJsLike | number | string | null
    orderId?: StringNullableWithAggregatesFilter<"LedgerEntry"> | string | null
    confirmed?: BoolWithAggregatesFilter<"LedgerEntry"> | boolean
    confirmedAt?: DateTimeNullableWithAggregatesFilter<"LedgerEntry"> | Date | string | null
    postedByAdminUserId?: StringNullableWithAggregatesFilter<"LedgerEntry"> | string | null
    labName?: StringNullableWithAggregatesFilter<"LedgerEntry"> | string | null
    hallmark?: StringNullableWithAggregatesFilter<"LedgerEntry"> | string | null
    accountName?: StringNullableWithAggregatesFilter<"LedgerEntry"> | string | null
    bankName?: StringNullableWithAggregatesFilter<"LedgerEntry"> | string | null
    transferTo?: StringNullableWithAggregatesFilter<"LedgerEntry"> | string | null
    originalValue?: DecimalNullableWithAggregatesFilter<"LedgerEntry"> | Decimal | DecimalJsLike | number | string | null
    priceRial?: DecimalNullableWithAggregatesFilter<"LedgerEntry"> | Decimal | DecimalJsLike | number | string | null
    receivedAt?: DateTimeNullableWithAggregatesFilter<"LedgerEntry"> | Date | string | null
    note?: StringNullableWithAggregatesFilter<"LedgerEntry"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"LedgerEntry"> | Date | string
  }

  export type GoldPriceQuoteWhereInput = {
    AND?: GoldPriceQuoteWhereInput | GoldPriceQuoteWhereInput[]
    OR?: GoldPriceQuoteWhereInput[]
    NOT?: GoldPriceQuoteWhereInput | GoldPriceQuoteWhereInput[]
    id?: StringFilter<"GoldPriceQuote"> | string
    karatPerMille?: IntFilter<"GoldPriceQuote"> | number
    pricePerGramRial?: DecimalFilter<"GoldPriceQuote"> | Decimal | DecimalJsLike | number | string
    source?: StringFilter<"GoldPriceQuote"> | string
    quotedAt?: DateTimeFilter<"GoldPriceQuote"> | Date | string
  }

  export type GoldPriceQuoteOrderByWithRelationInput = {
    id?: SortOrder
    karatPerMille?: SortOrder
    pricePerGramRial?: SortOrder
    source?: SortOrder
    quotedAt?: SortOrder
  }

  export type GoldPriceQuoteWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: GoldPriceQuoteWhereInput | GoldPriceQuoteWhereInput[]
    OR?: GoldPriceQuoteWhereInput[]
    NOT?: GoldPriceQuoteWhereInput | GoldPriceQuoteWhereInput[]
    karatPerMille?: IntFilter<"GoldPriceQuote"> | number
    pricePerGramRial?: DecimalFilter<"GoldPriceQuote"> | Decimal | DecimalJsLike | number | string
    source?: StringFilter<"GoldPriceQuote"> | string
    quotedAt?: DateTimeFilter<"GoldPriceQuote"> | Date | string
  }, "id">

  export type GoldPriceQuoteOrderByWithAggregationInput = {
    id?: SortOrder
    karatPerMille?: SortOrder
    pricePerGramRial?: SortOrder
    source?: SortOrder
    quotedAt?: SortOrder
    _count?: GoldPriceQuoteCountOrderByAggregateInput
    _avg?: GoldPriceQuoteAvgOrderByAggregateInput
    _max?: GoldPriceQuoteMaxOrderByAggregateInput
    _min?: GoldPriceQuoteMinOrderByAggregateInput
    _sum?: GoldPriceQuoteSumOrderByAggregateInput
  }

  export type GoldPriceQuoteScalarWhereWithAggregatesInput = {
    AND?: GoldPriceQuoteScalarWhereWithAggregatesInput | GoldPriceQuoteScalarWhereWithAggregatesInput[]
    OR?: GoldPriceQuoteScalarWhereWithAggregatesInput[]
    NOT?: GoldPriceQuoteScalarWhereWithAggregatesInput | GoldPriceQuoteScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"GoldPriceQuote"> | string
    karatPerMille?: IntWithAggregatesFilter<"GoldPriceQuote"> | number
    pricePerGramRial?: DecimalWithAggregatesFilter<"GoldPriceQuote"> | Decimal | DecimalJsLike | number | string
    source?: StringWithAggregatesFilter<"GoldPriceQuote"> | string
    quotedAt?: DateTimeWithAggregatesFilter<"GoldPriceQuote"> | Date | string
  }

  export type WalletBonusWhereInput = {
    AND?: WalletBonusWhereInput | WalletBonusWhereInput[]
    OR?: WalletBonusWhereInput[]
    NOT?: WalletBonusWhereInput | WalletBonusWhereInput[]
    id?: StringFilter<"WalletBonus"> | string
    customerId?: StringFilter<"WalletBonus"> | string
    orderId?: StringNullableFilter<"WalletBonus"> | string | null
    goldGrams?: DecimalFilter<"WalletBonus"> | Decimal | DecimalJsLike | number | string
    grantedAt?: DateTimeFilter<"WalletBonus"> | Date | string
    expiresAt?: DateTimeFilter<"WalletBonus"> | Date | string
    consumedAt?: DateTimeNullableFilter<"WalletBonus"> | Date | string | null
    isActive?: BoolFilter<"WalletBonus"> | boolean
    customer?: XOR<CustomerRelationFilter, CustomerWhereInput>
  }

  export type WalletBonusOrderByWithRelationInput = {
    id?: SortOrder
    customerId?: SortOrder
    orderId?: SortOrderInput | SortOrder
    goldGrams?: SortOrder
    grantedAt?: SortOrder
    expiresAt?: SortOrder
    consumedAt?: SortOrderInput | SortOrder
    isActive?: SortOrder
    customer?: CustomerOrderByWithRelationInput
  }

  export type WalletBonusWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: WalletBonusWhereInput | WalletBonusWhereInput[]
    OR?: WalletBonusWhereInput[]
    NOT?: WalletBonusWhereInput | WalletBonusWhereInput[]
    customerId?: StringFilter<"WalletBonus"> | string
    orderId?: StringNullableFilter<"WalletBonus"> | string | null
    goldGrams?: DecimalFilter<"WalletBonus"> | Decimal | DecimalJsLike | number | string
    grantedAt?: DateTimeFilter<"WalletBonus"> | Date | string
    expiresAt?: DateTimeFilter<"WalletBonus"> | Date | string
    consumedAt?: DateTimeNullableFilter<"WalletBonus"> | Date | string | null
    isActive?: BoolFilter<"WalletBonus"> | boolean
    customer?: XOR<CustomerRelationFilter, CustomerWhereInput>
  }, "id">

  export type WalletBonusOrderByWithAggregationInput = {
    id?: SortOrder
    customerId?: SortOrder
    orderId?: SortOrderInput | SortOrder
    goldGrams?: SortOrder
    grantedAt?: SortOrder
    expiresAt?: SortOrder
    consumedAt?: SortOrderInput | SortOrder
    isActive?: SortOrder
    _count?: WalletBonusCountOrderByAggregateInput
    _avg?: WalletBonusAvgOrderByAggregateInput
    _max?: WalletBonusMaxOrderByAggregateInput
    _min?: WalletBonusMinOrderByAggregateInput
    _sum?: WalletBonusSumOrderByAggregateInput
  }

  export type WalletBonusScalarWhereWithAggregatesInput = {
    AND?: WalletBonusScalarWhereWithAggregatesInput | WalletBonusScalarWhereWithAggregatesInput[]
    OR?: WalletBonusScalarWhereWithAggregatesInput[]
    NOT?: WalletBonusScalarWhereWithAggregatesInput | WalletBonusScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"WalletBonus"> | string
    customerId?: StringWithAggregatesFilter<"WalletBonus"> | string
    orderId?: StringNullableWithAggregatesFilter<"WalletBonus"> | string | null
    goldGrams?: DecimalWithAggregatesFilter<"WalletBonus"> | Decimal | DecimalJsLike | number | string
    grantedAt?: DateTimeWithAggregatesFilter<"WalletBonus"> | Date | string
    expiresAt?: DateTimeWithAggregatesFilter<"WalletBonus"> | Date | string
    consumedAt?: DateTimeNullableWithAggregatesFilter<"WalletBonus"> | Date | string | null
    isActive?: BoolWithAggregatesFilter<"WalletBonus"> | boolean
  }

  export type UserTypeWhereInput = {
    AND?: UserTypeWhereInput | UserTypeWhereInput[]
    OR?: UserTypeWhereInput[]
    NOT?: UserTypeWhereInput | UserTypeWhereInput[]
    id?: IntFilter<"UserType"> | number
    title?: StringFilter<"UserType"> | string
    isActive?: BoolFilter<"UserType"> | boolean
    createdAt?: DateTimeFilter<"UserType"> | Date | string
    permissions?: PermissionListRelationFilter
    adminUsers?: AdminUserListRelationFilter
  }

  export type UserTypeOrderByWithRelationInput = {
    id?: SortOrder
    title?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    permissions?: PermissionOrderByRelationAggregateInput
    adminUsers?: AdminUserOrderByRelationAggregateInput
  }

  export type UserTypeWhereUniqueInput = Prisma.AtLeast<{
    id?: number
    AND?: UserTypeWhereInput | UserTypeWhereInput[]
    OR?: UserTypeWhereInput[]
    NOT?: UserTypeWhereInput | UserTypeWhereInput[]
    title?: StringFilter<"UserType"> | string
    isActive?: BoolFilter<"UserType"> | boolean
    createdAt?: DateTimeFilter<"UserType"> | Date | string
    permissions?: PermissionListRelationFilter
    adminUsers?: AdminUserListRelationFilter
  }, "id">

  export type UserTypeOrderByWithAggregationInput = {
    id?: SortOrder
    title?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    _count?: UserTypeCountOrderByAggregateInput
    _avg?: UserTypeAvgOrderByAggregateInput
    _max?: UserTypeMaxOrderByAggregateInput
    _min?: UserTypeMinOrderByAggregateInput
    _sum?: UserTypeSumOrderByAggregateInput
  }

  export type UserTypeScalarWhereWithAggregatesInput = {
    AND?: UserTypeScalarWhereWithAggregatesInput | UserTypeScalarWhereWithAggregatesInput[]
    OR?: UserTypeScalarWhereWithAggregatesInput[]
    NOT?: UserTypeScalarWhereWithAggregatesInput | UserTypeScalarWhereWithAggregatesInput[]
    id?: IntWithAggregatesFilter<"UserType"> | number
    title?: StringWithAggregatesFilter<"UserType"> | string
    isActive?: BoolWithAggregatesFilter<"UserType"> | boolean
    createdAt?: DateTimeWithAggregatesFilter<"UserType"> | Date | string
  }

  export type PermissionWhereInput = {
    AND?: PermissionWhereInput | PermissionWhereInput[]
    OR?: PermissionWhereInput[]
    NOT?: PermissionWhereInput | PermissionWhereInput[]
    rid?: StringFilter<"Permission"> | string
    userTypeId?: IntFilter<"Permission"> | number
    userType?: XOR<UserTypeRelationFilter, UserTypeWhereInput>
  }

  export type PermissionOrderByWithRelationInput = {
    rid?: SortOrder
    userTypeId?: SortOrder
    userType?: UserTypeOrderByWithRelationInput
  }

  export type PermissionWhereUniqueInput = Prisma.AtLeast<{
    rid_userTypeId?: PermissionRidUserTypeIdCompoundUniqueInput
    AND?: PermissionWhereInput | PermissionWhereInput[]
    OR?: PermissionWhereInput[]
    NOT?: PermissionWhereInput | PermissionWhereInput[]
    rid?: StringFilter<"Permission"> | string
    userTypeId?: IntFilter<"Permission"> | number
    userType?: XOR<UserTypeRelationFilter, UserTypeWhereInput>
  }, "rid_userTypeId">

  export type PermissionOrderByWithAggregationInput = {
    rid?: SortOrder
    userTypeId?: SortOrder
    _count?: PermissionCountOrderByAggregateInput
    _avg?: PermissionAvgOrderByAggregateInput
    _max?: PermissionMaxOrderByAggregateInput
    _min?: PermissionMinOrderByAggregateInput
    _sum?: PermissionSumOrderByAggregateInput
  }

  export type PermissionScalarWhereWithAggregatesInput = {
    AND?: PermissionScalarWhereWithAggregatesInput | PermissionScalarWhereWithAggregatesInput[]
    OR?: PermissionScalarWhereWithAggregatesInput[]
    NOT?: PermissionScalarWhereWithAggregatesInput | PermissionScalarWhereWithAggregatesInput[]
    rid?: StringWithAggregatesFilter<"Permission"> | string
    userTypeId?: IntWithAggregatesFilter<"Permission"> | number
  }

  export type CommentWhereInput = {
    AND?: CommentWhereInput | CommentWhereInput[]
    OR?: CommentWhereInput[]
    NOT?: CommentWhereInput | CommentWhereInput[]
    id?: StringFilter<"Comment"> | string
    productId?: StringFilter<"Comment"> | string
    customerId?: StringFilter<"Comment"> | string
    body?: StringFilter<"Comment"> | string
    status?: EnumCommentStatusFilter<"Comment"> | $Enums.CommentStatus
    replyToId?: StringNullableFilter<"Comment"> | string | null
    createdAt?: DateTimeFilter<"Comment"> | Date | string
    updatedAt?: DateTimeFilter<"Comment"> | Date | string
    product?: XOR<ProductRelationFilter, ProductWhereInput>
    customer?: XOR<CustomerRelationFilter, CustomerWhereInput>
    replyTo?: XOR<CommentNullableRelationFilter, CommentWhereInput> | null
    replies?: CommentListRelationFilter
  }

  export type CommentOrderByWithRelationInput = {
    id?: SortOrder
    productId?: SortOrder
    customerId?: SortOrder
    body?: SortOrder
    status?: SortOrder
    replyToId?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    product?: ProductOrderByWithRelationInput
    customer?: CustomerOrderByWithRelationInput
    replyTo?: CommentOrderByWithRelationInput
    replies?: CommentOrderByRelationAggregateInput
  }

  export type CommentWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: CommentWhereInput | CommentWhereInput[]
    OR?: CommentWhereInput[]
    NOT?: CommentWhereInput | CommentWhereInput[]
    productId?: StringFilter<"Comment"> | string
    customerId?: StringFilter<"Comment"> | string
    body?: StringFilter<"Comment"> | string
    status?: EnumCommentStatusFilter<"Comment"> | $Enums.CommentStatus
    replyToId?: StringNullableFilter<"Comment"> | string | null
    createdAt?: DateTimeFilter<"Comment"> | Date | string
    updatedAt?: DateTimeFilter<"Comment"> | Date | string
    product?: XOR<ProductRelationFilter, ProductWhereInput>
    customer?: XOR<CustomerRelationFilter, CustomerWhereInput>
    replyTo?: XOR<CommentNullableRelationFilter, CommentWhereInput> | null
    replies?: CommentListRelationFilter
  }, "id">

  export type CommentOrderByWithAggregationInput = {
    id?: SortOrder
    productId?: SortOrder
    customerId?: SortOrder
    body?: SortOrder
    status?: SortOrder
    replyToId?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: CommentCountOrderByAggregateInput
    _max?: CommentMaxOrderByAggregateInput
    _min?: CommentMinOrderByAggregateInput
  }

  export type CommentScalarWhereWithAggregatesInput = {
    AND?: CommentScalarWhereWithAggregatesInput | CommentScalarWhereWithAggregatesInput[]
    OR?: CommentScalarWhereWithAggregatesInput[]
    NOT?: CommentScalarWhereWithAggregatesInput | CommentScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Comment"> | string
    productId?: StringWithAggregatesFilter<"Comment"> | string
    customerId?: StringWithAggregatesFilter<"Comment"> | string
    body?: StringWithAggregatesFilter<"Comment"> | string
    status?: EnumCommentStatusWithAggregatesFilter<"Comment"> | $Enums.CommentStatus
    replyToId?: StringNullableWithAggregatesFilter<"Comment"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"Comment"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Comment"> | Date | string
  }

  export type SettingWhereInput = {
    AND?: SettingWhereInput | SettingWhereInput[]
    OR?: SettingWhereInput[]
    NOT?: SettingWhereInput | SettingWhereInput[]
    key?: StringFilter<"Setting"> | string
    value?: JsonFilter<"Setting">
    updatedAt?: DateTimeFilter<"Setting"> | Date | string
  }

  export type SettingOrderByWithRelationInput = {
    key?: SortOrder
    value?: SortOrder
    updatedAt?: SortOrder
  }

  export type SettingWhereUniqueInput = Prisma.AtLeast<{
    key?: string
    AND?: SettingWhereInput | SettingWhereInput[]
    OR?: SettingWhereInput[]
    NOT?: SettingWhereInput | SettingWhereInput[]
    value?: JsonFilter<"Setting">
    updatedAt?: DateTimeFilter<"Setting"> | Date | string
  }, "key">

  export type SettingOrderByWithAggregationInput = {
    key?: SortOrder
    value?: SortOrder
    updatedAt?: SortOrder
    _count?: SettingCountOrderByAggregateInput
    _max?: SettingMaxOrderByAggregateInput
    _min?: SettingMinOrderByAggregateInput
  }

  export type SettingScalarWhereWithAggregatesInput = {
    AND?: SettingScalarWhereWithAggregatesInput | SettingScalarWhereWithAggregatesInput[]
    OR?: SettingScalarWhereWithAggregatesInput[]
    NOT?: SettingScalarWhereWithAggregatesInput | SettingScalarWhereWithAggregatesInput[]
    key?: StringWithAggregatesFilter<"Setting"> | string
    value?: JsonWithAggregatesFilter<"Setting">
    updatedAt?: DateTimeWithAggregatesFilter<"Setting"> | Date | string
  }

  export type PromotionWhereInput = {
    AND?: PromotionWhereInput | PromotionWhereInput[]
    OR?: PromotionWhereInput[]
    NOT?: PromotionWhereInput | PromotionWhereInput[]
    id?: StringFilter<"Promotion"> | string
    title?: StringFilter<"Promotion"> | string
    description?: StringNullableFilter<"Promotion"> | string | null
    scope?: EnumPromotionScopeFilter<"Promotion"> | $Enums.PromotionScope
    usage?: EnumPromotionUsageFilter<"Promotion"> | $Enums.PromotionUsage
    discountPercent?: DecimalFilter<"Promotion"> | Decimal | DecimalJsLike | number | string
    isActive?: BoolFilter<"Promotion"> | boolean
    platform?: IntFilter<"Promotion"> | number
    startsAt?: DateTimeNullableFilter<"Promotion"> | Date | string | null
    endsAt?: DateTimeNullableFilter<"Promotion"> | Date | string | null
    productId?: StringNullableFilter<"Promotion"> | string | null
    categoryId?: StringNullableFilter<"Promotion"> | string | null
    customerId?: StringNullableFilter<"Promotion"> | string | null
    brandId?: StringNullableFilter<"Promotion"> | string | null
    createdAt?: DateTimeFilter<"Promotion"> | Date | string
    updatedAt?: DateTimeFilter<"Promotion"> | Date | string
    product?: XOR<ProductNullableRelationFilter, ProductWhereInput> | null
    category?: XOR<CategoryNullableRelationFilter, CategoryWhereInput> | null
    customer?: XOR<CustomerNullableRelationFilter, CustomerWhereInput> | null
    brand?: XOR<BrandNullableRelationFilter, BrandWhereInput> | null
  }

  export type PromotionOrderByWithRelationInput = {
    id?: SortOrder
    title?: SortOrder
    description?: SortOrderInput | SortOrder
    scope?: SortOrder
    usage?: SortOrder
    discountPercent?: SortOrder
    isActive?: SortOrder
    platform?: SortOrder
    startsAt?: SortOrderInput | SortOrder
    endsAt?: SortOrderInput | SortOrder
    productId?: SortOrderInput | SortOrder
    categoryId?: SortOrderInput | SortOrder
    customerId?: SortOrderInput | SortOrder
    brandId?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    product?: ProductOrderByWithRelationInput
    category?: CategoryOrderByWithRelationInput
    customer?: CustomerOrderByWithRelationInput
    brand?: BrandOrderByWithRelationInput
  }

  export type PromotionWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: PromotionWhereInput | PromotionWhereInput[]
    OR?: PromotionWhereInput[]
    NOT?: PromotionWhereInput | PromotionWhereInput[]
    title?: StringFilter<"Promotion"> | string
    description?: StringNullableFilter<"Promotion"> | string | null
    scope?: EnumPromotionScopeFilter<"Promotion"> | $Enums.PromotionScope
    usage?: EnumPromotionUsageFilter<"Promotion"> | $Enums.PromotionUsage
    discountPercent?: DecimalFilter<"Promotion"> | Decimal | DecimalJsLike | number | string
    isActive?: BoolFilter<"Promotion"> | boolean
    platform?: IntFilter<"Promotion"> | number
    startsAt?: DateTimeNullableFilter<"Promotion"> | Date | string | null
    endsAt?: DateTimeNullableFilter<"Promotion"> | Date | string | null
    productId?: StringNullableFilter<"Promotion"> | string | null
    categoryId?: StringNullableFilter<"Promotion"> | string | null
    customerId?: StringNullableFilter<"Promotion"> | string | null
    brandId?: StringNullableFilter<"Promotion"> | string | null
    createdAt?: DateTimeFilter<"Promotion"> | Date | string
    updatedAt?: DateTimeFilter<"Promotion"> | Date | string
    product?: XOR<ProductNullableRelationFilter, ProductWhereInput> | null
    category?: XOR<CategoryNullableRelationFilter, CategoryWhereInput> | null
    customer?: XOR<CustomerNullableRelationFilter, CustomerWhereInput> | null
    brand?: XOR<BrandNullableRelationFilter, BrandWhereInput> | null
  }, "id">

  export type PromotionOrderByWithAggregationInput = {
    id?: SortOrder
    title?: SortOrder
    description?: SortOrderInput | SortOrder
    scope?: SortOrder
    usage?: SortOrder
    discountPercent?: SortOrder
    isActive?: SortOrder
    platform?: SortOrder
    startsAt?: SortOrderInput | SortOrder
    endsAt?: SortOrderInput | SortOrder
    productId?: SortOrderInput | SortOrder
    categoryId?: SortOrderInput | SortOrder
    customerId?: SortOrderInput | SortOrder
    brandId?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
    _count?: PromotionCountOrderByAggregateInput
    _avg?: PromotionAvgOrderByAggregateInput
    _max?: PromotionMaxOrderByAggregateInput
    _min?: PromotionMinOrderByAggregateInput
    _sum?: PromotionSumOrderByAggregateInput
  }

  export type PromotionScalarWhereWithAggregatesInput = {
    AND?: PromotionScalarWhereWithAggregatesInput | PromotionScalarWhereWithAggregatesInput[]
    OR?: PromotionScalarWhereWithAggregatesInput[]
    NOT?: PromotionScalarWhereWithAggregatesInput | PromotionScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Promotion"> | string
    title?: StringWithAggregatesFilter<"Promotion"> | string
    description?: StringNullableWithAggregatesFilter<"Promotion"> | string | null
    scope?: EnumPromotionScopeWithAggregatesFilter<"Promotion"> | $Enums.PromotionScope
    usage?: EnumPromotionUsageWithAggregatesFilter<"Promotion"> | $Enums.PromotionUsage
    discountPercent?: DecimalWithAggregatesFilter<"Promotion"> | Decimal | DecimalJsLike | number | string
    isActive?: BoolWithAggregatesFilter<"Promotion"> | boolean
    platform?: IntWithAggregatesFilter<"Promotion"> | number
    startsAt?: DateTimeNullableWithAggregatesFilter<"Promotion"> | Date | string | null
    endsAt?: DateTimeNullableWithAggregatesFilter<"Promotion"> | Date | string | null
    productId?: StringNullableWithAggregatesFilter<"Promotion"> | string | null
    categoryId?: StringNullableWithAggregatesFilter<"Promotion"> | string | null
    customerId?: StringNullableWithAggregatesFilter<"Promotion"> | string | null
    brandId?: StringNullableWithAggregatesFilter<"Promotion"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"Promotion"> | Date | string
    updatedAt?: DateTimeWithAggregatesFilter<"Promotion"> | Date | string
  }

  export type PromotionExclusionWhereInput = {
    AND?: PromotionExclusionWhereInput | PromotionExclusionWhereInput[]
    OR?: PromotionExclusionWhereInput[]
    NOT?: PromotionExclusionWhereInput | PromotionExclusionWhereInput[]
    id?: StringFilter<"PromotionExclusion"> | string
    type?: IntFilter<"PromotionExclusion"> | number
    itemId?: StringFilter<"PromotionExclusion"> | string
    createdAt?: DateTimeFilter<"PromotionExclusion"> | Date | string
  }

  export type PromotionExclusionOrderByWithRelationInput = {
    id?: SortOrder
    type?: SortOrder
    itemId?: SortOrder
    createdAt?: SortOrder
  }

  export type PromotionExclusionWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    type_itemId?: PromotionExclusionTypeItemIdCompoundUniqueInput
    AND?: PromotionExclusionWhereInput | PromotionExclusionWhereInput[]
    OR?: PromotionExclusionWhereInput[]
    NOT?: PromotionExclusionWhereInput | PromotionExclusionWhereInput[]
    type?: IntFilter<"PromotionExclusion"> | number
    itemId?: StringFilter<"PromotionExclusion"> | string
    createdAt?: DateTimeFilter<"PromotionExclusion"> | Date | string
  }, "id" | "type_itemId">

  export type PromotionExclusionOrderByWithAggregationInput = {
    id?: SortOrder
    type?: SortOrder
    itemId?: SortOrder
    createdAt?: SortOrder
    _count?: PromotionExclusionCountOrderByAggregateInput
    _avg?: PromotionExclusionAvgOrderByAggregateInput
    _max?: PromotionExclusionMaxOrderByAggregateInput
    _min?: PromotionExclusionMinOrderByAggregateInput
    _sum?: PromotionExclusionSumOrderByAggregateInput
  }

  export type PromotionExclusionScalarWhereWithAggregatesInput = {
    AND?: PromotionExclusionScalarWhereWithAggregatesInput | PromotionExclusionScalarWhereWithAggregatesInput[]
    OR?: PromotionExclusionScalarWhereWithAggregatesInput[]
    NOT?: PromotionExclusionScalarWhereWithAggregatesInput | PromotionExclusionScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"PromotionExclusion"> | string
    type?: IntWithAggregatesFilter<"PromotionExclusion"> | number
    itemId?: StringWithAggregatesFilter<"PromotionExclusion"> | string
    createdAt?: DateTimeWithAggregatesFilter<"PromotionExclusion"> | Date | string
  }

  export type BranchAllocationWhereInput = {
    AND?: BranchAllocationWhereInput | BranchAllocationWhereInput[]
    OR?: BranchAllocationWhereInput[]
    NOT?: BranchAllocationWhereInput | BranchAllocationWhereInput[]
    id?: StringFilter<"BranchAllocation"> | string
    branchId?: StringFilter<"BranchAllocation"> | string
    allocatorAdminUserId?: StringNullableFilter<"BranchAllocation"> | string | null
    note?: StringNullableFilter<"BranchAllocation"> | string | null
    createdAt?: DateTimeFilter<"BranchAllocation"> | Date | string
    branch?: XOR<BranchRelationFilter, BranchWhereInput>
    allocatorAdminUser?: XOR<AdminUserNullableRelationFilter, AdminUserWhereInput> | null
    items?: BranchAllocationItemListRelationFilter
  }

  export type BranchAllocationOrderByWithRelationInput = {
    id?: SortOrder
    branchId?: SortOrder
    allocatorAdminUserId?: SortOrderInput | SortOrder
    note?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    branch?: BranchOrderByWithRelationInput
    allocatorAdminUser?: AdminUserOrderByWithRelationInput
    items?: BranchAllocationItemOrderByRelationAggregateInput
  }

  export type BranchAllocationWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: BranchAllocationWhereInput | BranchAllocationWhereInput[]
    OR?: BranchAllocationWhereInput[]
    NOT?: BranchAllocationWhereInput | BranchAllocationWhereInput[]
    branchId?: StringFilter<"BranchAllocation"> | string
    allocatorAdminUserId?: StringNullableFilter<"BranchAllocation"> | string | null
    note?: StringNullableFilter<"BranchAllocation"> | string | null
    createdAt?: DateTimeFilter<"BranchAllocation"> | Date | string
    branch?: XOR<BranchRelationFilter, BranchWhereInput>
    allocatorAdminUser?: XOR<AdminUserNullableRelationFilter, AdminUserWhereInput> | null
    items?: BranchAllocationItemListRelationFilter
  }, "id">

  export type BranchAllocationOrderByWithAggregationInput = {
    id?: SortOrder
    branchId?: SortOrder
    allocatorAdminUserId?: SortOrderInput | SortOrder
    note?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    _count?: BranchAllocationCountOrderByAggregateInput
    _max?: BranchAllocationMaxOrderByAggregateInput
    _min?: BranchAllocationMinOrderByAggregateInput
  }

  export type BranchAllocationScalarWhereWithAggregatesInput = {
    AND?: BranchAllocationScalarWhereWithAggregatesInput | BranchAllocationScalarWhereWithAggregatesInput[]
    OR?: BranchAllocationScalarWhereWithAggregatesInput[]
    NOT?: BranchAllocationScalarWhereWithAggregatesInput | BranchAllocationScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"BranchAllocation"> | string
    branchId?: StringWithAggregatesFilter<"BranchAllocation"> | string
    allocatorAdminUserId?: StringNullableWithAggregatesFilter<"BranchAllocation"> | string | null
    note?: StringNullableWithAggregatesFilter<"BranchAllocation"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"BranchAllocation"> | Date | string
  }

  export type BranchAllocationItemWhereInput = {
    AND?: BranchAllocationItemWhereInput | BranchAllocationItemWhereInput[]
    OR?: BranchAllocationItemWhereInput[]
    NOT?: BranchAllocationItemWhereInput | BranchAllocationItemWhereInput[]
    id?: StringFilter<"BranchAllocationItem"> | string
    allocationId?: StringFilter<"BranchAllocationItem"> | string
    productId?: StringFilter<"BranchAllocationItem"> | string
    weightGrams?: DecimalNullableFilter<"BranchAllocationItem"> | Decimal | DecimalJsLike | number | string | null
    allocation?: XOR<BranchAllocationRelationFilter, BranchAllocationWhereInput>
    product?: XOR<ProductRelationFilter, ProductWhereInput>
  }

  export type BranchAllocationItemOrderByWithRelationInput = {
    id?: SortOrder
    allocationId?: SortOrder
    productId?: SortOrder
    weightGrams?: SortOrderInput | SortOrder
    allocation?: BranchAllocationOrderByWithRelationInput
    product?: ProductOrderByWithRelationInput
  }

  export type BranchAllocationItemWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    allocationId_productId?: BranchAllocationItemAllocationIdProductIdCompoundUniqueInput
    AND?: BranchAllocationItemWhereInput | BranchAllocationItemWhereInput[]
    OR?: BranchAllocationItemWhereInput[]
    NOT?: BranchAllocationItemWhereInput | BranchAllocationItemWhereInput[]
    allocationId?: StringFilter<"BranchAllocationItem"> | string
    productId?: StringFilter<"BranchAllocationItem"> | string
    weightGrams?: DecimalNullableFilter<"BranchAllocationItem"> | Decimal | DecimalJsLike | number | string | null
    allocation?: XOR<BranchAllocationRelationFilter, BranchAllocationWhereInput>
    product?: XOR<ProductRelationFilter, ProductWhereInput>
  }, "id" | "allocationId_productId">

  export type BranchAllocationItemOrderByWithAggregationInput = {
    id?: SortOrder
    allocationId?: SortOrder
    productId?: SortOrder
    weightGrams?: SortOrderInput | SortOrder
    _count?: BranchAllocationItemCountOrderByAggregateInput
    _avg?: BranchAllocationItemAvgOrderByAggregateInput
    _max?: BranchAllocationItemMaxOrderByAggregateInput
    _min?: BranchAllocationItemMinOrderByAggregateInput
    _sum?: BranchAllocationItemSumOrderByAggregateInput
  }

  export type BranchAllocationItemScalarWhereWithAggregatesInput = {
    AND?: BranchAllocationItemScalarWhereWithAggregatesInput | BranchAllocationItemScalarWhereWithAggregatesInput[]
    OR?: BranchAllocationItemScalarWhereWithAggregatesInput[]
    NOT?: BranchAllocationItemScalarWhereWithAggregatesInput | BranchAllocationItemScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"BranchAllocationItem"> | string
    allocationId?: StringWithAggregatesFilter<"BranchAllocationItem"> | string
    productId?: StringWithAggregatesFilter<"BranchAllocationItem"> | string
    weightGrams?: DecimalNullableWithAggregatesFilter<"BranchAllocationItem"> | Decimal | DecimalJsLike | number | string | null
  }

  export type SmsMessageWhereInput = {
    AND?: SmsMessageWhereInput | SmsMessageWhereInput[]
    OR?: SmsMessageWhereInput[]
    NOT?: SmsMessageWhereInput | SmsMessageWhereInput[]
    id?: StringFilter<"SmsMessage"> | string
    audience?: EnumMessageAudienceFilter<"SmsMessage"> | $Enums.MessageAudience
    recipients?: StringNullableFilter<"SmsMessage"> | string | null
    body?: StringFilter<"SmsMessage"> | string
    sentCount?: IntFilter<"SmsMessage"> | number
    sentByAdminUserId?: StringNullableFilter<"SmsMessage"> | string | null
    createdAt?: DateTimeFilter<"SmsMessage"> | Date | string
    sentByAdminUser?: XOR<AdminUserNullableRelationFilter, AdminUserWhereInput> | null
  }

  export type SmsMessageOrderByWithRelationInput = {
    id?: SortOrder
    audience?: SortOrder
    recipients?: SortOrderInput | SortOrder
    body?: SortOrder
    sentCount?: SortOrder
    sentByAdminUserId?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    sentByAdminUser?: AdminUserOrderByWithRelationInput
  }

  export type SmsMessageWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: SmsMessageWhereInput | SmsMessageWhereInput[]
    OR?: SmsMessageWhereInput[]
    NOT?: SmsMessageWhereInput | SmsMessageWhereInput[]
    audience?: EnumMessageAudienceFilter<"SmsMessage"> | $Enums.MessageAudience
    recipients?: StringNullableFilter<"SmsMessage"> | string | null
    body?: StringFilter<"SmsMessage"> | string
    sentCount?: IntFilter<"SmsMessage"> | number
    sentByAdminUserId?: StringNullableFilter<"SmsMessage"> | string | null
    createdAt?: DateTimeFilter<"SmsMessage"> | Date | string
    sentByAdminUser?: XOR<AdminUserNullableRelationFilter, AdminUserWhereInput> | null
  }, "id">

  export type SmsMessageOrderByWithAggregationInput = {
    id?: SortOrder
    audience?: SortOrder
    recipients?: SortOrderInput | SortOrder
    body?: SortOrder
    sentCount?: SortOrder
    sentByAdminUserId?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    _count?: SmsMessageCountOrderByAggregateInput
    _avg?: SmsMessageAvgOrderByAggregateInput
    _max?: SmsMessageMaxOrderByAggregateInput
    _min?: SmsMessageMinOrderByAggregateInput
    _sum?: SmsMessageSumOrderByAggregateInput
  }

  export type SmsMessageScalarWhereWithAggregatesInput = {
    AND?: SmsMessageScalarWhereWithAggregatesInput | SmsMessageScalarWhereWithAggregatesInput[]
    OR?: SmsMessageScalarWhereWithAggregatesInput[]
    NOT?: SmsMessageScalarWhereWithAggregatesInput | SmsMessageScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"SmsMessage"> | string
    audience?: EnumMessageAudienceWithAggregatesFilter<"SmsMessage"> | $Enums.MessageAudience
    recipients?: StringNullableWithAggregatesFilter<"SmsMessage"> | string | null
    body?: StringWithAggregatesFilter<"SmsMessage"> | string
    sentCount?: IntWithAggregatesFilter<"SmsMessage"> | number
    sentByAdminUserId?: StringNullableWithAggregatesFilter<"SmsMessage"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"SmsMessage"> | Date | string
  }

  export type NotificationWhereInput = {
    AND?: NotificationWhereInput | NotificationWhereInput[]
    OR?: NotificationWhereInput[]
    NOT?: NotificationWhereInput | NotificationWhereInput[]
    id?: StringFilter<"Notification"> | string
    title?: StringFilter<"Notification"> | string
    body?: StringFilter<"Notification"> | string
    audience?: EnumMessageAudienceFilter<"Notification"> | $Enums.MessageAudience
    sentByAdminUserId?: StringNullableFilter<"Notification"> | string | null
    createdAt?: DateTimeFilter<"Notification"> | Date | string
    sentByAdminUser?: XOR<AdminUserNullableRelationFilter, AdminUserWhereInput> | null
    recipients?: NotificationRecipientListRelationFilter
  }

  export type NotificationOrderByWithRelationInput = {
    id?: SortOrder
    title?: SortOrder
    body?: SortOrder
    audience?: SortOrder
    sentByAdminUserId?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    sentByAdminUser?: AdminUserOrderByWithRelationInput
    recipients?: NotificationRecipientOrderByRelationAggregateInput
  }

  export type NotificationWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: NotificationWhereInput | NotificationWhereInput[]
    OR?: NotificationWhereInput[]
    NOT?: NotificationWhereInput | NotificationWhereInput[]
    title?: StringFilter<"Notification"> | string
    body?: StringFilter<"Notification"> | string
    audience?: EnumMessageAudienceFilter<"Notification"> | $Enums.MessageAudience
    sentByAdminUserId?: StringNullableFilter<"Notification"> | string | null
    createdAt?: DateTimeFilter<"Notification"> | Date | string
    sentByAdminUser?: XOR<AdminUserNullableRelationFilter, AdminUserWhereInput> | null
    recipients?: NotificationRecipientListRelationFilter
  }, "id">

  export type NotificationOrderByWithAggregationInput = {
    id?: SortOrder
    title?: SortOrder
    body?: SortOrder
    audience?: SortOrder
    sentByAdminUserId?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    _count?: NotificationCountOrderByAggregateInput
    _max?: NotificationMaxOrderByAggregateInput
    _min?: NotificationMinOrderByAggregateInput
  }

  export type NotificationScalarWhereWithAggregatesInput = {
    AND?: NotificationScalarWhereWithAggregatesInput | NotificationScalarWhereWithAggregatesInput[]
    OR?: NotificationScalarWhereWithAggregatesInput[]
    NOT?: NotificationScalarWhereWithAggregatesInput | NotificationScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"Notification"> | string
    title?: StringWithAggregatesFilter<"Notification"> | string
    body?: StringWithAggregatesFilter<"Notification"> | string
    audience?: EnumMessageAudienceWithAggregatesFilter<"Notification"> | $Enums.MessageAudience
    sentByAdminUserId?: StringNullableWithAggregatesFilter<"Notification"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"Notification"> | Date | string
  }

  export type NotificationRecipientWhereInput = {
    AND?: NotificationRecipientWhereInput | NotificationRecipientWhereInput[]
    OR?: NotificationRecipientWhereInput[]
    NOT?: NotificationRecipientWhereInput | NotificationRecipientWhereInput[]
    id?: StringFilter<"NotificationRecipient"> | string
    notificationId?: StringFilter<"NotificationRecipient"> | string
    customerId?: StringFilter<"NotificationRecipient"> | string
    readAt?: DateTimeNullableFilter<"NotificationRecipient"> | Date | string | null
    notification?: XOR<NotificationRelationFilter, NotificationWhereInput>
    customer?: XOR<CustomerRelationFilter, CustomerWhereInput>
  }

  export type NotificationRecipientOrderByWithRelationInput = {
    id?: SortOrder
    notificationId?: SortOrder
    customerId?: SortOrder
    readAt?: SortOrderInput | SortOrder
    notification?: NotificationOrderByWithRelationInput
    customer?: CustomerOrderByWithRelationInput
  }

  export type NotificationRecipientWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    notificationId_customerId?: NotificationRecipientNotificationIdCustomerIdCompoundUniqueInput
    AND?: NotificationRecipientWhereInput | NotificationRecipientWhereInput[]
    OR?: NotificationRecipientWhereInput[]
    NOT?: NotificationRecipientWhereInput | NotificationRecipientWhereInput[]
    notificationId?: StringFilter<"NotificationRecipient"> | string
    customerId?: StringFilter<"NotificationRecipient"> | string
    readAt?: DateTimeNullableFilter<"NotificationRecipient"> | Date | string | null
    notification?: XOR<NotificationRelationFilter, NotificationWhereInput>
    customer?: XOR<CustomerRelationFilter, CustomerWhereInput>
  }, "id" | "notificationId_customerId">

  export type NotificationRecipientOrderByWithAggregationInput = {
    id?: SortOrder
    notificationId?: SortOrder
    customerId?: SortOrder
    readAt?: SortOrderInput | SortOrder
    _count?: NotificationRecipientCountOrderByAggregateInput
    _max?: NotificationRecipientMaxOrderByAggregateInput
    _min?: NotificationRecipientMinOrderByAggregateInput
  }

  export type NotificationRecipientScalarWhereWithAggregatesInput = {
    AND?: NotificationRecipientScalarWhereWithAggregatesInput | NotificationRecipientScalarWhereWithAggregatesInput[]
    OR?: NotificationRecipientScalarWhereWithAggregatesInput[]
    NOT?: NotificationRecipientScalarWhereWithAggregatesInput | NotificationRecipientScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"NotificationRecipient"> | string
    notificationId?: StringWithAggregatesFilter<"NotificationRecipient"> | string
    customerId?: StringWithAggregatesFilter<"NotificationRecipient"> | string
    readAt?: DateTimeNullableWithAggregatesFilter<"NotificationRecipient"> | Date | string | null
  }

  export type NewsletterSubscriberWhereInput = {
    AND?: NewsletterSubscriberWhereInput | NewsletterSubscriberWhereInput[]
    OR?: NewsletterSubscriberWhereInput[]
    NOT?: NewsletterSubscriberWhereInput | NewsletterSubscriberWhereInput[]
    id?: StringFilter<"NewsletterSubscriber"> | string
    email?: StringNullableFilter<"NewsletterSubscriber"> | string | null
    mobile?: StringNullableFilter<"NewsletterSubscriber"> | string | null
    createdAt?: DateTimeFilter<"NewsletterSubscriber"> | Date | string
  }

  export type NewsletterSubscriberOrderByWithRelationInput = {
    id?: SortOrder
    email?: SortOrderInput | SortOrder
    mobile?: SortOrderInput | SortOrder
    createdAt?: SortOrder
  }

  export type NewsletterSubscriberWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    email?: string
    mobile?: string
    AND?: NewsletterSubscriberWhereInput | NewsletterSubscriberWhereInput[]
    OR?: NewsletterSubscriberWhereInput[]
    NOT?: NewsletterSubscriberWhereInput | NewsletterSubscriberWhereInput[]
    createdAt?: DateTimeFilter<"NewsletterSubscriber"> | Date | string
  }, "id" | "email" | "mobile">

  export type NewsletterSubscriberOrderByWithAggregationInput = {
    id?: SortOrder
    email?: SortOrderInput | SortOrder
    mobile?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    _count?: NewsletterSubscriberCountOrderByAggregateInput
    _max?: NewsletterSubscriberMaxOrderByAggregateInput
    _min?: NewsletterSubscriberMinOrderByAggregateInput
  }

  export type NewsletterSubscriberScalarWhereWithAggregatesInput = {
    AND?: NewsletterSubscriberScalarWhereWithAggregatesInput | NewsletterSubscriberScalarWhereWithAggregatesInput[]
    OR?: NewsletterSubscriberScalarWhereWithAggregatesInput[]
    NOT?: NewsletterSubscriberScalarWhereWithAggregatesInput | NewsletterSubscriberScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"NewsletterSubscriber"> | string
    email?: StringNullableWithAggregatesFilter<"NewsletterSubscriber"> | string | null
    mobile?: StringNullableWithAggregatesFilter<"NewsletterSubscriber"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"NewsletterSubscriber"> | Date | string
  }

  export type CustomerActivityLogWhereInput = {
    AND?: CustomerActivityLogWhereInput | CustomerActivityLogWhereInput[]
    OR?: CustomerActivityLogWhereInput[]
    NOT?: CustomerActivityLogWhereInput | CustomerActivityLogWhereInput[]
    id?: StringFilter<"CustomerActivityLog"> | string
    customerId?: StringFilter<"CustomerActivityLog"> | string
    action?: StringFilter<"CustomerActivityLog"> | string
    detail?: StringNullableFilter<"CustomerActivityLog"> | string | null
    createdAt?: DateTimeFilter<"CustomerActivityLog"> | Date | string
    customer?: XOR<CustomerRelationFilter, CustomerWhereInput>
  }

  export type CustomerActivityLogOrderByWithRelationInput = {
    id?: SortOrder
    customerId?: SortOrder
    action?: SortOrder
    detail?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    customer?: CustomerOrderByWithRelationInput
  }

  export type CustomerActivityLogWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: CustomerActivityLogWhereInput | CustomerActivityLogWhereInput[]
    OR?: CustomerActivityLogWhereInput[]
    NOT?: CustomerActivityLogWhereInput | CustomerActivityLogWhereInput[]
    customerId?: StringFilter<"CustomerActivityLog"> | string
    action?: StringFilter<"CustomerActivityLog"> | string
    detail?: StringNullableFilter<"CustomerActivityLog"> | string | null
    createdAt?: DateTimeFilter<"CustomerActivityLog"> | Date | string
    customer?: XOR<CustomerRelationFilter, CustomerWhereInput>
  }, "id">

  export type CustomerActivityLogOrderByWithAggregationInput = {
    id?: SortOrder
    customerId?: SortOrder
    action?: SortOrder
    detail?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    _count?: CustomerActivityLogCountOrderByAggregateInput
    _max?: CustomerActivityLogMaxOrderByAggregateInput
    _min?: CustomerActivityLogMinOrderByAggregateInput
  }

  export type CustomerActivityLogScalarWhereWithAggregatesInput = {
    AND?: CustomerActivityLogScalarWhereWithAggregatesInput | CustomerActivityLogScalarWhereWithAggregatesInput[]
    OR?: CustomerActivityLogScalarWhereWithAggregatesInput[]
    NOT?: CustomerActivityLogScalarWhereWithAggregatesInput | CustomerActivityLogScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"CustomerActivityLog"> | string
    customerId?: StringWithAggregatesFilter<"CustomerActivityLog"> | string
    action?: StringWithAggregatesFilter<"CustomerActivityLog"> | string
    detail?: StringNullableWithAggregatesFilter<"CustomerActivityLog"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"CustomerActivityLog"> | Date | string
  }

  export type UploadedFileWhereInput = {
    AND?: UploadedFileWhereInput | UploadedFileWhereInput[]
    OR?: UploadedFileWhereInput[]
    NOT?: UploadedFileWhereInput | UploadedFileWhereInput[]
    id?: StringFilter<"UploadedFile"> | string
    url?: StringFilter<"UploadedFile"> | string
    originalName?: StringFilter<"UploadedFile"> | string
    mimeType?: StringFilter<"UploadedFile"> | string
    sizeBytes?: IntFilter<"UploadedFile"> | number
    purpose?: StringNullableFilter<"UploadedFile"> | string | null
    uploadedByAdminUserId?: StringNullableFilter<"UploadedFile"> | string | null
    createdAt?: DateTimeFilter<"UploadedFile"> | Date | string
    uploadedByAdminUser?: XOR<AdminUserNullableRelationFilter, AdminUserWhereInput> | null
    customerAvatars?: CustomerListRelationFilter
    adminUserAvatars?: AdminUserListRelationFilter
  }

  export type UploadedFileOrderByWithRelationInput = {
    id?: SortOrder
    url?: SortOrder
    originalName?: SortOrder
    mimeType?: SortOrder
    sizeBytes?: SortOrder
    purpose?: SortOrderInput | SortOrder
    uploadedByAdminUserId?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    uploadedByAdminUser?: AdminUserOrderByWithRelationInput
    customerAvatars?: CustomerOrderByRelationAggregateInput
    adminUserAvatars?: AdminUserOrderByRelationAggregateInput
  }

  export type UploadedFileWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: UploadedFileWhereInput | UploadedFileWhereInput[]
    OR?: UploadedFileWhereInput[]
    NOT?: UploadedFileWhereInput | UploadedFileWhereInput[]
    url?: StringFilter<"UploadedFile"> | string
    originalName?: StringFilter<"UploadedFile"> | string
    mimeType?: StringFilter<"UploadedFile"> | string
    sizeBytes?: IntFilter<"UploadedFile"> | number
    purpose?: StringNullableFilter<"UploadedFile"> | string | null
    uploadedByAdminUserId?: StringNullableFilter<"UploadedFile"> | string | null
    createdAt?: DateTimeFilter<"UploadedFile"> | Date | string
    uploadedByAdminUser?: XOR<AdminUserNullableRelationFilter, AdminUserWhereInput> | null
    customerAvatars?: CustomerListRelationFilter
    adminUserAvatars?: AdminUserListRelationFilter
  }, "id">

  export type UploadedFileOrderByWithAggregationInput = {
    id?: SortOrder
    url?: SortOrder
    originalName?: SortOrder
    mimeType?: SortOrder
    sizeBytes?: SortOrder
    purpose?: SortOrderInput | SortOrder
    uploadedByAdminUserId?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    _count?: UploadedFileCountOrderByAggregateInput
    _avg?: UploadedFileAvgOrderByAggregateInput
    _max?: UploadedFileMaxOrderByAggregateInput
    _min?: UploadedFileMinOrderByAggregateInput
    _sum?: UploadedFileSumOrderByAggregateInput
  }

  export type UploadedFileScalarWhereWithAggregatesInput = {
    AND?: UploadedFileScalarWhereWithAggregatesInput | UploadedFileScalarWhereWithAggregatesInput[]
    OR?: UploadedFileScalarWhereWithAggregatesInput[]
    NOT?: UploadedFileScalarWhereWithAggregatesInput | UploadedFileScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"UploadedFile"> | string
    url?: StringWithAggregatesFilter<"UploadedFile"> | string
    originalName?: StringWithAggregatesFilter<"UploadedFile"> | string
    mimeType?: StringWithAggregatesFilter<"UploadedFile"> | string
    sizeBytes?: IntWithAggregatesFilter<"UploadedFile"> | number
    purpose?: StringNullableWithAggregatesFilter<"UploadedFile"> | string | null
    uploadedByAdminUserId?: StringNullableWithAggregatesFilter<"UploadedFile"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"UploadedFile"> | Date | string
  }

  export type CustomerOtpWhereInput = {
    AND?: CustomerOtpWhereInput | CustomerOtpWhereInput[]
    OR?: CustomerOtpWhereInput[]
    NOT?: CustomerOtpWhereInput | CustomerOtpWhereInput[]
    id?: StringFilter<"CustomerOtp"> | string
    mobile?: StringFilter<"CustomerOtp"> | string
    customerId?: StringFilter<"CustomerOtp"> | string
    codeHash?: StringFilter<"CustomerOtp"> | string
    expiresAt?: DateTimeFilter<"CustomerOtp"> | Date | string
    attempts?: IntFilter<"CustomerOtp"> | number
    consumedAt?: DateTimeNullableFilter<"CustomerOtp"> | Date | string | null
    requestIp?: StringNullableFilter<"CustomerOtp"> | string | null
    createdAt?: DateTimeFilter<"CustomerOtp"> | Date | string
    customer?: XOR<CustomerRelationFilter, CustomerWhereInput>
  }

  export type CustomerOtpOrderByWithRelationInput = {
    id?: SortOrder
    mobile?: SortOrder
    customerId?: SortOrder
    codeHash?: SortOrder
    expiresAt?: SortOrder
    attempts?: SortOrder
    consumedAt?: SortOrderInput | SortOrder
    requestIp?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    customer?: CustomerOrderByWithRelationInput
  }

  export type CustomerOtpWhereUniqueInput = Prisma.AtLeast<{
    id?: string
    AND?: CustomerOtpWhereInput | CustomerOtpWhereInput[]
    OR?: CustomerOtpWhereInput[]
    NOT?: CustomerOtpWhereInput | CustomerOtpWhereInput[]
    mobile?: StringFilter<"CustomerOtp"> | string
    customerId?: StringFilter<"CustomerOtp"> | string
    codeHash?: StringFilter<"CustomerOtp"> | string
    expiresAt?: DateTimeFilter<"CustomerOtp"> | Date | string
    attempts?: IntFilter<"CustomerOtp"> | number
    consumedAt?: DateTimeNullableFilter<"CustomerOtp"> | Date | string | null
    requestIp?: StringNullableFilter<"CustomerOtp"> | string | null
    createdAt?: DateTimeFilter<"CustomerOtp"> | Date | string
    customer?: XOR<CustomerRelationFilter, CustomerWhereInput>
  }, "id">

  export type CustomerOtpOrderByWithAggregationInput = {
    id?: SortOrder
    mobile?: SortOrder
    customerId?: SortOrder
    codeHash?: SortOrder
    expiresAt?: SortOrder
    attempts?: SortOrder
    consumedAt?: SortOrderInput | SortOrder
    requestIp?: SortOrderInput | SortOrder
    createdAt?: SortOrder
    _count?: CustomerOtpCountOrderByAggregateInput
    _avg?: CustomerOtpAvgOrderByAggregateInput
    _max?: CustomerOtpMaxOrderByAggregateInput
    _min?: CustomerOtpMinOrderByAggregateInput
    _sum?: CustomerOtpSumOrderByAggregateInput
  }

  export type CustomerOtpScalarWhereWithAggregatesInput = {
    AND?: CustomerOtpScalarWhereWithAggregatesInput | CustomerOtpScalarWhereWithAggregatesInput[]
    OR?: CustomerOtpScalarWhereWithAggregatesInput[]
    NOT?: CustomerOtpScalarWhereWithAggregatesInput | CustomerOtpScalarWhereWithAggregatesInput[]
    id?: StringWithAggregatesFilter<"CustomerOtp"> | string
    mobile?: StringWithAggregatesFilter<"CustomerOtp"> | string
    customerId?: StringWithAggregatesFilter<"CustomerOtp"> | string
    codeHash?: StringWithAggregatesFilter<"CustomerOtp"> | string
    expiresAt?: DateTimeWithAggregatesFilter<"CustomerOtp"> | Date | string
    attempts?: IntWithAggregatesFilter<"CustomerOtp"> | number
    consumedAt?: DateTimeNullableWithAggregatesFilter<"CustomerOtp"> | Date | string | null
    requestIp?: StringNullableWithAggregatesFilter<"CustomerOtp"> | string | null
    createdAt?: DateTimeWithAggregatesFilter<"CustomerOtp"> | Date | string
  }

  export type CityCreateInput = {
    id?: string
    name: string
    province?: string | null
    percent?: Decimal | DecimalJsLike | number | string | null
    percentAux?: Decimal | DecimalJsLike | number | string | null
    customers?: CustomerCreateNestedManyWithoutCityInput
    addresses?: CustomerAddressCreateNestedManyWithoutCityInput
    branches?: BranchCreateNestedManyWithoutCityInput
    preOrders?: PreOrderCreateNestedManyWithoutCityInput
    salesExpertProfiles?: SalesExpertProfileCreateNestedManyWithoutCityInput
  }

  export type CityUncheckedCreateInput = {
    id?: string
    name: string
    province?: string | null
    percent?: Decimal | DecimalJsLike | number | string | null
    percentAux?: Decimal | DecimalJsLike | number | string | null
    customers?: CustomerUncheckedCreateNestedManyWithoutCityInput
    addresses?: CustomerAddressUncheckedCreateNestedManyWithoutCityInput
    branches?: BranchUncheckedCreateNestedManyWithoutCityInput
    preOrders?: PreOrderUncheckedCreateNestedManyWithoutCityInput
    salesExpertProfiles?: SalesExpertProfileUncheckedCreateNestedManyWithoutCityInput
  }

  export type CityUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    province?: NullableStringFieldUpdateOperationsInput | string | null
    percent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    percentAux?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    customers?: CustomerUpdateManyWithoutCityNestedInput
    addresses?: CustomerAddressUpdateManyWithoutCityNestedInput
    branches?: BranchUpdateManyWithoutCityNestedInput
    preOrders?: PreOrderUpdateManyWithoutCityNestedInput
    salesExpertProfiles?: SalesExpertProfileUpdateManyWithoutCityNestedInput
  }

  export type CityUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    province?: NullableStringFieldUpdateOperationsInput | string | null
    percent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    percentAux?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    customers?: CustomerUncheckedUpdateManyWithoutCityNestedInput
    addresses?: CustomerAddressUncheckedUpdateManyWithoutCityNestedInput
    branches?: BranchUncheckedUpdateManyWithoutCityNestedInput
    preOrders?: PreOrderUncheckedUpdateManyWithoutCityNestedInput
    salesExpertProfiles?: SalesExpertProfileUncheckedUpdateManyWithoutCityNestedInput
  }

  export type CityCreateManyInput = {
    id?: string
    name: string
    province?: string | null
    percent?: Decimal | DecimalJsLike | number | string | null
    percentAux?: Decimal | DecimalJsLike | number | string | null
  }

  export type CityUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    province?: NullableStringFieldUpdateOperationsInput | string | null
    percent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    percentAux?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
  }

  export type CityUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    province?: NullableStringFieldUpdateOperationsInput | string | null
    percent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    percentAux?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
  }

  export type AdminUserCreateInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    userType?: UserTypeCreateNestedOneWithoutAdminUsersInput
    branch?: BranchCreateNestedOneWithoutAdminUsersInput
    avatarFile?: UploadedFileCreateNestedOneWithoutAdminUserAvatarsInput
    referredCustomers?: CustomerCreateNestedManyWithoutReferredByAgentInput
    supervisedWorkshops?: WorkshopCreateNestedManyWithoutSupervisorInput
    branchAllocations?: BranchAllocationCreateNestedManyWithoutAllocatorAdminUserInput
    postedLedgerEntries?: LedgerEntryCreateNestedManyWithoutPostedByAdminUserInput
    orderStatusEvents?: OrderStatusEventCreateNestedManyWithoutActorAdminUserInput
    preOrderStatusEvents?: PreOrderStatusEventCreateNestedManyWithoutActorAdminUserInput
    sentSmsMessages?: SmsMessageCreateNestedManyWithoutSentByAdminUserInput
    sentNotifications?: NotificationCreateNestedManyWithoutSentByAdminUserInput
    uploadedFiles?: UploadedFileCreateNestedManyWithoutUploadedByAdminUserInput
    salesExpertProfile?: SalesExpertProfileCreateNestedOneWithoutAdminUserInput
    sessions?: AdminSessionCreateNestedManyWithoutAdminUserInput
  }

  export type AdminUserUncheckedCreateInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    userTypeId?: number | null
    branchId?: string | null
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    avatarFileId?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    referredCustomers?: CustomerUncheckedCreateNestedManyWithoutReferredByAgentInput
    supervisedWorkshops?: WorkshopUncheckedCreateNestedManyWithoutSupervisorInput
    branchAllocations?: BranchAllocationUncheckedCreateNestedManyWithoutAllocatorAdminUserInput
    postedLedgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutPostedByAdminUserInput
    orderStatusEvents?: OrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput
    preOrderStatusEvents?: PreOrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput
    sentSmsMessages?: SmsMessageUncheckedCreateNestedManyWithoutSentByAdminUserInput
    sentNotifications?: NotificationUncheckedCreateNestedManyWithoutSentByAdminUserInput
    uploadedFiles?: UploadedFileUncheckedCreateNestedManyWithoutUploadedByAdminUserInput
    salesExpertProfile?: SalesExpertProfileUncheckedCreateNestedOneWithoutAdminUserInput
    sessions?: AdminSessionUncheckedCreateNestedManyWithoutAdminUserInput
  }

  export type AdminUserUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    userType?: UserTypeUpdateOneWithoutAdminUsersNestedInput
    branch?: BranchUpdateOneWithoutAdminUsersNestedInput
    avatarFile?: UploadedFileUpdateOneWithoutAdminUserAvatarsNestedInput
    referredCustomers?: CustomerUpdateManyWithoutReferredByAgentNestedInput
    supervisedWorkshops?: WorkshopUpdateManyWithoutSupervisorNestedInput
    branchAllocations?: BranchAllocationUpdateManyWithoutAllocatorAdminUserNestedInput
    postedLedgerEntries?: LedgerEntryUpdateManyWithoutPostedByAdminUserNestedInput
    orderStatusEvents?: OrderStatusEventUpdateManyWithoutActorAdminUserNestedInput
    preOrderStatusEvents?: PreOrderStatusEventUpdateManyWithoutActorAdminUserNestedInput
    sentSmsMessages?: SmsMessageUpdateManyWithoutSentByAdminUserNestedInput
    sentNotifications?: NotificationUpdateManyWithoutSentByAdminUserNestedInput
    uploadedFiles?: UploadedFileUpdateManyWithoutUploadedByAdminUserNestedInput
    salesExpertProfile?: SalesExpertProfileUpdateOneWithoutAdminUserNestedInput
    sessions?: AdminSessionUpdateManyWithoutAdminUserNestedInput
  }

  export type AdminUserUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    userTypeId?: NullableIntFieldUpdateOperationsInput | number | null
    branchId?: NullableStringFieldUpdateOperationsInput | string | null
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredCustomers?: CustomerUncheckedUpdateManyWithoutReferredByAgentNestedInput
    supervisedWorkshops?: WorkshopUncheckedUpdateManyWithoutSupervisorNestedInput
    branchAllocations?: BranchAllocationUncheckedUpdateManyWithoutAllocatorAdminUserNestedInput
    postedLedgerEntries?: LedgerEntryUncheckedUpdateManyWithoutPostedByAdminUserNestedInput
    orderStatusEvents?: OrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput
    preOrderStatusEvents?: PreOrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput
    sentSmsMessages?: SmsMessageUncheckedUpdateManyWithoutSentByAdminUserNestedInput
    sentNotifications?: NotificationUncheckedUpdateManyWithoutSentByAdminUserNestedInput
    uploadedFiles?: UploadedFileUncheckedUpdateManyWithoutUploadedByAdminUserNestedInput
    salesExpertProfile?: SalesExpertProfileUncheckedUpdateOneWithoutAdminUserNestedInput
    sessions?: AdminSessionUncheckedUpdateManyWithoutAdminUserNestedInput
  }

  export type AdminUserCreateManyInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    userTypeId?: number | null
    branchId?: string | null
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    avatarFileId?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
  }

  export type AdminUserUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type AdminUserUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    userTypeId?: NullableIntFieldUpdateOperationsInput | number | null
    branchId?: NullableStringFieldUpdateOperationsInput | string | null
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type AppSessionCreateInput = {
    id?: string
    jti: string
    subjectId: string
    subjectType: string
    mobile?: string | null
    iamSessionId?: string | null
    iamSub?: string | null
    ipAddress?: string | null
    userAgent?: string | null
    createdAt?: Date | string
    expiresAt?: Date | string | null
    lastSeenAt?: Date | string | null
    revokedAt?: Date | string | null
    revokedReason?: string | null
  }

  export type AppSessionUncheckedCreateInput = {
    id?: string
    jti: string
    subjectId: string
    subjectType: string
    mobile?: string | null
    iamSessionId?: string | null
    iamSub?: string | null
    ipAddress?: string | null
    userAgent?: string | null
    createdAt?: Date | string
    expiresAt?: Date | string | null
    lastSeenAt?: Date | string | null
    revokedAt?: Date | string | null
    revokedReason?: string | null
  }

  export type AppSessionUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    jti?: StringFieldUpdateOperationsInput | string
    subjectId?: StringFieldUpdateOperationsInput | string
    subjectType?: StringFieldUpdateOperationsInput | string
    mobile?: NullableStringFieldUpdateOperationsInput | string | null
    iamSessionId?: NullableStringFieldUpdateOperationsInput | string | null
    iamSub?: NullableStringFieldUpdateOperationsInput | string | null
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    lastSeenAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    revokedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    revokedReason?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type AppSessionUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    jti?: StringFieldUpdateOperationsInput | string
    subjectId?: StringFieldUpdateOperationsInput | string
    subjectType?: StringFieldUpdateOperationsInput | string
    mobile?: NullableStringFieldUpdateOperationsInput | string | null
    iamSessionId?: NullableStringFieldUpdateOperationsInput | string | null
    iamSub?: NullableStringFieldUpdateOperationsInput | string | null
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    lastSeenAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    revokedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    revokedReason?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type AppSessionCreateManyInput = {
    id?: string
    jti: string
    subjectId: string
    subjectType: string
    mobile?: string | null
    iamSessionId?: string | null
    iamSub?: string | null
    ipAddress?: string | null
    userAgent?: string | null
    createdAt?: Date | string
    expiresAt?: Date | string | null
    lastSeenAt?: Date | string | null
    revokedAt?: Date | string | null
    revokedReason?: string | null
  }

  export type AppSessionUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    jti?: StringFieldUpdateOperationsInput | string
    subjectId?: StringFieldUpdateOperationsInput | string
    subjectType?: StringFieldUpdateOperationsInput | string
    mobile?: NullableStringFieldUpdateOperationsInput | string | null
    iamSessionId?: NullableStringFieldUpdateOperationsInput | string | null
    iamSub?: NullableStringFieldUpdateOperationsInput | string | null
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    lastSeenAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    revokedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    revokedReason?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type AppSessionUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    jti?: StringFieldUpdateOperationsInput | string
    subjectId?: StringFieldUpdateOperationsInput | string
    subjectType?: StringFieldUpdateOperationsInput | string
    mobile?: NullableStringFieldUpdateOperationsInput | string | null
    iamSessionId?: NullableStringFieldUpdateOperationsInput | string | null
    iamSub?: NullableStringFieldUpdateOperationsInput | string | null
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    lastSeenAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    revokedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    revokedReason?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type AdminSessionCreateInput = {
    id?: string
    jti: string
    iamSessionId?: string | null
    iamSub?: string | null
    ipAddress?: string | null
    userAgent?: string | null
    createdAt?: Date | string
    expiresAt?: Date | string | null
    lastSeenAt?: Date | string | null
    revokedAt?: Date | string | null
    revokedReason?: string | null
    adminUser: AdminUserCreateNestedOneWithoutSessionsInput
  }

  export type AdminSessionUncheckedCreateInput = {
    id?: string
    jti: string
    adminUserId: string
    iamSessionId?: string | null
    iamSub?: string | null
    ipAddress?: string | null
    userAgent?: string | null
    createdAt?: Date | string
    expiresAt?: Date | string | null
    lastSeenAt?: Date | string | null
    revokedAt?: Date | string | null
    revokedReason?: string | null
  }

  export type AdminSessionUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    jti?: StringFieldUpdateOperationsInput | string
    iamSessionId?: NullableStringFieldUpdateOperationsInput | string | null
    iamSub?: NullableStringFieldUpdateOperationsInput | string | null
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    lastSeenAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    revokedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    revokedReason?: NullableStringFieldUpdateOperationsInput | string | null
    adminUser?: AdminUserUpdateOneRequiredWithoutSessionsNestedInput
  }

  export type AdminSessionUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    jti?: StringFieldUpdateOperationsInput | string
    adminUserId?: StringFieldUpdateOperationsInput | string
    iamSessionId?: NullableStringFieldUpdateOperationsInput | string | null
    iamSub?: NullableStringFieldUpdateOperationsInput | string | null
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    lastSeenAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    revokedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    revokedReason?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type AdminSessionCreateManyInput = {
    id?: string
    jti: string
    adminUserId: string
    iamSessionId?: string | null
    iamSub?: string | null
    ipAddress?: string | null
    userAgent?: string | null
    createdAt?: Date | string
    expiresAt?: Date | string | null
    lastSeenAt?: Date | string | null
    revokedAt?: Date | string | null
    revokedReason?: string | null
  }

  export type AdminSessionUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    jti?: StringFieldUpdateOperationsInput | string
    iamSessionId?: NullableStringFieldUpdateOperationsInput | string | null
    iamSub?: NullableStringFieldUpdateOperationsInput | string | null
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    lastSeenAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    revokedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    revokedReason?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type AdminSessionUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    jti?: StringFieldUpdateOperationsInput | string
    adminUserId?: StringFieldUpdateOperationsInput | string
    iamSessionId?: NullableStringFieldUpdateOperationsInput | string | null
    iamSub?: NullableStringFieldUpdateOperationsInput | string | null
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    lastSeenAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    revokedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    revokedReason?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type SalesExpertProfileCreateInput = {
    id?: string
    gramLevel?: Decimal | DecimalJsLike | number | string
    phone?: string | null
    nationalCode?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    adminUser: AdminUserCreateNestedOneWithoutSalesExpertProfileInput
    city?: CityCreateNestedOneWithoutSalesExpertProfilesInput
    tradingCustomer?: CustomerCreateNestedOneWithoutSalesExpertTradingForInput
  }

  export type SalesExpertProfileUncheckedCreateInput = {
    id?: string
    adminUserId: string
    cityId?: string | null
    gramLevel?: Decimal | DecimalJsLike | number | string
    phone?: string | null
    nationalCode?: string | null
    tradingCustomerId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SalesExpertProfileUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    gramLevel?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    nationalCode?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    adminUser?: AdminUserUpdateOneRequiredWithoutSalesExpertProfileNestedInput
    city?: CityUpdateOneWithoutSalesExpertProfilesNestedInput
    tradingCustomer?: CustomerUpdateOneWithoutSalesExpertTradingForNestedInput
  }

  export type SalesExpertProfileUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    adminUserId?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    gramLevel?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    nationalCode?: NullableStringFieldUpdateOperationsInput | string | null
    tradingCustomerId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SalesExpertProfileCreateManyInput = {
    id?: string
    adminUserId: string
    cityId?: string | null
    gramLevel?: Decimal | DecimalJsLike | number | string
    phone?: string | null
    nationalCode?: string | null
    tradingCustomerId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SalesExpertProfileUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    gramLevel?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    nationalCode?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SalesExpertProfileUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    adminUserId?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    gramLevel?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    nationalCode?: NullableStringFieldUpdateOperationsInput | string | null
    tradingCustomerId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CustomerCreateInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    city?: CityCreateNestedOneWithoutCustomersInput
    referredByAgent?: AdminUserCreateNestedOneWithoutReferredCustomersInput
    salesExpertTradingFor?: SalesExpertProfileCreateNestedOneWithoutTradingCustomerInput
    avatarFile?: UploadedFileCreateNestedOneWithoutCustomerAvatarsInput
    addresses?: CustomerAddressCreateNestedManyWithoutCustomerInput
    orders?: OrderCreateNestedManyWithoutCustomerInput
    preOrders?: PreOrderCreateNestedManyWithoutCustomerInput
    ledgerEntries?: LedgerEntryCreateNestedManyWithoutCustomerInput
    walletBonuses?: WalletBonusCreateNestedManyWithoutCustomerInput
    comments?: CommentCreateNestedManyWithoutCustomerInput
    promotions?: PromotionCreateNestedManyWithoutCustomerInput
    notifications?: NotificationRecipientCreateNestedManyWithoutCustomerInput
    activityLogs?: CustomerActivityLogCreateNestedManyWithoutCustomerInput
    otpChallenges?: CustomerOtpCreateNestedManyWithoutCustomerInput
  }

  export type CustomerUncheckedCreateInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    cityId?: string | null
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    referredByAgentId?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    avatarFileId?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    salesExpertTradingFor?: SalesExpertProfileUncheckedCreateNestedOneWithoutTradingCustomerInput
    addresses?: CustomerAddressUncheckedCreateNestedManyWithoutCustomerInput
    orders?: OrderUncheckedCreateNestedManyWithoutCustomerInput
    preOrders?: PreOrderUncheckedCreateNestedManyWithoutCustomerInput
    ledgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutCustomerInput
    walletBonuses?: WalletBonusUncheckedCreateNestedManyWithoutCustomerInput
    comments?: CommentUncheckedCreateNestedManyWithoutCustomerInput
    promotions?: PromotionUncheckedCreateNestedManyWithoutCustomerInput
    notifications?: NotificationRecipientUncheckedCreateNestedManyWithoutCustomerInput
    activityLogs?: CustomerActivityLogUncheckedCreateNestedManyWithoutCustomerInput
    otpChallenges?: CustomerOtpUncheckedCreateNestedManyWithoutCustomerInput
  }

  export type CustomerUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutCustomersNestedInput
    referredByAgent?: AdminUserUpdateOneWithoutReferredCustomersNestedInput
    salesExpertTradingFor?: SalesExpertProfileUpdateOneWithoutTradingCustomerNestedInput
    avatarFile?: UploadedFileUpdateOneWithoutCustomerAvatarsNestedInput
    addresses?: CustomerAddressUpdateManyWithoutCustomerNestedInput
    orders?: OrderUpdateManyWithoutCustomerNestedInput
    preOrders?: PreOrderUpdateManyWithoutCustomerNestedInput
    ledgerEntries?: LedgerEntryUpdateManyWithoutCustomerNestedInput
    walletBonuses?: WalletBonusUpdateManyWithoutCustomerNestedInput
    comments?: CommentUpdateManyWithoutCustomerNestedInput
    promotions?: PromotionUpdateManyWithoutCustomerNestedInput
    notifications?: NotificationRecipientUpdateManyWithoutCustomerNestedInput
    activityLogs?: CustomerActivityLogUpdateManyWithoutCustomerNestedInput
    otpChallenges?: CustomerOtpUpdateManyWithoutCustomerNestedInput
  }

  export type CustomerUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredByAgentId?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    salesExpertTradingFor?: SalesExpertProfileUncheckedUpdateOneWithoutTradingCustomerNestedInput
    addresses?: CustomerAddressUncheckedUpdateManyWithoutCustomerNestedInput
    orders?: OrderUncheckedUpdateManyWithoutCustomerNestedInput
    preOrders?: PreOrderUncheckedUpdateManyWithoutCustomerNestedInput
    ledgerEntries?: LedgerEntryUncheckedUpdateManyWithoutCustomerNestedInput
    walletBonuses?: WalletBonusUncheckedUpdateManyWithoutCustomerNestedInput
    comments?: CommentUncheckedUpdateManyWithoutCustomerNestedInput
    promotions?: PromotionUncheckedUpdateManyWithoutCustomerNestedInput
    notifications?: NotificationRecipientUncheckedUpdateManyWithoutCustomerNestedInput
    activityLogs?: CustomerActivityLogUncheckedUpdateManyWithoutCustomerNestedInput
    otpChallenges?: CustomerOtpUncheckedUpdateManyWithoutCustomerNestedInput
  }

  export type CustomerCreateManyInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    cityId?: string | null
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    referredByAgentId?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    avatarFileId?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type CustomerUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CustomerUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredByAgentId?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CustomerAddressCreateInput = {
    id?: string
    addressLine: string
    isDefault?: boolean
    customer: CustomerCreateNestedOneWithoutAddressesInput
    city?: CityCreateNestedOneWithoutAddressesInput
  }

  export type CustomerAddressUncheckedCreateInput = {
    id?: string
    customerId: string
    cityId?: string | null
    addressLine: string
    isDefault?: boolean
  }

  export type CustomerAddressUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    addressLine?: StringFieldUpdateOperationsInput | string
    isDefault?: BoolFieldUpdateOperationsInput | boolean
    customer?: CustomerUpdateOneRequiredWithoutAddressesNestedInput
    city?: CityUpdateOneWithoutAddressesNestedInput
  }

  export type CustomerAddressUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    addressLine?: StringFieldUpdateOperationsInput | string
    isDefault?: BoolFieldUpdateOperationsInput | boolean
  }

  export type CustomerAddressCreateManyInput = {
    id?: string
    customerId: string
    cityId?: string | null
    addressLine: string
    isDefault?: boolean
  }

  export type CustomerAddressUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    addressLine?: StringFieldUpdateOperationsInput | string
    isDefault?: BoolFieldUpdateOperationsInput | boolean
  }

  export type CustomerAddressUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    addressLine?: StringFieldUpdateOperationsInput | string
    isDefault?: BoolFieldUpdateOperationsInput | boolean
  }

  export type BranchCreateInput = {
    id?: string
    name: string
    address?: string | null
    phone?: string | null
    isActive?: boolean
    city?: CityCreateNestedOneWithoutBranchesInput
    adminUsers?: AdminUserCreateNestedManyWithoutBranchInput
    orders?: OrderCreateNestedManyWithoutBranchInput
    allocations?: BranchAllocationCreateNestedManyWithoutBranchInput
  }

  export type BranchUncheckedCreateInput = {
    id?: string
    name: string
    address?: string | null
    phone?: string | null
    isActive?: boolean
    cityId?: string | null
    adminUsers?: AdminUserUncheckedCreateNestedManyWithoutBranchInput
    orders?: OrderUncheckedCreateNestedManyWithoutBranchInput
    allocations?: BranchAllocationUncheckedCreateNestedManyWithoutBranchInput
  }

  export type BranchUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    city?: CityUpdateOneWithoutBranchesNestedInput
    adminUsers?: AdminUserUpdateManyWithoutBranchNestedInput
    orders?: OrderUpdateManyWithoutBranchNestedInput
    allocations?: BranchAllocationUpdateManyWithoutBranchNestedInput
  }

  export type BranchUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    adminUsers?: AdminUserUncheckedUpdateManyWithoutBranchNestedInput
    orders?: OrderUncheckedUpdateManyWithoutBranchNestedInput
    allocations?: BranchAllocationUncheckedUpdateManyWithoutBranchNestedInput
  }

  export type BranchCreateManyInput = {
    id?: string
    name: string
    address?: string | null
    phone?: string | null
    isActive?: boolean
    cityId?: string | null
  }

  export type BranchUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
  }

  export type BranchUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type WorkshopCreateInput = {
    id?: string
    name: string
    address?: string | null
    phone?: string | null
    isActive?: boolean
    supervisor?: AdminUserCreateNestedOneWithoutSupervisedWorkshopsInput
    preOrders?: PreOrderCreateNestedManyWithoutWorkshopInput
  }

  export type WorkshopUncheckedCreateInput = {
    id?: string
    name: string
    address?: string | null
    phone?: string | null
    supervisorId?: string | null
    isActive?: boolean
    preOrders?: PreOrderUncheckedCreateNestedManyWithoutWorkshopInput
  }

  export type WorkshopUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    supervisor?: AdminUserUpdateOneWithoutSupervisedWorkshopsNestedInput
    preOrders?: PreOrderUpdateManyWithoutWorkshopNestedInput
  }

  export type WorkshopUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    supervisorId?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    preOrders?: PreOrderUncheckedUpdateManyWithoutWorkshopNestedInput
  }

  export type WorkshopCreateManyInput = {
    id?: string
    name: string
    address?: string | null
    phone?: string | null
    supervisorId?: string | null
    isActive?: boolean
  }

  export type WorkshopUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
  }

  export type WorkshopUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    supervisorId?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
  }

  export type CategoryCreateInput = {
    id?: string
    title: string
    type?: number
    imageUrl?: string | null
    iconUrl?: string | null
    metaTag?: string | null
    description?: string | null
    parent?: CategoryCreateNestedOneWithoutChildrenInput
    children?: CategoryCreateNestedManyWithoutParentInput
    products?: ProductCreateNestedManyWithoutCategoryInput
    promotions?: PromotionCreateNestedManyWithoutCategoryInput
  }

  export type CategoryUncheckedCreateInput = {
    id?: string
    title: string
    type?: number
    imageUrl?: string | null
    iconUrl?: string | null
    metaTag?: string | null
    description?: string | null
    parentId?: string | null
    children?: CategoryUncheckedCreateNestedManyWithoutParentInput
    products?: ProductUncheckedCreateNestedManyWithoutCategoryInput
    promotions?: PromotionUncheckedCreateNestedManyWithoutCategoryInput
  }

  export type CategoryUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    type?: IntFieldUpdateOperationsInput | number
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    iconUrl?: NullableStringFieldUpdateOperationsInput | string | null
    metaTag?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    parent?: CategoryUpdateOneWithoutChildrenNestedInput
    children?: CategoryUpdateManyWithoutParentNestedInput
    products?: ProductUpdateManyWithoutCategoryNestedInput
    promotions?: PromotionUpdateManyWithoutCategoryNestedInput
  }

  export type CategoryUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    type?: IntFieldUpdateOperationsInput | number
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    iconUrl?: NullableStringFieldUpdateOperationsInput | string | null
    metaTag?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    parentId?: NullableStringFieldUpdateOperationsInput | string | null
    children?: CategoryUncheckedUpdateManyWithoutParentNestedInput
    products?: ProductUncheckedUpdateManyWithoutCategoryNestedInput
    promotions?: PromotionUncheckedUpdateManyWithoutCategoryNestedInput
  }

  export type CategoryCreateManyInput = {
    id?: string
    title: string
    type?: number
    imageUrl?: string | null
    iconUrl?: string | null
    metaTag?: string | null
    description?: string | null
    parentId?: string | null
  }

  export type CategoryUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    type?: IntFieldUpdateOperationsInput | number
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    iconUrl?: NullableStringFieldUpdateOperationsInput | string | null
    metaTag?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type CategoryUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    type?: IntFieldUpdateOperationsInput | number
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    iconUrl?: NullableStringFieldUpdateOperationsInput | string | null
    metaTag?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    parentId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type BrandCreateInput = {
    id?: string
    title: string
    products?: ProductCreateNestedManyWithoutBrandInput
    promotions?: PromotionCreateNestedManyWithoutBrandInput
  }

  export type BrandUncheckedCreateInput = {
    id?: string
    title: string
    products?: ProductUncheckedCreateNestedManyWithoutBrandInput
    promotions?: PromotionUncheckedCreateNestedManyWithoutBrandInput
  }

  export type BrandUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    products?: ProductUpdateManyWithoutBrandNestedInput
    promotions?: PromotionUpdateManyWithoutBrandNestedInput
  }

  export type BrandUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    products?: ProductUncheckedUpdateManyWithoutBrandNestedInput
    promotions?: PromotionUncheckedUpdateManyWithoutBrandNestedInput
  }

  export type BrandCreateManyInput = {
    id?: string
    title: string
  }

  export type BrandUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
  }

  export type BrandUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
  }

  export type CollectionCreateInput = {
    id?: string
    title: string
    description?: string | null
    isActive?: boolean
    products?: CollectionProductCreateNestedManyWithoutCollectionInput
  }

  export type CollectionUncheckedCreateInput = {
    id?: string
    title: string
    description?: string | null
    isActive?: boolean
    products?: CollectionProductUncheckedCreateNestedManyWithoutCollectionInput
  }

  export type CollectionUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    products?: CollectionProductUpdateManyWithoutCollectionNestedInput
  }

  export type CollectionUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    products?: CollectionProductUncheckedUpdateManyWithoutCollectionNestedInput
  }

  export type CollectionCreateManyInput = {
    id?: string
    title: string
    description?: string | null
    isActive?: boolean
  }

  export type CollectionUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
  }

  export type CollectionUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
  }

  export type CollectionProductCreateInput = {
    collection: CollectionCreateNestedOneWithoutProductsInput
    product: ProductCreateNestedOneWithoutCollectionsInput
  }

  export type CollectionProductUncheckedCreateInput = {
    collectionId: string
    productId: string
  }

  export type CollectionProductUpdateInput = {
    collection?: CollectionUpdateOneRequiredWithoutProductsNestedInput
    product?: ProductUpdateOneRequiredWithoutCollectionsNestedInput
  }

  export type CollectionProductUncheckedUpdateInput = {
    collectionId?: StringFieldUpdateOperationsInput | string
    productId?: StringFieldUpdateOperationsInput | string
  }

  export type CollectionProductCreateManyInput = {
    collectionId: string
    productId: string
  }

  export type CollectionProductUpdateManyMutationInput = {

  }

  export type CollectionProductUncheckedUpdateManyInput = {
    collectionId?: StringFieldUpdateOperationsInput | string
    productId?: StringFieldUpdateOperationsInput | string
  }

  export type ProductCreateInput = {
    id?: string
    title: string
    description?: string | null
    productCode?: string | null
    showType?: number
    isActive?: boolean
    createdAt?: Date | string
    category?: CategoryCreateNestedOneWithoutProductsInput
    brand?: BrandCreateNestedOneWithoutProductsInput
    variants?: ProductVariantCreateNestedManyWithoutProductInput
    images?: ProductImageCreateNestedManyWithoutProductInput
    collections?: CollectionProductCreateNestedManyWithoutProductInput
    comments?: CommentCreateNestedManyWithoutProductInput
    promotions?: PromotionCreateNestedManyWithoutProductInput
    allocationItems?: BranchAllocationItemCreateNestedManyWithoutProductInput
  }

  export type ProductUncheckedCreateInput = {
    id?: string
    title: string
    description?: string | null
    categoryId?: string | null
    brandId?: string | null
    productCode?: string | null
    showType?: number
    isActive?: boolean
    createdAt?: Date | string
    variants?: ProductVariantUncheckedCreateNestedManyWithoutProductInput
    images?: ProductImageUncheckedCreateNestedManyWithoutProductInput
    collections?: CollectionProductUncheckedCreateNestedManyWithoutProductInput
    comments?: CommentUncheckedCreateNestedManyWithoutProductInput
    promotions?: PromotionUncheckedCreateNestedManyWithoutProductInput
    allocationItems?: BranchAllocationItemUncheckedCreateNestedManyWithoutProductInput
  }

  export type ProductUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    productCode?: NullableStringFieldUpdateOperationsInput | string | null
    showType?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    category?: CategoryUpdateOneWithoutProductsNestedInput
    brand?: BrandUpdateOneWithoutProductsNestedInput
    variants?: ProductVariantUpdateManyWithoutProductNestedInput
    images?: ProductImageUpdateManyWithoutProductNestedInput
    collections?: CollectionProductUpdateManyWithoutProductNestedInput
    comments?: CommentUpdateManyWithoutProductNestedInput
    promotions?: PromotionUpdateManyWithoutProductNestedInput
    allocationItems?: BranchAllocationItemUpdateManyWithoutProductNestedInput
  }

  export type ProductUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    categoryId?: NullableStringFieldUpdateOperationsInput | string | null
    brandId?: NullableStringFieldUpdateOperationsInput | string | null
    productCode?: NullableStringFieldUpdateOperationsInput | string | null
    showType?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    variants?: ProductVariantUncheckedUpdateManyWithoutProductNestedInput
    images?: ProductImageUncheckedUpdateManyWithoutProductNestedInput
    collections?: CollectionProductUncheckedUpdateManyWithoutProductNestedInput
    comments?: CommentUncheckedUpdateManyWithoutProductNestedInput
    promotions?: PromotionUncheckedUpdateManyWithoutProductNestedInput
    allocationItems?: BranchAllocationItemUncheckedUpdateManyWithoutProductNestedInput
  }

  export type ProductCreateManyInput = {
    id?: string
    title: string
    description?: string | null
    categoryId?: string | null
    brandId?: string | null
    productCode?: string | null
    showType?: number
    isActive?: boolean
    createdAt?: Date | string
  }

  export type ProductUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    productCode?: NullableStringFieldUpdateOperationsInput | string | null
    showType?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProductUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    categoryId?: NullableStringFieldUpdateOperationsInput | string | null
    brandId?: NullableStringFieldUpdateOperationsInput | string | null
    productCode?: NullableStringFieldUpdateOperationsInput | string | null
    showType?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProductImageCreateInput = {
    id?: string
    url: string
    sortOrder?: number
    role?: $Enums.ProductImageRole
    product: ProductCreateNestedOneWithoutImagesInput
    variants?: ProductVariantCreateNestedManyWithoutImageInput
  }

  export type ProductImageUncheckedCreateInput = {
    id?: string
    productId: string
    url: string
    sortOrder?: number
    role?: $Enums.ProductImageRole
    variants?: ProductVariantUncheckedCreateNestedManyWithoutImageInput
  }

  export type ProductImageUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    sortOrder?: IntFieldUpdateOperationsInput | number
    role?: EnumProductImageRoleFieldUpdateOperationsInput | $Enums.ProductImageRole
    product?: ProductUpdateOneRequiredWithoutImagesNestedInput
    variants?: ProductVariantUpdateManyWithoutImageNestedInput
  }

  export type ProductImageUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    productId?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    sortOrder?: IntFieldUpdateOperationsInput | number
    role?: EnumProductImageRoleFieldUpdateOperationsInput | $Enums.ProductImageRole
    variants?: ProductVariantUncheckedUpdateManyWithoutImageNestedInput
  }

  export type ProductImageCreateManyInput = {
    id?: string
    productId: string
    url: string
    sortOrder?: number
    role?: $Enums.ProductImageRole
  }

  export type ProductImageUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    sortOrder?: IntFieldUpdateOperationsInput | number
    role?: EnumProductImageRoleFieldUpdateOperationsInput | $Enums.ProductImageRole
  }

  export type ProductImageUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    productId?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    sortOrder?: IntFieldUpdateOperationsInput | number
    role?: EnumProductImageRoleFieldUpdateOperationsInput | $Enums.ProductImageRole
  }

  export type ProductVariantCreateInput = {
    id?: string
    title: string
    sku?: string | null
    rashWeightGrams: Decimal | DecimalJsLike | number | string
    defaultWagePercent: Decimal | DecimalJsLike | number | string
    qty?: number
    isPreOrder?: boolean
    isActive?: boolean
    product: ProductCreateNestedOneWithoutVariantsInput
    image?: ProductImageCreateNestedOneWithoutVariantsInput
    orderItems?: OrderItemCreateNestedManyWithoutProductVariantInput
  }

  export type ProductVariantUncheckedCreateInput = {
    id?: string
    productId: string
    title: string
    sku?: string | null
    rashWeightGrams: Decimal | DecimalJsLike | number | string
    defaultWagePercent: Decimal | DecimalJsLike | number | string
    qty?: number
    isPreOrder?: boolean
    isActive?: boolean
    imageId?: string | null
    orderItems?: OrderItemUncheckedCreateNestedManyWithoutProductVariantInput
  }

  export type ProductVariantUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    sku?: NullableStringFieldUpdateOperationsInput | string | null
    rashWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    defaultWagePercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    qty?: IntFieldUpdateOperationsInput | number
    isPreOrder?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    product?: ProductUpdateOneRequiredWithoutVariantsNestedInput
    image?: ProductImageUpdateOneWithoutVariantsNestedInput
    orderItems?: OrderItemUpdateManyWithoutProductVariantNestedInput
  }

  export type ProductVariantUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    productId?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    sku?: NullableStringFieldUpdateOperationsInput | string | null
    rashWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    defaultWagePercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    qty?: IntFieldUpdateOperationsInput | number
    isPreOrder?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    imageId?: NullableStringFieldUpdateOperationsInput | string | null
    orderItems?: OrderItemUncheckedUpdateManyWithoutProductVariantNestedInput
  }

  export type ProductVariantCreateManyInput = {
    id?: string
    productId: string
    title: string
    sku?: string | null
    rashWeightGrams: Decimal | DecimalJsLike | number | string
    defaultWagePercent: Decimal | DecimalJsLike | number | string
    qty?: number
    isPreOrder?: boolean
    isActive?: boolean
    imageId?: string | null
  }

  export type ProductVariantUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    sku?: NullableStringFieldUpdateOperationsInput | string | null
    rashWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    defaultWagePercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    qty?: IntFieldUpdateOperationsInput | number
    isPreOrder?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
  }

  export type ProductVariantUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    productId?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    sku?: NullableStringFieldUpdateOperationsInput | string | null
    rashWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    defaultWagePercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    qty?: IntFieldUpdateOperationsInput | number
    isPreOrder?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    imageId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type OrderCreateInput = {
    id?: string
    orderNumber: string
    channel?: $Enums.OrderChannel
    status?: $Enums.OrderStatus
    totalGoldWeightGrams: Decimal | DecimalJsLike | number | string
    wageWeightGrams: Decimal | DecimalJsLike | number | string
    flatRialCharge?: Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: boolean
    deliveredAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    customer: CustomerCreateNestedOneWithoutOrdersInput
    branch?: BranchCreateNestedOneWithoutOrdersInput
    items?: OrderItemCreateNestedManyWithoutOrderInput
    statusEvents?: OrderStatusEventCreateNestedManyWithoutOrderInput
    ledgerEntries?: LedgerEntryCreateNestedManyWithoutOrderInput
    convertedFromPreOrder?: PreOrderCreateNestedOneWithoutConvertedOrderInput
  }

  export type OrderUncheckedCreateInput = {
    id?: string
    orderNumber: string
    customerId: string
    branchId?: string | null
    channel?: $Enums.OrderChannel
    status?: $Enums.OrderStatus
    totalGoldWeightGrams: Decimal | DecimalJsLike | number | string
    wageWeightGrams: Decimal | DecimalJsLike | number | string
    flatRialCharge?: Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: boolean
    deliveredAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    items?: OrderItemUncheckedCreateNestedManyWithoutOrderInput
    statusEvents?: OrderStatusEventUncheckedCreateNestedManyWithoutOrderInput
    ledgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutOrderInput
    convertedFromPreOrder?: PreOrderUncheckedCreateNestedOneWithoutConvertedOrderInput
  }

  export type OrderUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderNumber?: StringFieldUpdateOperationsInput | string
    channel?: EnumOrderChannelFieldUpdateOperationsInput | $Enums.OrderChannel
    status?: EnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus
    totalGoldWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    wageWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: BoolFieldUpdateOperationsInput | boolean
    deliveredAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    customer?: CustomerUpdateOneRequiredWithoutOrdersNestedInput
    branch?: BranchUpdateOneWithoutOrdersNestedInput
    items?: OrderItemUpdateManyWithoutOrderNestedInput
    statusEvents?: OrderStatusEventUpdateManyWithoutOrderNestedInput
    ledgerEntries?: LedgerEntryUpdateManyWithoutOrderNestedInput
    convertedFromPreOrder?: PreOrderUpdateOneWithoutConvertedOrderNestedInput
  }

  export type OrderUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderNumber?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    branchId?: NullableStringFieldUpdateOperationsInput | string | null
    channel?: EnumOrderChannelFieldUpdateOperationsInput | $Enums.OrderChannel
    status?: EnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus
    totalGoldWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    wageWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: BoolFieldUpdateOperationsInput | boolean
    deliveredAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    items?: OrderItemUncheckedUpdateManyWithoutOrderNestedInput
    statusEvents?: OrderStatusEventUncheckedUpdateManyWithoutOrderNestedInput
    ledgerEntries?: LedgerEntryUncheckedUpdateManyWithoutOrderNestedInput
    convertedFromPreOrder?: PreOrderUncheckedUpdateOneWithoutConvertedOrderNestedInput
  }

  export type OrderCreateManyInput = {
    id?: string
    orderNumber: string
    customerId: string
    branchId?: string | null
    channel?: $Enums.OrderChannel
    status?: $Enums.OrderStatus
    totalGoldWeightGrams: Decimal | DecimalJsLike | number | string
    wageWeightGrams: Decimal | DecimalJsLike | number | string
    flatRialCharge?: Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: boolean
    deliveredAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type OrderUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderNumber?: StringFieldUpdateOperationsInput | string
    channel?: EnumOrderChannelFieldUpdateOperationsInput | $Enums.OrderChannel
    status?: EnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus
    totalGoldWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    wageWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: BoolFieldUpdateOperationsInput | boolean
    deliveredAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type OrderUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderNumber?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    branchId?: NullableStringFieldUpdateOperationsInput | string | null
    channel?: EnumOrderChannelFieldUpdateOperationsInput | $Enums.OrderChannel
    status?: EnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus
    totalGoldWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    wageWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: BoolFieldUpdateOperationsInput | boolean
    deliveredAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type OrderItemCreateInput = {
    id?: string
    quantity: number
    rashWeightGramsSnapshot: Decimal | DecimalJsLike | number | string
    wagePercentSnapshot: Decimal | DecimalJsLike | number | string
    discountPercentSnapshot?: Decimal | DecimalJsLike | number | string
    computedWeightGrams: Decimal | DecimalJsLike | number | string
    flatRialCharge?: Decimal | DecimalJsLike | number | string
    order: OrderCreateNestedOneWithoutItemsInput
    productVariant: ProductVariantCreateNestedOneWithoutOrderItemsInput
  }

  export type OrderItemUncheckedCreateInput = {
    id?: string
    orderId: string
    productVariantId: string
    quantity: number
    rashWeightGramsSnapshot: Decimal | DecimalJsLike | number | string
    wagePercentSnapshot: Decimal | DecimalJsLike | number | string
    discountPercentSnapshot?: Decimal | DecimalJsLike | number | string
    computedWeightGrams: Decimal | DecimalJsLike | number | string
    flatRialCharge?: Decimal | DecimalJsLike | number | string
  }

  export type OrderItemUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    quantity?: IntFieldUpdateOperationsInput | number
    rashWeightGramsSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    wagePercentSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    discountPercentSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    computedWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order?: OrderUpdateOneRequiredWithoutItemsNestedInput
    productVariant?: ProductVariantUpdateOneRequiredWithoutOrderItemsNestedInput
  }

  export type OrderItemUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderId?: StringFieldUpdateOperationsInput | string
    productVariantId?: StringFieldUpdateOperationsInput | string
    quantity?: IntFieldUpdateOperationsInput | number
    rashWeightGramsSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    wagePercentSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    discountPercentSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    computedWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
  }

  export type OrderItemCreateManyInput = {
    id?: string
    orderId: string
    productVariantId: string
    quantity: number
    rashWeightGramsSnapshot: Decimal | DecimalJsLike | number | string
    wagePercentSnapshot: Decimal | DecimalJsLike | number | string
    discountPercentSnapshot?: Decimal | DecimalJsLike | number | string
    computedWeightGrams: Decimal | DecimalJsLike | number | string
    flatRialCharge?: Decimal | DecimalJsLike | number | string
  }

  export type OrderItemUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    quantity?: IntFieldUpdateOperationsInput | number
    rashWeightGramsSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    wagePercentSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    discountPercentSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    computedWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
  }

  export type OrderItemUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderId?: StringFieldUpdateOperationsInput | string
    productVariantId?: StringFieldUpdateOperationsInput | string
    quantity?: IntFieldUpdateOperationsInput | number
    rashWeightGramsSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    wagePercentSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    discountPercentSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    computedWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
  }

  export type OrderStatusEventCreateInput = {
    id?: string
    fromStatus?: $Enums.OrderStatus | null
    toStatus: $Enums.OrderStatus
    note?: string | null
    createdAt?: Date | string
    order: OrderCreateNestedOneWithoutStatusEventsInput
    actorAdminUser?: AdminUserCreateNestedOneWithoutOrderStatusEventsInput
  }

  export type OrderStatusEventUncheckedCreateInput = {
    id?: string
    orderId: string
    fromStatus?: $Enums.OrderStatus | null
    toStatus: $Enums.OrderStatus
    note?: string | null
    actorAdminUserId?: string | null
    createdAt?: Date | string
  }

  export type OrderStatusEventUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    fromStatus?: NullableEnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus | null
    toStatus?: EnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    order?: OrderUpdateOneRequiredWithoutStatusEventsNestedInput
    actorAdminUser?: AdminUserUpdateOneWithoutOrderStatusEventsNestedInput
  }

  export type OrderStatusEventUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderId?: StringFieldUpdateOperationsInput | string
    fromStatus?: NullableEnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus | null
    toStatus?: EnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus
    note?: NullableStringFieldUpdateOperationsInput | string | null
    actorAdminUserId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type OrderStatusEventCreateManyInput = {
    id?: string
    orderId: string
    fromStatus?: $Enums.OrderStatus | null
    toStatus: $Enums.OrderStatus
    note?: string | null
    actorAdminUserId?: string | null
    createdAt?: Date | string
  }

  export type OrderStatusEventUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    fromStatus?: NullableEnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus | null
    toStatus?: EnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type OrderStatusEventUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderId?: StringFieldUpdateOperationsInput | string
    fromStatus?: NullableEnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus | null
    toStatus?: EnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus
    note?: NullableStringFieldUpdateOperationsInput | string | null
    actorAdminUserId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PreOrderCreateInput = {
    id?: string
    status?: $Enums.PreOrderStatus
    designImageUrl?: string | null
    colorName?: string | null
    sizeSpec?: string | null
    stoneColor?: string | null
    minaColor?: string | null
    estimatedWeightGrams?: Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: Decimal | DecimalJsLike | number | string | null
    description?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    customer: CustomerCreateNestedOneWithoutPreOrdersInput
    city?: CityCreateNestedOneWithoutPreOrdersInput
    workshop?: WorkshopCreateNestedOneWithoutPreOrdersInput
    convertedOrder?: OrderCreateNestedOneWithoutConvertedFromPreOrderInput
    statusEvents?: PreOrderStatusEventCreateNestedManyWithoutPreOrderInput
  }

  export type PreOrderUncheckedCreateInput = {
    id?: string
    customerId: string
    cityId?: string | null
    workshopId?: string | null
    status?: $Enums.PreOrderStatus
    designImageUrl?: string | null
    colorName?: string | null
    sizeSpec?: string | null
    stoneColor?: string | null
    minaColor?: string | null
    estimatedWeightGrams?: Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: Decimal | DecimalJsLike | number | string | null
    description?: string | null
    convertedOrderId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    statusEvents?: PreOrderStatusEventUncheckedCreateNestedManyWithoutPreOrderInput
  }

  export type PreOrderUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: EnumPreOrderStatusFieldUpdateOperationsInput | $Enums.PreOrderStatus
    designImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    colorName?: NullableStringFieldUpdateOperationsInput | string | null
    sizeSpec?: NullableStringFieldUpdateOperationsInput | string | null
    stoneColor?: NullableStringFieldUpdateOperationsInput | string | null
    minaColor?: NullableStringFieldUpdateOperationsInput | string | null
    estimatedWeightGrams?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    customer?: CustomerUpdateOneRequiredWithoutPreOrdersNestedInput
    city?: CityUpdateOneWithoutPreOrdersNestedInput
    workshop?: WorkshopUpdateOneWithoutPreOrdersNestedInput
    convertedOrder?: OrderUpdateOneWithoutConvertedFromPreOrderNestedInput
    statusEvents?: PreOrderStatusEventUpdateManyWithoutPreOrderNestedInput
  }

  export type PreOrderUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    workshopId?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPreOrderStatusFieldUpdateOperationsInput | $Enums.PreOrderStatus
    designImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    colorName?: NullableStringFieldUpdateOperationsInput | string | null
    sizeSpec?: NullableStringFieldUpdateOperationsInput | string | null
    stoneColor?: NullableStringFieldUpdateOperationsInput | string | null
    minaColor?: NullableStringFieldUpdateOperationsInput | string | null
    estimatedWeightGrams?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    convertedOrderId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    statusEvents?: PreOrderStatusEventUncheckedUpdateManyWithoutPreOrderNestedInput
  }

  export type PreOrderCreateManyInput = {
    id?: string
    customerId: string
    cityId?: string | null
    workshopId?: string | null
    status?: $Enums.PreOrderStatus
    designImageUrl?: string | null
    colorName?: string | null
    sizeSpec?: string | null
    stoneColor?: string | null
    minaColor?: string | null
    estimatedWeightGrams?: Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: Decimal | DecimalJsLike | number | string | null
    description?: string | null
    convertedOrderId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type PreOrderUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: EnumPreOrderStatusFieldUpdateOperationsInput | $Enums.PreOrderStatus
    designImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    colorName?: NullableStringFieldUpdateOperationsInput | string | null
    sizeSpec?: NullableStringFieldUpdateOperationsInput | string | null
    stoneColor?: NullableStringFieldUpdateOperationsInput | string | null
    minaColor?: NullableStringFieldUpdateOperationsInput | string | null
    estimatedWeightGrams?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PreOrderUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    workshopId?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPreOrderStatusFieldUpdateOperationsInput | $Enums.PreOrderStatus
    designImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    colorName?: NullableStringFieldUpdateOperationsInput | string | null
    sizeSpec?: NullableStringFieldUpdateOperationsInput | string | null
    stoneColor?: NullableStringFieldUpdateOperationsInput | string | null
    minaColor?: NullableStringFieldUpdateOperationsInput | string | null
    estimatedWeightGrams?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    convertedOrderId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PreOrderStatusEventCreateInput = {
    id?: string
    changes: JsonNullValueInput | InputJsonValue
    ipAddress?: string | null
    createdAt?: Date | string
    preOrder: PreOrderCreateNestedOneWithoutStatusEventsInput
    actorAdminUser?: AdminUserCreateNestedOneWithoutPreOrderStatusEventsInput
  }

  export type PreOrderStatusEventUncheckedCreateInput = {
    id?: string
    preOrderId: string
    changes: JsonNullValueInput | InputJsonValue
    actorAdminUserId?: string | null
    ipAddress?: string | null
    createdAt?: Date | string
  }

  export type PreOrderStatusEventUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    changes?: JsonNullValueInput | InputJsonValue
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    preOrder?: PreOrderUpdateOneRequiredWithoutStatusEventsNestedInput
    actorAdminUser?: AdminUserUpdateOneWithoutPreOrderStatusEventsNestedInput
  }

  export type PreOrderStatusEventUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    preOrderId?: StringFieldUpdateOperationsInput | string
    changes?: JsonNullValueInput | InputJsonValue
    actorAdminUserId?: NullableStringFieldUpdateOperationsInput | string | null
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PreOrderStatusEventCreateManyInput = {
    id?: string
    preOrderId: string
    changes: JsonNullValueInput | InputJsonValue
    actorAdminUserId?: string | null
    ipAddress?: string | null
    createdAt?: Date | string
  }

  export type PreOrderStatusEventUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    changes?: JsonNullValueInput | InputJsonValue
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PreOrderStatusEventUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    preOrderId?: StringFieldUpdateOperationsInput | string
    changes?: JsonNullValueInput | InputJsonValue
    actorAdminUserId?: NullableStringFieldUpdateOperationsInput | string | null
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LedgerEntryCreateInput = {
    id?: string
    currency: $Enums.LedgerCurrency
    direction: $Enums.LedgerDirection
    sourceType: $Enums.LedgerSourceType
    amount: Decimal | DecimalJsLike | number | string
    karatPerMille?: number | null
    pricePerGramRialAtEntry?: Decimal | DecimalJsLike | number | string | null
    confirmed?: boolean
    confirmedAt?: Date | string | null
    labName?: string | null
    hallmark?: string | null
    accountName?: string | null
    bankName?: string | null
    transferTo?: string | null
    originalValue?: Decimal | DecimalJsLike | number | string | null
    priceRial?: Decimal | DecimalJsLike | number | string | null
    receivedAt?: Date | string | null
    note?: string | null
    createdAt?: Date | string
    customer: CustomerCreateNestedOneWithoutLedgerEntriesInput
    order?: OrderCreateNestedOneWithoutLedgerEntriesInput
    postedByAdminUser?: AdminUserCreateNestedOneWithoutPostedLedgerEntriesInput
  }

  export type LedgerEntryUncheckedCreateInput = {
    id?: string
    customerId: string
    currency: $Enums.LedgerCurrency
    direction: $Enums.LedgerDirection
    sourceType: $Enums.LedgerSourceType
    amount: Decimal | DecimalJsLike | number | string
    karatPerMille?: number | null
    pricePerGramRialAtEntry?: Decimal | DecimalJsLike | number | string | null
    orderId?: string | null
    confirmed?: boolean
    confirmedAt?: Date | string | null
    postedByAdminUserId?: string | null
    labName?: string | null
    hallmark?: string | null
    accountName?: string | null
    bankName?: string | null
    transferTo?: string | null
    originalValue?: Decimal | DecimalJsLike | number | string | null
    priceRial?: Decimal | DecimalJsLike | number | string | null
    receivedAt?: Date | string | null
    note?: string | null
    createdAt?: Date | string
  }

  export type LedgerEntryUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    currency?: EnumLedgerCurrencyFieldUpdateOperationsInput | $Enums.LedgerCurrency
    direction?: EnumLedgerDirectionFieldUpdateOperationsInput | $Enums.LedgerDirection
    sourceType?: EnumLedgerSourceTypeFieldUpdateOperationsInput | $Enums.LedgerSourceType
    amount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    karatPerMille?: NullableIntFieldUpdateOperationsInput | number | null
    pricePerGramRialAtEntry?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    confirmed?: BoolFieldUpdateOperationsInput | boolean
    confirmedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    labName?: NullableStringFieldUpdateOperationsInput | string | null
    hallmark?: NullableStringFieldUpdateOperationsInput | string | null
    accountName?: NullableStringFieldUpdateOperationsInput | string | null
    bankName?: NullableStringFieldUpdateOperationsInput | string | null
    transferTo?: NullableStringFieldUpdateOperationsInput | string | null
    originalValue?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    priceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    receivedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    customer?: CustomerUpdateOneRequiredWithoutLedgerEntriesNestedInput
    order?: OrderUpdateOneWithoutLedgerEntriesNestedInput
    postedByAdminUser?: AdminUserUpdateOneWithoutPostedLedgerEntriesNestedInput
  }

  export type LedgerEntryUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    currency?: EnumLedgerCurrencyFieldUpdateOperationsInput | $Enums.LedgerCurrency
    direction?: EnumLedgerDirectionFieldUpdateOperationsInput | $Enums.LedgerDirection
    sourceType?: EnumLedgerSourceTypeFieldUpdateOperationsInput | $Enums.LedgerSourceType
    amount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    karatPerMille?: NullableIntFieldUpdateOperationsInput | number | null
    pricePerGramRialAtEntry?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    orderId?: NullableStringFieldUpdateOperationsInput | string | null
    confirmed?: BoolFieldUpdateOperationsInput | boolean
    confirmedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    postedByAdminUserId?: NullableStringFieldUpdateOperationsInput | string | null
    labName?: NullableStringFieldUpdateOperationsInput | string | null
    hallmark?: NullableStringFieldUpdateOperationsInput | string | null
    accountName?: NullableStringFieldUpdateOperationsInput | string | null
    bankName?: NullableStringFieldUpdateOperationsInput | string | null
    transferTo?: NullableStringFieldUpdateOperationsInput | string | null
    originalValue?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    priceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    receivedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LedgerEntryCreateManyInput = {
    id?: string
    customerId: string
    currency: $Enums.LedgerCurrency
    direction: $Enums.LedgerDirection
    sourceType: $Enums.LedgerSourceType
    amount: Decimal | DecimalJsLike | number | string
    karatPerMille?: number | null
    pricePerGramRialAtEntry?: Decimal | DecimalJsLike | number | string | null
    orderId?: string | null
    confirmed?: boolean
    confirmedAt?: Date | string | null
    postedByAdminUserId?: string | null
    labName?: string | null
    hallmark?: string | null
    accountName?: string | null
    bankName?: string | null
    transferTo?: string | null
    originalValue?: Decimal | DecimalJsLike | number | string | null
    priceRial?: Decimal | DecimalJsLike | number | string | null
    receivedAt?: Date | string | null
    note?: string | null
    createdAt?: Date | string
  }

  export type LedgerEntryUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    currency?: EnumLedgerCurrencyFieldUpdateOperationsInput | $Enums.LedgerCurrency
    direction?: EnumLedgerDirectionFieldUpdateOperationsInput | $Enums.LedgerDirection
    sourceType?: EnumLedgerSourceTypeFieldUpdateOperationsInput | $Enums.LedgerSourceType
    amount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    karatPerMille?: NullableIntFieldUpdateOperationsInput | number | null
    pricePerGramRialAtEntry?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    confirmed?: BoolFieldUpdateOperationsInput | boolean
    confirmedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    labName?: NullableStringFieldUpdateOperationsInput | string | null
    hallmark?: NullableStringFieldUpdateOperationsInput | string | null
    accountName?: NullableStringFieldUpdateOperationsInput | string | null
    bankName?: NullableStringFieldUpdateOperationsInput | string | null
    transferTo?: NullableStringFieldUpdateOperationsInput | string | null
    originalValue?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    priceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    receivedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LedgerEntryUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    currency?: EnumLedgerCurrencyFieldUpdateOperationsInput | $Enums.LedgerCurrency
    direction?: EnumLedgerDirectionFieldUpdateOperationsInput | $Enums.LedgerDirection
    sourceType?: EnumLedgerSourceTypeFieldUpdateOperationsInput | $Enums.LedgerSourceType
    amount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    karatPerMille?: NullableIntFieldUpdateOperationsInput | number | null
    pricePerGramRialAtEntry?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    orderId?: NullableStringFieldUpdateOperationsInput | string | null
    confirmed?: BoolFieldUpdateOperationsInput | boolean
    confirmedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    postedByAdminUserId?: NullableStringFieldUpdateOperationsInput | string | null
    labName?: NullableStringFieldUpdateOperationsInput | string | null
    hallmark?: NullableStringFieldUpdateOperationsInput | string | null
    accountName?: NullableStringFieldUpdateOperationsInput | string | null
    bankName?: NullableStringFieldUpdateOperationsInput | string | null
    transferTo?: NullableStringFieldUpdateOperationsInput | string | null
    originalValue?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    priceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    receivedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type GoldPriceQuoteCreateInput = {
    id?: string
    karatPerMille: number
    pricePerGramRial: Decimal | DecimalJsLike | number | string
    source: string
    quotedAt?: Date | string
  }

  export type GoldPriceQuoteUncheckedCreateInput = {
    id?: string
    karatPerMille: number
    pricePerGramRial: Decimal | DecimalJsLike | number | string
    source: string
    quotedAt?: Date | string
  }

  export type GoldPriceQuoteUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    karatPerMille?: IntFieldUpdateOperationsInput | number
    pricePerGramRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    source?: StringFieldUpdateOperationsInput | string
    quotedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type GoldPriceQuoteUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    karatPerMille?: IntFieldUpdateOperationsInput | number
    pricePerGramRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    source?: StringFieldUpdateOperationsInput | string
    quotedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type GoldPriceQuoteCreateManyInput = {
    id?: string
    karatPerMille: number
    pricePerGramRial: Decimal | DecimalJsLike | number | string
    source: string
    quotedAt?: Date | string
  }

  export type GoldPriceQuoteUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    karatPerMille?: IntFieldUpdateOperationsInput | number
    pricePerGramRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    source?: StringFieldUpdateOperationsInput | string
    quotedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type GoldPriceQuoteUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    karatPerMille?: IntFieldUpdateOperationsInput | number
    pricePerGramRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    source?: StringFieldUpdateOperationsInput | string
    quotedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type WalletBonusCreateInput = {
    id?: string
    orderId?: string | null
    goldGrams: Decimal | DecimalJsLike | number | string
    grantedAt?: Date | string
    expiresAt: Date | string
    consumedAt?: Date | string | null
    isActive?: boolean
    customer: CustomerCreateNestedOneWithoutWalletBonusesInput
  }

  export type WalletBonusUncheckedCreateInput = {
    id?: string
    customerId: string
    orderId?: string | null
    goldGrams: Decimal | DecimalJsLike | number | string
    grantedAt?: Date | string
    expiresAt: Date | string
    consumedAt?: Date | string | null
    isActive?: boolean
  }

  export type WalletBonusUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderId?: NullableStringFieldUpdateOperationsInput | string | null
    goldGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    grantedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    consumedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    customer?: CustomerUpdateOneRequiredWithoutWalletBonusesNestedInput
  }

  export type WalletBonusUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    orderId?: NullableStringFieldUpdateOperationsInput | string | null
    goldGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    grantedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    consumedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
  }

  export type WalletBonusCreateManyInput = {
    id?: string
    customerId: string
    orderId?: string | null
    goldGrams: Decimal | DecimalJsLike | number | string
    grantedAt?: Date | string
    expiresAt: Date | string
    consumedAt?: Date | string | null
    isActive?: boolean
  }

  export type WalletBonusUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderId?: NullableStringFieldUpdateOperationsInput | string | null
    goldGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    grantedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    consumedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
  }

  export type WalletBonusUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    orderId?: NullableStringFieldUpdateOperationsInput | string | null
    goldGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    grantedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    consumedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
  }

  export type UserTypeCreateInput = {
    id: number
    title: string
    isActive?: boolean
    createdAt?: Date | string
    permissions?: PermissionCreateNestedManyWithoutUserTypeInput
    adminUsers?: AdminUserCreateNestedManyWithoutUserTypeInput
  }

  export type UserTypeUncheckedCreateInput = {
    id: number
    title: string
    isActive?: boolean
    createdAt?: Date | string
    permissions?: PermissionUncheckedCreateNestedManyWithoutUserTypeInput
    adminUsers?: AdminUserUncheckedCreateNestedManyWithoutUserTypeInput
  }

  export type UserTypeUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    permissions?: PermissionUpdateManyWithoutUserTypeNestedInput
    adminUsers?: AdminUserUpdateManyWithoutUserTypeNestedInput
  }

  export type UserTypeUncheckedUpdateInput = {
    id?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    permissions?: PermissionUncheckedUpdateManyWithoutUserTypeNestedInput
    adminUsers?: AdminUserUncheckedUpdateManyWithoutUserTypeNestedInput
  }

  export type UserTypeCreateManyInput = {
    id: number
    title: string
    isActive?: boolean
    createdAt?: Date | string
  }

  export type UserTypeUpdateManyMutationInput = {
    id?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UserTypeUncheckedUpdateManyInput = {
    id?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PermissionCreateInput = {
    rid: string
    userType: UserTypeCreateNestedOneWithoutPermissionsInput
  }

  export type PermissionUncheckedCreateInput = {
    rid: string
    userTypeId: number
  }

  export type PermissionUpdateInput = {
    rid?: StringFieldUpdateOperationsInput | string
    userType?: UserTypeUpdateOneRequiredWithoutPermissionsNestedInput
  }

  export type PermissionUncheckedUpdateInput = {
    rid?: StringFieldUpdateOperationsInput | string
    userTypeId?: IntFieldUpdateOperationsInput | number
  }

  export type PermissionCreateManyInput = {
    rid: string
    userTypeId: number
  }

  export type PermissionUpdateManyMutationInput = {
    rid?: StringFieldUpdateOperationsInput | string
  }

  export type PermissionUncheckedUpdateManyInput = {
    rid?: StringFieldUpdateOperationsInput | string
    userTypeId?: IntFieldUpdateOperationsInput | number
  }

  export type CommentCreateInput = {
    id?: string
    body: string
    status?: $Enums.CommentStatus
    createdAt?: Date | string
    updatedAt?: Date | string
    product: ProductCreateNestedOneWithoutCommentsInput
    customer: CustomerCreateNestedOneWithoutCommentsInput
    replyTo?: CommentCreateNestedOneWithoutRepliesInput
    replies?: CommentCreateNestedManyWithoutReplyToInput
  }

  export type CommentUncheckedCreateInput = {
    id?: string
    productId: string
    customerId: string
    body: string
    status?: $Enums.CommentStatus
    replyToId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    replies?: CommentUncheckedCreateNestedManyWithoutReplyToInput
  }

  export type CommentUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    body?: StringFieldUpdateOperationsInput | string
    status?: EnumCommentStatusFieldUpdateOperationsInput | $Enums.CommentStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    product?: ProductUpdateOneRequiredWithoutCommentsNestedInput
    customer?: CustomerUpdateOneRequiredWithoutCommentsNestedInput
    replyTo?: CommentUpdateOneWithoutRepliesNestedInput
    replies?: CommentUpdateManyWithoutReplyToNestedInput
  }

  export type CommentUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    productId?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    body?: StringFieldUpdateOperationsInput | string
    status?: EnumCommentStatusFieldUpdateOperationsInput | $Enums.CommentStatus
    replyToId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    replies?: CommentUncheckedUpdateManyWithoutReplyToNestedInput
  }

  export type CommentCreateManyInput = {
    id?: string
    productId: string
    customerId: string
    body: string
    status?: $Enums.CommentStatus
    replyToId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type CommentUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    body?: StringFieldUpdateOperationsInput | string
    status?: EnumCommentStatusFieldUpdateOperationsInput | $Enums.CommentStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CommentUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    productId?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    body?: StringFieldUpdateOperationsInput | string
    status?: EnumCommentStatusFieldUpdateOperationsInput | $Enums.CommentStatus
    replyToId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SettingCreateInput = {
    key: string
    value: JsonNullValueInput | InputJsonValue
    updatedAt?: Date | string
  }

  export type SettingUncheckedCreateInput = {
    key: string
    value: JsonNullValueInput | InputJsonValue
    updatedAt?: Date | string
  }

  export type SettingUpdateInput = {
    key?: StringFieldUpdateOperationsInput | string
    value?: JsonNullValueInput | InputJsonValue
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SettingUncheckedUpdateInput = {
    key?: StringFieldUpdateOperationsInput | string
    value?: JsonNullValueInput | InputJsonValue
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SettingCreateManyInput = {
    key: string
    value: JsonNullValueInput | InputJsonValue
    updatedAt?: Date | string
  }

  export type SettingUpdateManyMutationInput = {
    key?: StringFieldUpdateOperationsInput | string
    value?: JsonNullValueInput | InputJsonValue
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SettingUncheckedUpdateManyInput = {
    key?: StringFieldUpdateOperationsInput | string
    value?: JsonNullValueInput | InputJsonValue
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PromotionCreateInput = {
    id?: string
    title: string
    description?: string | null
    scope?: $Enums.PromotionScope
    usage?: $Enums.PromotionUsage
    discountPercent: Decimal | DecimalJsLike | number | string
    isActive?: boolean
    platform?: number
    startsAt?: Date | string | null
    endsAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    product?: ProductCreateNestedOneWithoutPromotionsInput
    category?: CategoryCreateNestedOneWithoutPromotionsInput
    customer?: CustomerCreateNestedOneWithoutPromotionsInput
    brand?: BrandCreateNestedOneWithoutPromotionsInput
  }

  export type PromotionUncheckedCreateInput = {
    id?: string
    title: string
    description?: string | null
    scope?: $Enums.PromotionScope
    usage?: $Enums.PromotionUsage
    discountPercent: Decimal | DecimalJsLike | number | string
    isActive?: boolean
    platform?: number
    startsAt?: Date | string | null
    endsAt?: Date | string | null
    productId?: string | null
    categoryId?: string | null
    customerId?: string | null
    brandId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type PromotionUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: EnumPromotionScopeFieldUpdateOperationsInput | $Enums.PromotionScope
    usage?: EnumPromotionUsageFieldUpdateOperationsInput | $Enums.PromotionUsage
    discountPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    platform?: IntFieldUpdateOperationsInput | number
    startsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    product?: ProductUpdateOneWithoutPromotionsNestedInput
    category?: CategoryUpdateOneWithoutPromotionsNestedInput
    customer?: CustomerUpdateOneWithoutPromotionsNestedInput
    brand?: BrandUpdateOneWithoutPromotionsNestedInput
  }

  export type PromotionUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: EnumPromotionScopeFieldUpdateOperationsInput | $Enums.PromotionScope
    usage?: EnumPromotionUsageFieldUpdateOperationsInput | $Enums.PromotionUsage
    discountPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    platform?: IntFieldUpdateOperationsInput | number
    startsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    productId?: NullableStringFieldUpdateOperationsInput | string | null
    categoryId?: NullableStringFieldUpdateOperationsInput | string | null
    customerId?: NullableStringFieldUpdateOperationsInput | string | null
    brandId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PromotionCreateManyInput = {
    id?: string
    title: string
    description?: string | null
    scope?: $Enums.PromotionScope
    usage?: $Enums.PromotionUsage
    discountPercent: Decimal | DecimalJsLike | number | string
    isActive?: boolean
    platform?: number
    startsAt?: Date | string | null
    endsAt?: Date | string | null
    productId?: string | null
    categoryId?: string | null
    customerId?: string | null
    brandId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type PromotionUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: EnumPromotionScopeFieldUpdateOperationsInput | $Enums.PromotionScope
    usage?: EnumPromotionUsageFieldUpdateOperationsInput | $Enums.PromotionUsage
    discountPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    platform?: IntFieldUpdateOperationsInput | number
    startsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PromotionUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: EnumPromotionScopeFieldUpdateOperationsInput | $Enums.PromotionScope
    usage?: EnumPromotionUsageFieldUpdateOperationsInput | $Enums.PromotionUsage
    discountPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    platform?: IntFieldUpdateOperationsInput | number
    startsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    productId?: NullableStringFieldUpdateOperationsInput | string | null
    categoryId?: NullableStringFieldUpdateOperationsInput | string | null
    customerId?: NullableStringFieldUpdateOperationsInput | string | null
    brandId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PromotionExclusionCreateInput = {
    id?: string
    type: number
    itemId: string
    createdAt?: Date | string
  }

  export type PromotionExclusionUncheckedCreateInput = {
    id?: string
    type: number
    itemId: string
    createdAt?: Date | string
  }

  export type PromotionExclusionUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: IntFieldUpdateOperationsInput | number
    itemId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PromotionExclusionUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: IntFieldUpdateOperationsInput | number
    itemId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PromotionExclusionCreateManyInput = {
    id?: string
    type: number
    itemId: string
    createdAt?: Date | string
  }

  export type PromotionExclusionUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: IntFieldUpdateOperationsInput | number
    itemId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PromotionExclusionUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    type?: IntFieldUpdateOperationsInput | number
    itemId?: StringFieldUpdateOperationsInput | string
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type BranchAllocationCreateInput = {
    id?: string
    note?: string | null
    createdAt?: Date | string
    branch: BranchCreateNestedOneWithoutAllocationsInput
    allocatorAdminUser?: AdminUserCreateNestedOneWithoutBranchAllocationsInput
    items?: BranchAllocationItemCreateNestedManyWithoutAllocationInput
  }

  export type BranchAllocationUncheckedCreateInput = {
    id?: string
    branchId: string
    allocatorAdminUserId?: string | null
    note?: string | null
    createdAt?: Date | string
    items?: BranchAllocationItemUncheckedCreateNestedManyWithoutAllocationInput
  }

  export type BranchAllocationUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    branch?: BranchUpdateOneRequiredWithoutAllocationsNestedInput
    allocatorAdminUser?: AdminUserUpdateOneWithoutBranchAllocationsNestedInput
    items?: BranchAllocationItemUpdateManyWithoutAllocationNestedInput
  }

  export type BranchAllocationUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    branchId?: StringFieldUpdateOperationsInput | string
    allocatorAdminUserId?: NullableStringFieldUpdateOperationsInput | string | null
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    items?: BranchAllocationItemUncheckedUpdateManyWithoutAllocationNestedInput
  }

  export type BranchAllocationCreateManyInput = {
    id?: string
    branchId: string
    allocatorAdminUserId?: string | null
    note?: string | null
    createdAt?: Date | string
  }

  export type BranchAllocationUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type BranchAllocationUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    branchId?: StringFieldUpdateOperationsInput | string
    allocatorAdminUserId?: NullableStringFieldUpdateOperationsInput | string | null
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type BranchAllocationItemCreateInput = {
    id?: string
    weightGrams?: Decimal | DecimalJsLike | number | string | null
    allocation: BranchAllocationCreateNestedOneWithoutItemsInput
    product: ProductCreateNestedOneWithoutAllocationItemsInput
  }

  export type BranchAllocationItemUncheckedCreateInput = {
    id?: string
    allocationId: string
    productId: string
    weightGrams?: Decimal | DecimalJsLike | number | string | null
  }

  export type BranchAllocationItemUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    weightGrams?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    allocation?: BranchAllocationUpdateOneRequiredWithoutItemsNestedInput
    product?: ProductUpdateOneRequiredWithoutAllocationItemsNestedInput
  }

  export type BranchAllocationItemUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    allocationId?: StringFieldUpdateOperationsInput | string
    productId?: StringFieldUpdateOperationsInput | string
    weightGrams?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
  }

  export type BranchAllocationItemCreateManyInput = {
    id?: string
    allocationId: string
    productId: string
    weightGrams?: Decimal | DecimalJsLike | number | string | null
  }

  export type BranchAllocationItemUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    weightGrams?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
  }

  export type BranchAllocationItemUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    allocationId?: StringFieldUpdateOperationsInput | string
    productId?: StringFieldUpdateOperationsInput | string
    weightGrams?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
  }

  export type SmsMessageCreateInput = {
    id?: string
    audience: $Enums.MessageAudience
    recipients?: string | null
    body: string
    sentCount?: number
    createdAt?: Date | string
    sentByAdminUser?: AdminUserCreateNestedOneWithoutSentSmsMessagesInput
  }

  export type SmsMessageUncheckedCreateInput = {
    id?: string
    audience: $Enums.MessageAudience
    recipients?: string | null
    body: string
    sentCount?: number
    sentByAdminUserId?: string | null
    createdAt?: Date | string
  }

  export type SmsMessageUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    audience?: EnumMessageAudienceFieldUpdateOperationsInput | $Enums.MessageAudience
    recipients?: NullableStringFieldUpdateOperationsInput | string | null
    body?: StringFieldUpdateOperationsInput | string
    sentCount?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    sentByAdminUser?: AdminUserUpdateOneWithoutSentSmsMessagesNestedInput
  }

  export type SmsMessageUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    audience?: EnumMessageAudienceFieldUpdateOperationsInput | $Enums.MessageAudience
    recipients?: NullableStringFieldUpdateOperationsInput | string | null
    body?: StringFieldUpdateOperationsInput | string
    sentCount?: IntFieldUpdateOperationsInput | number
    sentByAdminUserId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SmsMessageCreateManyInput = {
    id?: string
    audience: $Enums.MessageAudience
    recipients?: string | null
    body: string
    sentCount?: number
    sentByAdminUserId?: string | null
    createdAt?: Date | string
  }

  export type SmsMessageUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    audience?: EnumMessageAudienceFieldUpdateOperationsInput | $Enums.MessageAudience
    recipients?: NullableStringFieldUpdateOperationsInput | string | null
    body?: StringFieldUpdateOperationsInput | string
    sentCount?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SmsMessageUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    audience?: EnumMessageAudienceFieldUpdateOperationsInput | $Enums.MessageAudience
    recipients?: NullableStringFieldUpdateOperationsInput | string | null
    body?: StringFieldUpdateOperationsInput | string
    sentCount?: IntFieldUpdateOperationsInput | number
    sentByAdminUserId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type NotificationCreateInput = {
    id?: string
    title: string
    body: string
    audience?: $Enums.MessageAudience
    createdAt?: Date | string
    sentByAdminUser?: AdminUserCreateNestedOneWithoutSentNotificationsInput
    recipients?: NotificationRecipientCreateNestedManyWithoutNotificationInput
  }

  export type NotificationUncheckedCreateInput = {
    id?: string
    title: string
    body: string
    audience?: $Enums.MessageAudience
    sentByAdminUserId?: string | null
    createdAt?: Date | string
    recipients?: NotificationRecipientUncheckedCreateNestedManyWithoutNotificationInput
  }

  export type NotificationUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    body?: StringFieldUpdateOperationsInput | string
    audience?: EnumMessageAudienceFieldUpdateOperationsInput | $Enums.MessageAudience
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    sentByAdminUser?: AdminUserUpdateOneWithoutSentNotificationsNestedInput
    recipients?: NotificationRecipientUpdateManyWithoutNotificationNestedInput
  }

  export type NotificationUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    body?: StringFieldUpdateOperationsInput | string
    audience?: EnumMessageAudienceFieldUpdateOperationsInput | $Enums.MessageAudience
    sentByAdminUserId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    recipients?: NotificationRecipientUncheckedUpdateManyWithoutNotificationNestedInput
  }

  export type NotificationCreateManyInput = {
    id?: string
    title: string
    body: string
    audience?: $Enums.MessageAudience
    sentByAdminUserId?: string | null
    createdAt?: Date | string
  }

  export type NotificationUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    body?: StringFieldUpdateOperationsInput | string
    audience?: EnumMessageAudienceFieldUpdateOperationsInput | $Enums.MessageAudience
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type NotificationUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    body?: StringFieldUpdateOperationsInput | string
    audience?: EnumMessageAudienceFieldUpdateOperationsInput | $Enums.MessageAudience
    sentByAdminUserId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type NotificationRecipientCreateInput = {
    id?: string
    readAt?: Date | string | null
    notification: NotificationCreateNestedOneWithoutRecipientsInput
    customer: CustomerCreateNestedOneWithoutNotificationsInput
  }

  export type NotificationRecipientUncheckedCreateInput = {
    id?: string
    notificationId: string
    customerId: string
    readAt?: Date | string | null
  }

  export type NotificationRecipientUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    readAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    notification?: NotificationUpdateOneRequiredWithoutRecipientsNestedInput
    customer?: CustomerUpdateOneRequiredWithoutNotificationsNestedInput
  }

  export type NotificationRecipientUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    notificationId?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    readAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type NotificationRecipientCreateManyInput = {
    id?: string
    notificationId: string
    customerId: string
    readAt?: Date | string | null
  }

  export type NotificationRecipientUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    readAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type NotificationRecipientUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    notificationId?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    readAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type NewsletterSubscriberCreateInput = {
    id?: string
    email?: string | null
    mobile?: string | null
    createdAt?: Date | string
  }

  export type NewsletterSubscriberUncheckedCreateInput = {
    id?: string
    email?: string | null
    mobile?: string | null
    createdAt?: Date | string
  }

  export type NewsletterSubscriberUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type NewsletterSubscriberUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type NewsletterSubscriberCreateManyInput = {
    id?: string
    email?: string | null
    mobile?: string | null
    createdAt?: Date | string
  }

  export type NewsletterSubscriberUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type NewsletterSubscriberUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    email?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CustomerActivityLogCreateInput = {
    id?: string
    action: string
    detail?: string | null
    createdAt?: Date | string
    customer: CustomerCreateNestedOneWithoutActivityLogsInput
  }

  export type CustomerActivityLogUncheckedCreateInput = {
    id?: string
    customerId: string
    action: string
    detail?: string | null
    createdAt?: Date | string
  }

  export type CustomerActivityLogUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    action?: StringFieldUpdateOperationsInput | string
    detail?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    customer?: CustomerUpdateOneRequiredWithoutActivityLogsNestedInput
  }

  export type CustomerActivityLogUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    action?: StringFieldUpdateOperationsInput | string
    detail?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CustomerActivityLogCreateManyInput = {
    id?: string
    customerId: string
    action: string
    detail?: string | null
    createdAt?: Date | string
  }

  export type CustomerActivityLogUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    action?: StringFieldUpdateOperationsInput | string
    detail?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CustomerActivityLogUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    action?: StringFieldUpdateOperationsInput | string
    detail?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UploadedFileCreateInput = {
    id?: string
    url: string
    originalName: string
    mimeType: string
    sizeBytes: number
    purpose?: string | null
    createdAt?: Date | string
    uploadedByAdminUser?: AdminUserCreateNestedOneWithoutUploadedFilesInput
    customerAvatars?: CustomerCreateNestedManyWithoutAvatarFileInput
    adminUserAvatars?: AdminUserCreateNestedManyWithoutAvatarFileInput
  }

  export type UploadedFileUncheckedCreateInput = {
    id?: string
    url: string
    originalName: string
    mimeType: string
    sizeBytes: number
    purpose?: string | null
    uploadedByAdminUserId?: string | null
    createdAt?: Date | string
    customerAvatars?: CustomerUncheckedCreateNestedManyWithoutAvatarFileInput
    adminUserAvatars?: AdminUserUncheckedCreateNestedManyWithoutAvatarFileInput
  }

  export type UploadedFileUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    originalName?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
    sizeBytes?: IntFieldUpdateOperationsInput | number
    purpose?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    uploadedByAdminUser?: AdminUserUpdateOneWithoutUploadedFilesNestedInput
    customerAvatars?: CustomerUpdateManyWithoutAvatarFileNestedInput
    adminUserAvatars?: AdminUserUpdateManyWithoutAvatarFileNestedInput
  }

  export type UploadedFileUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    originalName?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
    sizeBytes?: IntFieldUpdateOperationsInput | number
    purpose?: NullableStringFieldUpdateOperationsInput | string | null
    uploadedByAdminUserId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    customerAvatars?: CustomerUncheckedUpdateManyWithoutAvatarFileNestedInput
    adminUserAvatars?: AdminUserUncheckedUpdateManyWithoutAvatarFileNestedInput
  }

  export type UploadedFileCreateManyInput = {
    id?: string
    url: string
    originalName: string
    mimeType: string
    sizeBytes: number
    purpose?: string | null
    uploadedByAdminUserId?: string | null
    createdAt?: Date | string
  }

  export type UploadedFileUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    originalName?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
    sizeBytes?: IntFieldUpdateOperationsInput | number
    purpose?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UploadedFileUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    originalName?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
    sizeBytes?: IntFieldUpdateOperationsInput | number
    purpose?: NullableStringFieldUpdateOperationsInput | string | null
    uploadedByAdminUserId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CustomerOtpCreateInput = {
    id?: string
    mobile: string
    codeHash: string
    expiresAt: Date | string
    attempts?: number
    consumedAt?: Date | string | null
    requestIp?: string | null
    createdAt?: Date | string
    customer: CustomerCreateNestedOneWithoutOtpChallengesInput
  }

  export type CustomerOtpUncheckedCreateInput = {
    id?: string
    mobile: string
    customerId: string
    codeHash: string
    expiresAt: Date | string
    attempts?: number
    consumedAt?: Date | string | null
    requestIp?: string | null
    createdAt?: Date | string
  }

  export type CustomerOtpUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    mobile?: StringFieldUpdateOperationsInput | string
    codeHash?: StringFieldUpdateOperationsInput | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    attempts?: IntFieldUpdateOperationsInput | number
    consumedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    requestIp?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    customer?: CustomerUpdateOneRequiredWithoutOtpChallengesNestedInput
  }

  export type CustomerOtpUncheckedUpdateInput = {
    id?: StringFieldUpdateOperationsInput | string
    mobile?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    codeHash?: StringFieldUpdateOperationsInput | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    attempts?: IntFieldUpdateOperationsInput | number
    consumedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    requestIp?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CustomerOtpCreateManyInput = {
    id?: string
    mobile: string
    customerId: string
    codeHash: string
    expiresAt: Date | string
    attempts?: number
    consumedAt?: Date | string | null
    requestIp?: string | null
    createdAt?: Date | string
  }

  export type CustomerOtpUpdateManyMutationInput = {
    id?: StringFieldUpdateOperationsInput | string
    mobile?: StringFieldUpdateOperationsInput | string
    codeHash?: StringFieldUpdateOperationsInput | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    attempts?: IntFieldUpdateOperationsInput | number
    consumedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    requestIp?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CustomerOtpUncheckedUpdateManyInput = {
    id?: StringFieldUpdateOperationsInput | string
    mobile?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    codeHash?: StringFieldUpdateOperationsInput | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    attempts?: IntFieldUpdateOperationsInput | number
    consumedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    requestIp?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type StringFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[] | ListStringFieldRefInput<$PrismaModel>
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    mode?: QueryMode
    not?: NestedStringFilter<$PrismaModel> | string
  }

  export type StringNullableFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    mode?: QueryMode
    not?: NestedStringNullableFilter<$PrismaModel> | string | null
  }

  export type DecimalNullableFilter<$PrismaModel = never> = {
    equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel> | null
    in?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel> | null
    notIn?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel> | null
    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?: NestedDecimalNullableFilter<$PrismaModel> | Decimal | DecimalJsLike | number | string | null
  }

  export type CustomerListRelationFilter = {
    every?: CustomerWhereInput
    some?: CustomerWhereInput
    none?: CustomerWhereInput
  }

  export type CustomerAddressListRelationFilter = {
    every?: CustomerAddressWhereInput
    some?: CustomerAddressWhereInput
    none?: CustomerAddressWhereInput
  }

  export type BranchListRelationFilter = {
    every?: BranchWhereInput
    some?: BranchWhereInput
    none?: BranchWhereInput
  }

  export type PreOrderListRelationFilter = {
    every?: PreOrderWhereInput
    some?: PreOrderWhereInput
    none?: PreOrderWhereInput
  }

  export type SalesExpertProfileListRelationFilter = {
    every?: SalesExpertProfileWhereInput
    some?: SalesExpertProfileWhereInput
    none?: SalesExpertProfileWhereInput
  }

  export type SortOrderInput = {
    sort: SortOrder
    nulls?: NullsOrder
  }

  export type CustomerOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type CustomerAddressOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type BranchOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type PreOrderOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type SalesExpertProfileOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type CityCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    province?: SortOrder
    percent?: SortOrder
    percentAux?: SortOrder
  }

  export type CityAvgOrderByAggregateInput = {
    percent?: SortOrder
    percentAux?: SortOrder
  }

  export type CityMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    province?: SortOrder
    percent?: SortOrder
    percentAux?: SortOrder
  }

  export type CityMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    province?: SortOrder
    percent?: SortOrder
    percentAux?: SortOrder
  }

  export type CitySumOrderByAggregateInput = {
    percent?: SortOrder
    percentAux?: SortOrder
  }

  export type StringWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[] | ListStringFieldRefInput<$PrismaModel>
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    mode?: QueryMode
    not?: NestedStringWithAggregatesFilter<$PrismaModel> | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedStringFilter<$PrismaModel>
    _max?: NestedStringFilter<$PrismaModel>
  }

  export type StringNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    mode?: QueryMode
    not?: NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedStringNullableFilter<$PrismaModel>
    _max?: NestedStringNullableFilter<$PrismaModel>
  }

  export type DecimalNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel> | null
    in?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel> | null
    notIn?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel> | null
    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?: NestedDecimalNullableWithAggregatesFilter<$PrismaModel> | Decimal | DecimalJsLike | number | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedDecimalNullableFilter<$PrismaModel>
    _sum?: NestedDecimalNullableFilter<$PrismaModel>
    _min?: NestedDecimalNullableFilter<$PrismaModel>
    _max?: NestedDecimalNullableFilter<$PrismaModel>
  }

  export type EnumAdminRoleFilter<$PrismaModel = never> = {
    equals?: $Enums.AdminRole | EnumAdminRoleFieldRefInput<$PrismaModel>
    in?: $Enums.AdminRole[] | ListEnumAdminRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.AdminRole[] | ListEnumAdminRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumAdminRoleFilter<$PrismaModel> | $Enums.AdminRole
  }

  export type IntNullableFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableFilter<$PrismaModel> | number | null
  }

  export type BoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  export type DateTimeFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeFilter<$PrismaModel> | Date | string
  }

  export type UserTypeNullableRelationFilter = {
    is?: UserTypeWhereInput | null
    isNot?: UserTypeWhereInput | null
  }

  export type BranchNullableRelationFilter = {
    is?: BranchWhereInput | null
    isNot?: BranchWhereInput | null
  }

  export type UploadedFileNullableRelationFilter = {
    is?: UploadedFileWhereInput | null
    isNot?: UploadedFileWhereInput | null
  }

  export type WorkshopListRelationFilter = {
    every?: WorkshopWhereInput
    some?: WorkshopWhereInput
    none?: WorkshopWhereInput
  }

  export type BranchAllocationListRelationFilter = {
    every?: BranchAllocationWhereInput
    some?: BranchAllocationWhereInput
    none?: BranchAllocationWhereInput
  }

  export type LedgerEntryListRelationFilter = {
    every?: LedgerEntryWhereInput
    some?: LedgerEntryWhereInput
    none?: LedgerEntryWhereInput
  }

  export type OrderStatusEventListRelationFilter = {
    every?: OrderStatusEventWhereInput
    some?: OrderStatusEventWhereInput
    none?: OrderStatusEventWhereInput
  }

  export type PreOrderStatusEventListRelationFilter = {
    every?: PreOrderStatusEventWhereInput
    some?: PreOrderStatusEventWhereInput
    none?: PreOrderStatusEventWhereInput
  }

  export type SmsMessageListRelationFilter = {
    every?: SmsMessageWhereInput
    some?: SmsMessageWhereInput
    none?: SmsMessageWhereInput
  }

  export type NotificationListRelationFilter = {
    every?: NotificationWhereInput
    some?: NotificationWhereInput
    none?: NotificationWhereInput
  }

  export type UploadedFileListRelationFilter = {
    every?: UploadedFileWhereInput
    some?: UploadedFileWhereInput
    none?: UploadedFileWhereInput
  }

  export type SalesExpertProfileNullableRelationFilter = {
    is?: SalesExpertProfileWhereInput | null
    isNot?: SalesExpertProfileWhereInput | null
  }

  export type AdminSessionListRelationFilter = {
    every?: AdminSessionWhereInput
    some?: AdminSessionWhereInput
    none?: AdminSessionWhereInput
  }

  export type WorkshopOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type BranchAllocationOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type LedgerEntryOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type OrderStatusEventOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type PreOrderStatusEventOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type SmsMessageOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type NotificationOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type UploadedFileOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type AdminSessionOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type AdminUserCountOrderByAggregateInput = {
    id?: SortOrder
    fullName?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    mobile?: SortOrder
    passwordHash?: SortOrder
    role?: SortOrder
    userTypeId?: SortOrder
    branchId?: SortOrder
    wagePercent?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    avatarFileId?: SortOrder
    address?: SortOrder
    storeName?: SortOrder
    pasazhName?: SortOrder
    memberCode?: SortOrder
  }

  export type AdminUserAvgOrderByAggregateInput = {
    userTypeId?: SortOrder
    wagePercent?: SortOrder
  }

  export type AdminUserMaxOrderByAggregateInput = {
    id?: SortOrder
    fullName?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    mobile?: SortOrder
    passwordHash?: SortOrder
    role?: SortOrder
    userTypeId?: SortOrder
    branchId?: SortOrder
    wagePercent?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    avatarFileId?: SortOrder
    address?: SortOrder
    storeName?: SortOrder
    pasazhName?: SortOrder
    memberCode?: SortOrder
  }

  export type AdminUserMinOrderByAggregateInput = {
    id?: SortOrder
    fullName?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    mobile?: SortOrder
    passwordHash?: SortOrder
    role?: SortOrder
    userTypeId?: SortOrder
    branchId?: SortOrder
    wagePercent?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
    avatarFileId?: SortOrder
    address?: SortOrder
    storeName?: SortOrder
    pasazhName?: SortOrder
    memberCode?: SortOrder
  }

  export type AdminUserSumOrderByAggregateInput = {
    userTypeId?: SortOrder
    wagePercent?: SortOrder
  }

  export type EnumAdminRoleWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.AdminRole | EnumAdminRoleFieldRefInput<$PrismaModel>
    in?: $Enums.AdminRole[] | ListEnumAdminRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.AdminRole[] | ListEnumAdminRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumAdminRoleWithAggregatesFilter<$PrismaModel> | $Enums.AdminRole
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumAdminRoleFilter<$PrismaModel>
    _max?: NestedEnumAdminRoleFilter<$PrismaModel>
  }

  export type IntNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableWithAggregatesFilter<$PrismaModel> | number | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedFloatNullableFilter<$PrismaModel>
    _sum?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedIntNullableFilter<$PrismaModel>
    _max?: NestedIntNullableFilter<$PrismaModel>
  }

  export type BoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$PrismaModel>
  }

  export type DateTimeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedDateTimeFilter<$PrismaModel>
    _max?: NestedDateTimeFilter<$PrismaModel>
  }

  export type DateTimeNullableFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeNullableFilter<$PrismaModel> | Date | string | null
  }

  export type AppSessionCountOrderByAggregateInput = {
    id?: SortOrder
    jti?: SortOrder
    subjectId?: SortOrder
    subjectType?: SortOrder
    mobile?: SortOrder
    iamSessionId?: SortOrder
    iamSub?: SortOrder
    ipAddress?: SortOrder
    userAgent?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
    lastSeenAt?: SortOrder
    revokedAt?: SortOrder
    revokedReason?: SortOrder
  }

  export type AppSessionMaxOrderByAggregateInput = {
    id?: SortOrder
    jti?: SortOrder
    subjectId?: SortOrder
    subjectType?: SortOrder
    mobile?: SortOrder
    iamSessionId?: SortOrder
    iamSub?: SortOrder
    ipAddress?: SortOrder
    userAgent?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
    lastSeenAt?: SortOrder
    revokedAt?: SortOrder
    revokedReason?: SortOrder
  }

  export type AppSessionMinOrderByAggregateInput = {
    id?: SortOrder
    jti?: SortOrder
    subjectId?: SortOrder
    subjectType?: SortOrder
    mobile?: SortOrder
    iamSessionId?: SortOrder
    iamSub?: SortOrder
    ipAddress?: SortOrder
    userAgent?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
    lastSeenAt?: SortOrder
    revokedAt?: SortOrder
    revokedReason?: SortOrder
  }

  export type DateTimeNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeNullableWithAggregatesFilter<$PrismaModel> | Date | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedDateTimeNullableFilter<$PrismaModel>
    _max?: NestedDateTimeNullableFilter<$PrismaModel>
  }

  export type AdminUserRelationFilter = {
    is?: AdminUserWhereInput
    isNot?: AdminUserWhereInput
  }

  export type AdminSessionCountOrderByAggregateInput = {
    id?: SortOrder
    jti?: SortOrder
    adminUserId?: SortOrder
    iamSessionId?: SortOrder
    iamSub?: SortOrder
    ipAddress?: SortOrder
    userAgent?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
    lastSeenAt?: SortOrder
    revokedAt?: SortOrder
    revokedReason?: SortOrder
  }

  export type AdminSessionMaxOrderByAggregateInput = {
    id?: SortOrder
    jti?: SortOrder
    adminUserId?: SortOrder
    iamSessionId?: SortOrder
    iamSub?: SortOrder
    ipAddress?: SortOrder
    userAgent?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
    lastSeenAt?: SortOrder
    revokedAt?: SortOrder
    revokedReason?: SortOrder
  }

  export type AdminSessionMinOrderByAggregateInput = {
    id?: SortOrder
    jti?: SortOrder
    adminUserId?: SortOrder
    iamSessionId?: SortOrder
    iamSub?: SortOrder
    ipAddress?: SortOrder
    userAgent?: SortOrder
    createdAt?: SortOrder
    expiresAt?: SortOrder
    lastSeenAt?: SortOrder
    revokedAt?: SortOrder
    revokedReason?: SortOrder
  }

  export type DecimalFilter<$PrismaModel = never> = {
    equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    in?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel>
    notIn?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel>
    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 CityNullableRelationFilter = {
    is?: CityWhereInput | null
    isNot?: CityWhereInput | null
  }

  export type CustomerNullableRelationFilter = {
    is?: CustomerWhereInput | null
    isNot?: CustomerWhereInput | null
  }

  export type SalesExpertProfileCountOrderByAggregateInput = {
    id?: SortOrder
    adminUserId?: SortOrder
    cityId?: SortOrder
    gramLevel?: SortOrder
    phone?: SortOrder
    nationalCode?: SortOrder
    tradingCustomerId?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type SalesExpertProfileAvgOrderByAggregateInput = {
    gramLevel?: SortOrder
  }

  export type SalesExpertProfileMaxOrderByAggregateInput = {
    id?: SortOrder
    adminUserId?: SortOrder
    cityId?: SortOrder
    gramLevel?: SortOrder
    phone?: SortOrder
    nationalCode?: SortOrder
    tradingCustomerId?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type SalesExpertProfileMinOrderByAggregateInput = {
    id?: SortOrder
    adminUserId?: SortOrder
    cityId?: SortOrder
    gramLevel?: SortOrder
    phone?: SortOrder
    nationalCode?: SortOrder
    tradingCustomerId?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type SalesExpertProfileSumOrderByAggregateInput = {
    gramLevel?: SortOrder
  }

  export type DecimalWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    in?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel>
    notIn?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel>
    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 EnumCustomerKindFilter<$PrismaModel = never> = {
    equals?: $Enums.CustomerKind | EnumCustomerKindFieldRefInput<$PrismaModel>
    in?: $Enums.CustomerKind[] | ListEnumCustomerKindFieldRefInput<$PrismaModel>
    notIn?: $Enums.CustomerKind[] | ListEnumCustomerKindFieldRefInput<$PrismaModel>
    not?: NestedEnumCustomerKindFilter<$PrismaModel> | $Enums.CustomerKind
  }

  export type EnumVerificationStepFilter<$PrismaModel = never> = {
    equals?: $Enums.VerificationStep | EnumVerificationStepFieldRefInput<$PrismaModel>
    in?: $Enums.VerificationStep[] | ListEnumVerificationStepFieldRefInput<$PrismaModel>
    notIn?: $Enums.VerificationStep[] | ListEnumVerificationStepFieldRefInput<$PrismaModel>
    not?: NestedEnumVerificationStepFilter<$PrismaModel> | $Enums.VerificationStep
  }

  export type AdminUserNullableRelationFilter = {
    is?: AdminUserWhereInput | null
    isNot?: AdminUserWhereInput | null
  }

  export type OrderListRelationFilter = {
    every?: OrderWhereInput
    some?: OrderWhereInput
    none?: OrderWhereInput
  }

  export type WalletBonusListRelationFilter = {
    every?: WalletBonusWhereInput
    some?: WalletBonusWhereInput
    none?: WalletBonusWhereInput
  }

  export type CommentListRelationFilter = {
    every?: CommentWhereInput
    some?: CommentWhereInput
    none?: CommentWhereInput
  }

  export type PromotionListRelationFilter = {
    every?: PromotionWhereInput
    some?: PromotionWhereInput
    none?: PromotionWhereInput
  }

  export type NotificationRecipientListRelationFilter = {
    every?: NotificationRecipientWhereInput
    some?: NotificationRecipientWhereInput
    none?: NotificationRecipientWhereInput
  }

  export type CustomerActivityLogListRelationFilter = {
    every?: CustomerActivityLogWhereInput
    some?: CustomerActivityLogWhereInput
    none?: CustomerActivityLogWhereInput
  }

  export type CustomerOtpListRelationFilter = {
    every?: CustomerOtpWhereInput
    some?: CustomerOtpWhereInput
    none?: CustomerOtpWhereInput
  }

  export type OrderOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type WalletBonusOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type CommentOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type PromotionOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type NotificationRecipientOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type CustomerActivityLogOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type CustomerOtpOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type CustomerCountOrderByAggregateInput = {
    id?: SortOrder
    fullName?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    mobile?: SortOrder
    nationalCode?: SortOrder
    passwordHash?: SortOrder
    cityId?: SortOrder
    kind?: SortOrder
    phone?: SortOrder
    address?: SortOrder
    storeName?: SortOrder
    pasazhName?: SortOrder
    zone?: SortOrder
    memberCode?: SortOrder
    referredByAgentId?: SortOrder
    goldCreditLimitGrams?: SortOrder
    goldDebtGrams?: SortOrder
    fiatDebtRial?: SortOrder
    makingChargeOffsetPercent?: SortOrder
    verificationStep?: SortOrder
    nationalIdImageUrl?: SortOrder
    businessLicenseUrl?: SortOrder
    shopImageUrl?: SortOrder
    avatarFileId?: SortOrder
    canPlaceOrders?: SortOrder
    isActive?: SortOrder
    isArchived?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type CustomerAvgOrderByAggregateInput = {
    goldCreditLimitGrams?: SortOrder
    goldDebtGrams?: SortOrder
    fiatDebtRial?: SortOrder
    makingChargeOffsetPercent?: SortOrder
  }

  export type CustomerMaxOrderByAggregateInput = {
    id?: SortOrder
    fullName?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    mobile?: SortOrder
    nationalCode?: SortOrder
    passwordHash?: SortOrder
    cityId?: SortOrder
    kind?: SortOrder
    phone?: SortOrder
    address?: SortOrder
    storeName?: SortOrder
    pasazhName?: SortOrder
    zone?: SortOrder
    memberCode?: SortOrder
    referredByAgentId?: SortOrder
    goldCreditLimitGrams?: SortOrder
    goldDebtGrams?: SortOrder
    fiatDebtRial?: SortOrder
    makingChargeOffsetPercent?: SortOrder
    verificationStep?: SortOrder
    nationalIdImageUrl?: SortOrder
    businessLicenseUrl?: SortOrder
    shopImageUrl?: SortOrder
    avatarFileId?: SortOrder
    canPlaceOrders?: SortOrder
    isActive?: SortOrder
    isArchived?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type CustomerMinOrderByAggregateInput = {
    id?: SortOrder
    fullName?: SortOrder
    firstName?: SortOrder
    lastName?: SortOrder
    mobile?: SortOrder
    nationalCode?: SortOrder
    passwordHash?: SortOrder
    cityId?: SortOrder
    kind?: SortOrder
    phone?: SortOrder
    address?: SortOrder
    storeName?: SortOrder
    pasazhName?: SortOrder
    zone?: SortOrder
    memberCode?: SortOrder
    referredByAgentId?: SortOrder
    goldCreditLimitGrams?: SortOrder
    goldDebtGrams?: SortOrder
    fiatDebtRial?: SortOrder
    makingChargeOffsetPercent?: SortOrder
    verificationStep?: SortOrder
    nationalIdImageUrl?: SortOrder
    businessLicenseUrl?: SortOrder
    shopImageUrl?: SortOrder
    avatarFileId?: SortOrder
    canPlaceOrders?: SortOrder
    isActive?: SortOrder
    isArchived?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type CustomerSumOrderByAggregateInput = {
    goldCreditLimitGrams?: SortOrder
    goldDebtGrams?: SortOrder
    fiatDebtRial?: SortOrder
    makingChargeOffsetPercent?: SortOrder
  }

  export type EnumCustomerKindWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.CustomerKind | EnumCustomerKindFieldRefInput<$PrismaModel>
    in?: $Enums.CustomerKind[] | ListEnumCustomerKindFieldRefInput<$PrismaModel>
    notIn?: $Enums.CustomerKind[] | ListEnumCustomerKindFieldRefInput<$PrismaModel>
    not?: NestedEnumCustomerKindWithAggregatesFilter<$PrismaModel> | $Enums.CustomerKind
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumCustomerKindFilter<$PrismaModel>
    _max?: NestedEnumCustomerKindFilter<$PrismaModel>
  }

  export type EnumVerificationStepWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.VerificationStep | EnumVerificationStepFieldRefInput<$PrismaModel>
    in?: $Enums.VerificationStep[] | ListEnumVerificationStepFieldRefInput<$PrismaModel>
    notIn?: $Enums.VerificationStep[] | ListEnumVerificationStepFieldRefInput<$PrismaModel>
    not?: NestedEnumVerificationStepWithAggregatesFilter<$PrismaModel> | $Enums.VerificationStep
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumVerificationStepFilter<$PrismaModel>
    _max?: NestedEnumVerificationStepFilter<$PrismaModel>
  }

  export type CustomerRelationFilter = {
    is?: CustomerWhereInput
    isNot?: CustomerWhereInput
  }

  export type CustomerAddressCountOrderByAggregateInput = {
    id?: SortOrder
    customerId?: SortOrder
    cityId?: SortOrder
    addressLine?: SortOrder
    isDefault?: SortOrder
  }

  export type CustomerAddressMaxOrderByAggregateInput = {
    id?: SortOrder
    customerId?: SortOrder
    cityId?: SortOrder
    addressLine?: SortOrder
    isDefault?: SortOrder
  }

  export type CustomerAddressMinOrderByAggregateInput = {
    id?: SortOrder
    customerId?: SortOrder
    cityId?: SortOrder
    addressLine?: SortOrder
    isDefault?: SortOrder
  }

  export type AdminUserListRelationFilter = {
    every?: AdminUserWhereInput
    some?: AdminUserWhereInput
    none?: AdminUserWhereInput
  }

  export type AdminUserOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type BranchCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    address?: SortOrder
    phone?: SortOrder
    isActive?: SortOrder
    cityId?: SortOrder
  }

  export type BranchMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    address?: SortOrder
    phone?: SortOrder
    isActive?: SortOrder
    cityId?: SortOrder
  }

  export type BranchMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    address?: SortOrder
    phone?: SortOrder
    isActive?: SortOrder
    cityId?: SortOrder
  }

  export type WorkshopCountOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    address?: SortOrder
    phone?: SortOrder
    supervisorId?: SortOrder
    isActive?: SortOrder
  }

  export type WorkshopMaxOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    address?: SortOrder
    phone?: SortOrder
    supervisorId?: SortOrder
    isActive?: SortOrder
  }

  export type WorkshopMinOrderByAggregateInput = {
    id?: SortOrder
    name?: SortOrder
    address?: SortOrder
    phone?: SortOrder
    supervisorId?: SortOrder
    isActive?: SortOrder
  }

  export type IntFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[] | ListIntFieldRefInput<$PrismaModel>
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel>
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntFilter<$PrismaModel> | number
  }

  export type CategoryNullableRelationFilter = {
    is?: CategoryWhereInput | null
    isNot?: CategoryWhereInput | null
  }

  export type CategoryListRelationFilter = {
    every?: CategoryWhereInput
    some?: CategoryWhereInput
    none?: CategoryWhereInput
  }

  export type ProductListRelationFilter = {
    every?: ProductWhereInput
    some?: ProductWhereInput
    none?: ProductWhereInput
  }

  export type CategoryOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ProductOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type CategoryCountOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    type?: SortOrder
    imageUrl?: SortOrder
    iconUrl?: SortOrder
    metaTag?: SortOrder
    description?: SortOrder
    parentId?: SortOrder
  }

  export type CategoryAvgOrderByAggregateInput = {
    type?: SortOrder
  }

  export type CategoryMaxOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    type?: SortOrder
    imageUrl?: SortOrder
    iconUrl?: SortOrder
    metaTag?: SortOrder
    description?: SortOrder
    parentId?: SortOrder
  }

  export type CategoryMinOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    type?: SortOrder
    imageUrl?: SortOrder
    iconUrl?: SortOrder
    metaTag?: SortOrder
    description?: SortOrder
    parentId?: SortOrder
  }

  export type CategorySumOrderByAggregateInput = {
    type?: SortOrder
  }

  export type IntWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[] | ListIntFieldRefInput<$PrismaModel>
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel>
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntWithAggregatesFilter<$PrismaModel> | number
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedFloatFilter<$PrismaModel>
    _sum?: NestedIntFilter<$PrismaModel>
    _min?: NestedIntFilter<$PrismaModel>
    _max?: NestedIntFilter<$PrismaModel>
  }

  export type BrandCountOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
  }

  export type BrandMaxOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
  }

  export type BrandMinOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
  }

  export type CollectionProductListRelationFilter = {
    every?: CollectionProductWhereInput
    some?: CollectionProductWhereInput
    none?: CollectionProductWhereInput
  }

  export type CollectionProductOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type CollectionCountOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    description?: SortOrder
    isActive?: SortOrder
  }

  export type CollectionMaxOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    description?: SortOrder
    isActive?: SortOrder
  }

  export type CollectionMinOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    description?: SortOrder
    isActive?: SortOrder
  }

  export type CollectionRelationFilter = {
    is?: CollectionWhereInput
    isNot?: CollectionWhereInput
  }

  export type ProductRelationFilter = {
    is?: ProductWhereInput
    isNot?: ProductWhereInput
  }

  export type CollectionProductCollectionIdProductIdCompoundUniqueInput = {
    collectionId: string
    productId: string
  }

  export type CollectionProductCountOrderByAggregateInput = {
    collectionId?: SortOrder
    productId?: SortOrder
  }

  export type CollectionProductMaxOrderByAggregateInput = {
    collectionId?: SortOrder
    productId?: SortOrder
  }

  export type CollectionProductMinOrderByAggregateInput = {
    collectionId?: SortOrder
    productId?: SortOrder
  }

  export type BrandNullableRelationFilter = {
    is?: BrandWhereInput | null
    isNot?: BrandWhereInput | null
  }

  export type ProductVariantListRelationFilter = {
    every?: ProductVariantWhereInput
    some?: ProductVariantWhereInput
    none?: ProductVariantWhereInput
  }

  export type ProductImageListRelationFilter = {
    every?: ProductImageWhereInput
    some?: ProductImageWhereInput
    none?: ProductImageWhereInput
  }

  export type BranchAllocationItemListRelationFilter = {
    every?: BranchAllocationItemWhereInput
    some?: BranchAllocationItemWhereInput
    none?: BranchAllocationItemWhereInput
  }

  export type ProductVariantOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ProductImageOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type BranchAllocationItemOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ProductCountOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    description?: SortOrder
    categoryId?: SortOrder
    brandId?: SortOrder
    productCode?: SortOrder
    showType?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
  }

  export type ProductAvgOrderByAggregateInput = {
    showType?: SortOrder
  }

  export type ProductMaxOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    description?: SortOrder
    categoryId?: SortOrder
    brandId?: SortOrder
    productCode?: SortOrder
    showType?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
  }

  export type ProductMinOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    description?: SortOrder
    categoryId?: SortOrder
    brandId?: SortOrder
    productCode?: SortOrder
    showType?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
  }

  export type ProductSumOrderByAggregateInput = {
    showType?: SortOrder
  }

  export type EnumProductImageRoleFilter<$PrismaModel = never> = {
    equals?: $Enums.ProductImageRole | EnumProductImageRoleFieldRefInput<$PrismaModel>
    in?: $Enums.ProductImageRole[] | ListEnumProductImageRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.ProductImageRole[] | ListEnumProductImageRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumProductImageRoleFilter<$PrismaModel> | $Enums.ProductImageRole
  }

  export type ProductImageCountOrderByAggregateInput = {
    id?: SortOrder
    productId?: SortOrder
    url?: SortOrder
    sortOrder?: SortOrder
    role?: SortOrder
  }

  export type ProductImageAvgOrderByAggregateInput = {
    sortOrder?: SortOrder
  }

  export type ProductImageMaxOrderByAggregateInput = {
    id?: SortOrder
    productId?: SortOrder
    url?: SortOrder
    sortOrder?: SortOrder
    role?: SortOrder
  }

  export type ProductImageMinOrderByAggregateInput = {
    id?: SortOrder
    productId?: SortOrder
    url?: SortOrder
    sortOrder?: SortOrder
    role?: SortOrder
  }

  export type ProductImageSumOrderByAggregateInput = {
    sortOrder?: SortOrder
  }

  export type EnumProductImageRoleWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.ProductImageRole | EnumProductImageRoleFieldRefInput<$PrismaModel>
    in?: $Enums.ProductImageRole[] | ListEnumProductImageRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.ProductImageRole[] | ListEnumProductImageRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumProductImageRoleWithAggregatesFilter<$PrismaModel> | $Enums.ProductImageRole
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumProductImageRoleFilter<$PrismaModel>
    _max?: NestedEnumProductImageRoleFilter<$PrismaModel>
  }

  export type ProductImageNullableRelationFilter = {
    is?: ProductImageWhereInput | null
    isNot?: ProductImageWhereInput | null
  }

  export type OrderItemListRelationFilter = {
    every?: OrderItemWhereInput
    some?: OrderItemWhereInput
    none?: OrderItemWhereInput
  }

  export type OrderItemOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type ProductVariantCountOrderByAggregateInput = {
    id?: SortOrder
    productId?: SortOrder
    title?: SortOrder
    sku?: SortOrder
    rashWeightGrams?: SortOrder
    defaultWagePercent?: SortOrder
    qty?: SortOrder
    isPreOrder?: SortOrder
    isActive?: SortOrder
    imageId?: SortOrder
  }

  export type ProductVariantAvgOrderByAggregateInput = {
    rashWeightGrams?: SortOrder
    defaultWagePercent?: SortOrder
    qty?: SortOrder
  }

  export type ProductVariantMaxOrderByAggregateInput = {
    id?: SortOrder
    productId?: SortOrder
    title?: SortOrder
    sku?: SortOrder
    rashWeightGrams?: SortOrder
    defaultWagePercent?: SortOrder
    qty?: SortOrder
    isPreOrder?: SortOrder
    isActive?: SortOrder
    imageId?: SortOrder
  }

  export type ProductVariantMinOrderByAggregateInput = {
    id?: SortOrder
    productId?: SortOrder
    title?: SortOrder
    sku?: SortOrder
    rashWeightGrams?: SortOrder
    defaultWagePercent?: SortOrder
    qty?: SortOrder
    isPreOrder?: SortOrder
    isActive?: SortOrder
    imageId?: SortOrder
  }

  export type ProductVariantSumOrderByAggregateInput = {
    rashWeightGrams?: SortOrder
    defaultWagePercent?: SortOrder
    qty?: SortOrder
  }

  export type EnumOrderChannelFilter<$PrismaModel = never> = {
    equals?: $Enums.OrderChannel | EnumOrderChannelFieldRefInput<$PrismaModel>
    in?: $Enums.OrderChannel[] | ListEnumOrderChannelFieldRefInput<$PrismaModel>
    notIn?: $Enums.OrderChannel[] | ListEnumOrderChannelFieldRefInput<$PrismaModel>
    not?: NestedEnumOrderChannelFilter<$PrismaModel> | $Enums.OrderChannel
  }

  export type EnumOrderStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.OrderStatus | EnumOrderStatusFieldRefInput<$PrismaModel>
    in?: $Enums.OrderStatus[] | ListEnumOrderStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.OrderStatus[] | ListEnumOrderStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumOrderStatusFilter<$PrismaModel> | $Enums.OrderStatus
  }

  export type PreOrderNullableRelationFilter = {
    is?: PreOrderWhereInput | null
    isNot?: PreOrderWhereInput | null
  }

  export type OrderCountOrderByAggregateInput = {
    id?: SortOrder
    orderNumber?: SortOrder
    customerId?: SortOrder
    branchId?: SortOrder
    channel?: SortOrder
    status?: SortOrder
    totalGoldWeightGrams?: SortOrder
    wageWeightGrams?: SortOrder
    flatRialCharge?: SortOrder
    isSuspendedOverCreditLimit?: SortOrder
    deliveredAt?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type OrderAvgOrderByAggregateInput = {
    totalGoldWeightGrams?: SortOrder
    wageWeightGrams?: SortOrder
    flatRialCharge?: SortOrder
  }

  export type OrderMaxOrderByAggregateInput = {
    id?: SortOrder
    orderNumber?: SortOrder
    customerId?: SortOrder
    branchId?: SortOrder
    channel?: SortOrder
    status?: SortOrder
    totalGoldWeightGrams?: SortOrder
    wageWeightGrams?: SortOrder
    flatRialCharge?: SortOrder
    isSuspendedOverCreditLimit?: SortOrder
    deliveredAt?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type OrderMinOrderByAggregateInput = {
    id?: SortOrder
    orderNumber?: SortOrder
    customerId?: SortOrder
    branchId?: SortOrder
    channel?: SortOrder
    status?: SortOrder
    totalGoldWeightGrams?: SortOrder
    wageWeightGrams?: SortOrder
    flatRialCharge?: SortOrder
    isSuspendedOverCreditLimit?: SortOrder
    deliveredAt?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type OrderSumOrderByAggregateInput = {
    totalGoldWeightGrams?: SortOrder
    wageWeightGrams?: SortOrder
    flatRialCharge?: SortOrder
  }

  export type EnumOrderChannelWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.OrderChannel | EnumOrderChannelFieldRefInput<$PrismaModel>
    in?: $Enums.OrderChannel[] | ListEnumOrderChannelFieldRefInput<$PrismaModel>
    notIn?: $Enums.OrderChannel[] | ListEnumOrderChannelFieldRefInput<$PrismaModel>
    not?: NestedEnumOrderChannelWithAggregatesFilter<$PrismaModel> | $Enums.OrderChannel
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumOrderChannelFilter<$PrismaModel>
    _max?: NestedEnumOrderChannelFilter<$PrismaModel>
  }

  export type EnumOrderStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.OrderStatus | EnumOrderStatusFieldRefInput<$PrismaModel>
    in?: $Enums.OrderStatus[] | ListEnumOrderStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.OrderStatus[] | ListEnumOrderStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumOrderStatusWithAggregatesFilter<$PrismaModel> | $Enums.OrderStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumOrderStatusFilter<$PrismaModel>
    _max?: NestedEnumOrderStatusFilter<$PrismaModel>
  }

  export type OrderRelationFilter = {
    is?: OrderWhereInput
    isNot?: OrderWhereInput
  }

  export type ProductVariantRelationFilter = {
    is?: ProductVariantWhereInput
    isNot?: ProductVariantWhereInput
  }

  export type OrderItemCountOrderByAggregateInput = {
    id?: SortOrder
    orderId?: SortOrder
    productVariantId?: SortOrder
    quantity?: SortOrder
    rashWeightGramsSnapshot?: SortOrder
    wagePercentSnapshot?: SortOrder
    discountPercentSnapshot?: SortOrder
    computedWeightGrams?: SortOrder
    flatRialCharge?: SortOrder
  }

  export type OrderItemAvgOrderByAggregateInput = {
    quantity?: SortOrder
    rashWeightGramsSnapshot?: SortOrder
    wagePercentSnapshot?: SortOrder
    discountPercentSnapshot?: SortOrder
    computedWeightGrams?: SortOrder
    flatRialCharge?: SortOrder
  }

  export type OrderItemMaxOrderByAggregateInput = {
    id?: SortOrder
    orderId?: SortOrder
    productVariantId?: SortOrder
    quantity?: SortOrder
    rashWeightGramsSnapshot?: SortOrder
    wagePercentSnapshot?: SortOrder
    discountPercentSnapshot?: SortOrder
    computedWeightGrams?: SortOrder
    flatRialCharge?: SortOrder
  }

  export type OrderItemMinOrderByAggregateInput = {
    id?: SortOrder
    orderId?: SortOrder
    productVariantId?: SortOrder
    quantity?: SortOrder
    rashWeightGramsSnapshot?: SortOrder
    wagePercentSnapshot?: SortOrder
    discountPercentSnapshot?: SortOrder
    computedWeightGrams?: SortOrder
    flatRialCharge?: SortOrder
  }

  export type OrderItemSumOrderByAggregateInput = {
    quantity?: SortOrder
    rashWeightGramsSnapshot?: SortOrder
    wagePercentSnapshot?: SortOrder
    discountPercentSnapshot?: SortOrder
    computedWeightGrams?: SortOrder
    flatRialCharge?: SortOrder
  }

  export type EnumOrderStatusNullableFilter<$PrismaModel = never> = {
    equals?: $Enums.OrderStatus | EnumOrderStatusFieldRefInput<$PrismaModel> | null
    in?: $Enums.OrderStatus[] | ListEnumOrderStatusFieldRefInput<$PrismaModel> | null
    notIn?: $Enums.OrderStatus[] | ListEnumOrderStatusFieldRefInput<$PrismaModel> | null
    not?: NestedEnumOrderStatusNullableFilter<$PrismaModel> | $Enums.OrderStatus | null
  }

  export type OrderStatusEventCountOrderByAggregateInput = {
    id?: SortOrder
    orderId?: SortOrder
    fromStatus?: SortOrder
    toStatus?: SortOrder
    note?: SortOrder
    actorAdminUserId?: SortOrder
    createdAt?: SortOrder
  }

  export type OrderStatusEventMaxOrderByAggregateInput = {
    id?: SortOrder
    orderId?: SortOrder
    fromStatus?: SortOrder
    toStatus?: SortOrder
    note?: SortOrder
    actorAdminUserId?: SortOrder
    createdAt?: SortOrder
  }

  export type OrderStatusEventMinOrderByAggregateInput = {
    id?: SortOrder
    orderId?: SortOrder
    fromStatus?: SortOrder
    toStatus?: SortOrder
    note?: SortOrder
    actorAdminUserId?: SortOrder
    createdAt?: SortOrder
  }

  export type EnumOrderStatusNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.OrderStatus | EnumOrderStatusFieldRefInput<$PrismaModel> | null
    in?: $Enums.OrderStatus[] | ListEnumOrderStatusFieldRefInput<$PrismaModel> | null
    notIn?: $Enums.OrderStatus[] | ListEnumOrderStatusFieldRefInput<$PrismaModel> | null
    not?: NestedEnumOrderStatusNullableWithAggregatesFilter<$PrismaModel> | $Enums.OrderStatus | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedEnumOrderStatusNullableFilter<$PrismaModel>
    _max?: NestedEnumOrderStatusNullableFilter<$PrismaModel>
  }

  export type EnumPreOrderStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.PreOrderStatus | EnumPreOrderStatusFieldRefInput<$PrismaModel>
    in?: $Enums.PreOrderStatus[] | ListEnumPreOrderStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.PreOrderStatus[] | ListEnumPreOrderStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumPreOrderStatusFilter<$PrismaModel> | $Enums.PreOrderStatus
  }

  export type WorkshopNullableRelationFilter = {
    is?: WorkshopWhereInput | null
    isNot?: WorkshopWhereInput | null
  }

  export type OrderNullableRelationFilter = {
    is?: OrderWhereInput | null
    isNot?: OrderWhereInput | null
  }

  export type PreOrderCountOrderByAggregateInput = {
    id?: SortOrder
    customerId?: SortOrder
    cityId?: SortOrder
    workshopId?: SortOrder
    status?: SortOrder
    designImageUrl?: SortOrder
    colorName?: SortOrder
    sizeSpec?: SortOrder
    stoneColor?: SortOrder
    minaColor?: SortOrder
    estimatedWeightGrams?: SortOrder
    estimatedPriceRial?: SortOrder
    description?: SortOrder
    convertedOrderId?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type PreOrderAvgOrderByAggregateInput = {
    estimatedWeightGrams?: SortOrder
    estimatedPriceRial?: SortOrder
  }

  export type PreOrderMaxOrderByAggregateInput = {
    id?: SortOrder
    customerId?: SortOrder
    cityId?: SortOrder
    workshopId?: SortOrder
    status?: SortOrder
    designImageUrl?: SortOrder
    colorName?: SortOrder
    sizeSpec?: SortOrder
    stoneColor?: SortOrder
    minaColor?: SortOrder
    estimatedWeightGrams?: SortOrder
    estimatedPriceRial?: SortOrder
    description?: SortOrder
    convertedOrderId?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type PreOrderMinOrderByAggregateInput = {
    id?: SortOrder
    customerId?: SortOrder
    cityId?: SortOrder
    workshopId?: SortOrder
    status?: SortOrder
    designImageUrl?: SortOrder
    colorName?: SortOrder
    sizeSpec?: SortOrder
    stoneColor?: SortOrder
    minaColor?: SortOrder
    estimatedWeightGrams?: SortOrder
    estimatedPriceRial?: SortOrder
    description?: SortOrder
    convertedOrderId?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type PreOrderSumOrderByAggregateInput = {
    estimatedWeightGrams?: SortOrder
    estimatedPriceRial?: SortOrder
  }

  export type EnumPreOrderStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.PreOrderStatus | EnumPreOrderStatusFieldRefInput<$PrismaModel>
    in?: $Enums.PreOrderStatus[] | ListEnumPreOrderStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.PreOrderStatus[] | ListEnumPreOrderStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumPreOrderStatusWithAggregatesFilter<$PrismaModel> | $Enums.PreOrderStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumPreOrderStatusFilter<$PrismaModel>
    _max?: NestedEnumPreOrderStatusFilter<$PrismaModel>
  }
  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 | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
  }

  export type PreOrderRelationFilter = {
    is?: PreOrderWhereInput
    isNot?: PreOrderWhereInput
  }

  export type PreOrderStatusEventCountOrderByAggregateInput = {
    id?: SortOrder
    preOrderId?: SortOrder
    changes?: SortOrder
    actorAdminUserId?: SortOrder
    ipAddress?: SortOrder
    createdAt?: SortOrder
  }

  export type PreOrderStatusEventMaxOrderByAggregateInput = {
    id?: SortOrder
    preOrderId?: SortOrder
    actorAdminUserId?: SortOrder
    ipAddress?: SortOrder
    createdAt?: SortOrder
  }

  export type PreOrderStatusEventMinOrderByAggregateInput = {
    id?: SortOrder
    preOrderId?: SortOrder
    actorAdminUserId?: SortOrder
    ipAddress?: SortOrder
    createdAt?: SortOrder
  }
  export type JsonWithAggregatesFilter<$PrismaModel = never> = 
    | PatchUndefined<
        Either<Required<JsonWithAggregatesFilterBase<$PrismaModel>>, Exclude<keyof Required<JsonWithAggregatesFilterBase<$PrismaModel>>, 'path'>>,
        Required<JsonWithAggregatesFilterBase<$PrismaModel>>
      >
    | OptionalFlat<Omit<Required<JsonWithAggregatesFilterBase<$PrismaModel>>, 'path'>>

  export type JsonWithAggregatesFilterBase<$PrismaModel = never> = {
    equals?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    path?: string[]
    string_contains?: string | StringFieldRefInput<$PrismaModel>
    string_starts_with?: string | StringFieldRefInput<$PrismaModel>
    string_ends_with?: string | StringFieldRefInput<$PrismaModel>
    array_contains?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_starts_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    array_ends_with?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | null
    lt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedJsonFilter<$PrismaModel>
    _max?: NestedJsonFilter<$PrismaModel>
  }

  export type EnumLedgerCurrencyFilter<$PrismaModel = never> = {
    equals?: $Enums.LedgerCurrency | EnumLedgerCurrencyFieldRefInput<$PrismaModel>
    in?: $Enums.LedgerCurrency[] | ListEnumLedgerCurrencyFieldRefInput<$PrismaModel>
    notIn?: $Enums.LedgerCurrency[] | ListEnumLedgerCurrencyFieldRefInput<$PrismaModel>
    not?: NestedEnumLedgerCurrencyFilter<$PrismaModel> | $Enums.LedgerCurrency
  }

  export type EnumLedgerDirectionFilter<$PrismaModel = never> = {
    equals?: $Enums.LedgerDirection | EnumLedgerDirectionFieldRefInput<$PrismaModel>
    in?: $Enums.LedgerDirection[] | ListEnumLedgerDirectionFieldRefInput<$PrismaModel>
    notIn?: $Enums.LedgerDirection[] | ListEnumLedgerDirectionFieldRefInput<$PrismaModel>
    not?: NestedEnumLedgerDirectionFilter<$PrismaModel> | $Enums.LedgerDirection
  }

  export type EnumLedgerSourceTypeFilter<$PrismaModel = never> = {
    equals?: $Enums.LedgerSourceType | EnumLedgerSourceTypeFieldRefInput<$PrismaModel>
    in?: $Enums.LedgerSourceType[] | ListEnumLedgerSourceTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.LedgerSourceType[] | ListEnumLedgerSourceTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumLedgerSourceTypeFilter<$PrismaModel> | $Enums.LedgerSourceType
  }

  export type LedgerEntryCountOrderByAggregateInput = {
    id?: SortOrder
    customerId?: SortOrder
    currency?: SortOrder
    direction?: SortOrder
    sourceType?: SortOrder
    amount?: SortOrder
    karatPerMille?: SortOrder
    pricePerGramRialAtEntry?: SortOrder
    orderId?: SortOrder
    confirmed?: SortOrder
    confirmedAt?: SortOrder
    postedByAdminUserId?: SortOrder
    labName?: SortOrder
    hallmark?: SortOrder
    accountName?: SortOrder
    bankName?: SortOrder
    transferTo?: SortOrder
    originalValue?: SortOrder
    priceRial?: SortOrder
    receivedAt?: SortOrder
    note?: SortOrder
    createdAt?: SortOrder
  }

  export type LedgerEntryAvgOrderByAggregateInput = {
    amount?: SortOrder
    karatPerMille?: SortOrder
    pricePerGramRialAtEntry?: SortOrder
    originalValue?: SortOrder
    priceRial?: SortOrder
  }

  export type LedgerEntryMaxOrderByAggregateInput = {
    id?: SortOrder
    customerId?: SortOrder
    currency?: SortOrder
    direction?: SortOrder
    sourceType?: SortOrder
    amount?: SortOrder
    karatPerMille?: SortOrder
    pricePerGramRialAtEntry?: SortOrder
    orderId?: SortOrder
    confirmed?: SortOrder
    confirmedAt?: SortOrder
    postedByAdminUserId?: SortOrder
    labName?: SortOrder
    hallmark?: SortOrder
    accountName?: SortOrder
    bankName?: SortOrder
    transferTo?: SortOrder
    originalValue?: SortOrder
    priceRial?: SortOrder
    receivedAt?: SortOrder
    note?: SortOrder
    createdAt?: SortOrder
  }

  export type LedgerEntryMinOrderByAggregateInput = {
    id?: SortOrder
    customerId?: SortOrder
    currency?: SortOrder
    direction?: SortOrder
    sourceType?: SortOrder
    amount?: SortOrder
    karatPerMille?: SortOrder
    pricePerGramRialAtEntry?: SortOrder
    orderId?: SortOrder
    confirmed?: SortOrder
    confirmedAt?: SortOrder
    postedByAdminUserId?: SortOrder
    labName?: SortOrder
    hallmark?: SortOrder
    accountName?: SortOrder
    bankName?: SortOrder
    transferTo?: SortOrder
    originalValue?: SortOrder
    priceRial?: SortOrder
    receivedAt?: SortOrder
    note?: SortOrder
    createdAt?: SortOrder
  }

  export type LedgerEntrySumOrderByAggregateInput = {
    amount?: SortOrder
    karatPerMille?: SortOrder
    pricePerGramRialAtEntry?: SortOrder
    originalValue?: SortOrder
    priceRial?: SortOrder
  }

  export type EnumLedgerCurrencyWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.LedgerCurrency | EnumLedgerCurrencyFieldRefInput<$PrismaModel>
    in?: $Enums.LedgerCurrency[] | ListEnumLedgerCurrencyFieldRefInput<$PrismaModel>
    notIn?: $Enums.LedgerCurrency[] | ListEnumLedgerCurrencyFieldRefInput<$PrismaModel>
    not?: NestedEnumLedgerCurrencyWithAggregatesFilter<$PrismaModel> | $Enums.LedgerCurrency
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumLedgerCurrencyFilter<$PrismaModel>
    _max?: NestedEnumLedgerCurrencyFilter<$PrismaModel>
  }

  export type EnumLedgerDirectionWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.LedgerDirection | EnumLedgerDirectionFieldRefInput<$PrismaModel>
    in?: $Enums.LedgerDirection[] | ListEnumLedgerDirectionFieldRefInput<$PrismaModel>
    notIn?: $Enums.LedgerDirection[] | ListEnumLedgerDirectionFieldRefInput<$PrismaModel>
    not?: NestedEnumLedgerDirectionWithAggregatesFilter<$PrismaModel> | $Enums.LedgerDirection
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumLedgerDirectionFilter<$PrismaModel>
    _max?: NestedEnumLedgerDirectionFilter<$PrismaModel>
  }

  export type EnumLedgerSourceTypeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.LedgerSourceType | EnumLedgerSourceTypeFieldRefInput<$PrismaModel>
    in?: $Enums.LedgerSourceType[] | ListEnumLedgerSourceTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.LedgerSourceType[] | ListEnumLedgerSourceTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumLedgerSourceTypeWithAggregatesFilter<$PrismaModel> | $Enums.LedgerSourceType
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumLedgerSourceTypeFilter<$PrismaModel>
    _max?: NestedEnumLedgerSourceTypeFilter<$PrismaModel>
  }

  export type GoldPriceQuoteCountOrderByAggregateInput = {
    id?: SortOrder
    karatPerMille?: SortOrder
    pricePerGramRial?: SortOrder
    source?: SortOrder
    quotedAt?: SortOrder
  }

  export type GoldPriceQuoteAvgOrderByAggregateInput = {
    karatPerMille?: SortOrder
    pricePerGramRial?: SortOrder
  }

  export type GoldPriceQuoteMaxOrderByAggregateInput = {
    id?: SortOrder
    karatPerMille?: SortOrder
    pricePerGramRial?: SortOrder
    source?: SortOrder
    quotedAt?: SortOrder
  }

  export type GoldPriceQuoteMinOrderByAggregateInput = {
    id?: SortOrder
    karatPerMille?: SortOrder
    pricePerGramRial?: SortOrder
    source?: SortOrder
    quotedAt?: SortOrder
  }

  export type GoldPriceQuoteSumOrderByAggregateInput = {
    karatPerMille?: SortOrder
    pricePerGramRial?: SortOrder
  }

  export type WalletBonusCountOrderByAggregateInput = {
    id?: SortOrder
    customerId?: SortOrder
    orderId?: SortOrder
    goldGrams?: SortOrder
    grantedAt?: SortOrder
    expiresAt?: SortOrder
    consumedAt?: SortOrder
    isActive?: SortOrder
  }

  export type WalletBonusAvgOrderByAggregateInput = {
    goldGrams?: SortOrder
  }

  export type WalletBonusMaxOrderByAggregateInput = {
    id?: SortOrder
    customerId?: SortOrder
    orderId?: SortOrder
    goldGrams?: SortOrder
    grantedAt?: SortOrder
    expiresAt?: SortOrder
    consumedAt?: SortOrder
    isActive?: SortOrder
  }

  export type WalletBonusMinOrderByAggregateInput = {
    id?: SortOrder
    customerId?: SortOrder
    orderId?: SortOrder
    goldGrams?: SortOrder
    grantedAt?: SortOrder
    expiresAt?: SortOrder
    consumedAt?: SortOrder
    isActive?: SortOrder
  }

  export type WalletBonusSumOrderByAggregateInput = {
    goldGrams?: SortOrder
  }

  export type PermissionListRelationFilter = {
    every?: PermissionWhereInput
    some?: PermissionWhereInput
    none?: PermissionWhereInput
  }

  export type PermissionOrderByRelationAggregateInput = {
    _count?: SortOrder
  }

  export type UserTypeCountOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
  }

  export type UserTypeAvgOrderByAggregateInput = {
    id?: SortOrder
  }

  export type UserTypeMaxOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
  }

  export type UserTypeMinOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    isActive?: SortOrder
    createdAt?: SortOrder
  }

  export type UserTypeSumOrderByAggregateInput = {
    id?: SortOrder
  }

  export type UserTypeRelationFilter = {
    is?: UserTypeWhereInput
    isNot?: UserTypeWhereInput
  }

  export type PermissionRidUserTypeIdCompoundUniqueInput = {
    rid: string
    userTypeId: number
  }

  export type PermissionCountOrderByAggregateInput = {
    rid?: SortOrder
    userTypeId?: SortOrder
  }

  export type PermissionAvgOrderByAggregateInput = {
    userTypeId?: SortOrder
  }

  export type PermissionMaxOrderByAggregateInput = {
    rid?: SortOrder
    userTypeId?: SortOrder
  }

  export type PermissionMinOrderByAggregateInput = {
    rid?: SortOrder
    userTypeId?: SortOrder
  }

  export type PermissionSumOrderByAggregateInput = {
    userTypeId?: SortOrder
  }

  export type EnumCommentStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.CommentStatus | EnumCommentStatusFieldRefInput<$PrismaModel>
    in?: $Enums.CommentStatus[] | ListEnumCommentStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.CommentStatus[] | ListEnumCommentStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumCommentStatusFilter<$PrismaModel> | $Enums.CommentStatus
  }

  export type CommentNullableRelationFilter = {
    is?: CommentWhereInput | null
    isNot?: CommentWhereInput | null
  }

  export type CommentCountOrderByAggregateInput = {
    id?: SortOrder
    productId?: SortOrder
    customerId?: SortOrder
    body?: SortOrder
    status?: SortOrder
    replyToId?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type CommentMaxOrderByAggregateInput = {
    id?: SortOrder
    productId?: SortOrder
    customerId?: SortOrder
    body?: SortOrder
    status?: SortOrder
    replyToId?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type CommentMinOrderByAggregateInput = {
    id?: SortOrder
    productId?: SortOrder
    customerId?: SortOrder
    body?: SortOrder
    status?: SortOrder
    replyToId?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type EnumCommentStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.CommentStatus | EnumCommentStatusFieldRefInput<$PrismaModel>
    in?: $Enums.CommentStatus[] | ListEnumCommentStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.CommentStatus[] | ListEnumCommentStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumCommentStatusWithAggregatesFilter<$PrismaModel> | $Enums.CommentStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumCommentStatusFilter<$PrismaModel>
    _max?: NestedEnumCommentStatusFilter<$PrismaModel>
  }

  export type SettingCountOrderByAggregateInput = {
    key?: SortOrder
    value?: SortOrder
    updatedAt?: SortOrder
  }

  export type SettingMaxOrderByAggregateInput = {
    key?: SortOrder
    updatedAt?: SortOrder
  }

  export type SettingMinOrderByAggregateInput = {
    key?: SortOrder
    updatedAt?: SortOrder
  }

  export type EnumPromotionScopeFilter<$PrismaModel = never> = {
    equals?: $Enums.PromotionScope | EnumPromotionScopeFieldRefInput<$PrismaModel>
    in?: $Enums.PromotionScope[] | ListEnumPromotionScopeFieldRefInput<$PrismaModel>
    notIn?: $Enums.PromotionScope[] | ListEnumPromotionScopeFieldRefInput<$PrismaModel>
    not?: NestedEnumPromotionScopeFilter<$PrismaModel> | $Enums.PromotionScope
  }

  export type EnumPromotionUsageFilter<$PrismaModel = never> = {
    equals?: $Enums.PromotionUsage | EnumPromotionUsageFieldRefInput<$PrismaModel>
    in?: $Enums.PromotionUsage[] | ListEnumPromotionUsageFieldRefInput<$PrismaModel>
    notIn?: $Enums.PromotionUsage[] | ListEnumPromotionUsageFieldRefInput<$PrismaModel>
    not?: NestedEnumPromotionUsageFilter<$PrismaModel> | $Enums.PromotionUsage
  }

  export type ProductNullableRelationFilter = {
    is?: ProductWhereInput | null
    isNot?: ProductWhereInput | null
  }

  export type PromotionCountOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    description?: SortOrder
    scope?: SortOrder
    usage?: SortOrder
    discountPercent?: SortOrder
    isActive?: SortOrder
    platform?: SortOrder
    startsAt?: SortOrder
    endsAt?: SortOrder
    productId?: SortOrder
    categoryId?: SortOrder
    customerId?: SortOrder
    brandId?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type PromotionAvgOrderByAggregateInput = {
    discountPercent?: SortOrder
    platform?: SortOrder
  }

  export type PromotionMaxOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    description?: SortOrder
    scope?: SortOrder
    usage?: SortOrder
    discountPercent?: SortOrder
    isActive?: SortOrder
    platform?: SortOrder
    startsAt?: SortOrder
    endsAt?: SortOrder
    productId?: SortOrder
    categoryId?: SortOrder
    customerId?: SortOrder
    brandId?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type PromotionMinOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    description?: SortOrder
    scope?: SortOrder
    usage?: SortOrder
    discountPercent?: SortOrder
    isActive?: SortOrder
    platform?: SortOrder
    startsAt?: SortOrder
    endsAt?: SortOrder
    productId?: SortOrder
    categoryId?: SortOrder
    customerId?: SortOrder
    brandId?: SortOrder
    createdAt?: SortOrder
    updatedAt?: SortOrder
  }

  export type PromotionSumOrderByAggregateInput = {
    discountPercent?: SortOrder
    platform?: SortOrder
  }

  export type EnumPromotionScopeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.PromotionScope | EnumPromotionScopeFieldRefInput<$PrismaModel>
    in?: $Enums.PromotionScope[] | ListEnumPromotionScopeFieldRefInput<$PrismaModel>
    notIn?: $Enums.PromotionScope[] | ListEnumPromotionScopeFieldRefInput<$PrismaModel>
    not?: NestedEnumPromotionScopeWithAggregatesFilter<$PrismaModel> | $Enums.PromotionScope
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumPromotionScopeFilter<$PrismaModel>
    _max?: NestedEnumPromotionScopeFilter<$PrismaModel>
  }

  export type EnumPromotionUsageWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.PromotionUsage | EnumPromotionUsageFieldRefInput<$PrismaModel>
    in?: $Enums.PromotionUsage[] | ListEnumPromotionUsageFieldRefInput<$PrismaModel>
    notIn?: $Enums.PromotionUsage[] | ListEnumPromotionUsageFieldRefInput<$PrismaModel>
    not?: NestedEnumPromotionUsageWithAggregatesFilter<$PrismaModel> | $Enums.PromotionUsage
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumPromotionUsageFilter<$PrismaModel>
    _max?: NestedEnumPromotionUsageFilter<$PrismaModel>
  }

  export type PromotionExclusionTypeItemIdCompoundUniqueInput = {
    type: number
    itemId: string
  }

  export type PromotionExclusionCountOrderByAggregateInput = {
    id?: SortOrder
    type?: SortOrder
    itemId?: SortOrder
    createdAt?: SortOrder
  }

  export type PromotionExclusionAvgOrderByAggregateInput = {
    type?: SortOrder
  }

  export type PromotionExclusionMaxOrderByAggregateInput = {
    id?: SortOrder
    type?: SortOrder
    itemId?: SortOrder
    createdAt?: SortOrder
  }

  export type PromotionExclusionMinOrderByAggregateInput = {
    id?: SortOrder
    type?: SortOrder
    itemId?: SortOrder
    createdAt?: SortOrder
  }

  export type PromotionExclusionSumOrderByAggregateInput = {
    type?: SortOrder
  }

  export type BranchRelationFilter = {
    is?: BranchWhereInput
    isNot?: BranchWhereInput
  }

  export type BranchAllocationCountOrderByAggregateInput = {
    id?: SortOrder
    branchId?: SortOrder
    allocatorAdminUserId?: SortOrder
    note?: SortOrder
    createdAt?: SortOrder
  }

  export type BranchAllocationMaxOrderByAggregateInput = {
    id?: SortOrder
    branchId?: SortOrder
    allocatorAdminUserId?: SortOrder
    note?: SortOrder
    createdAt?: SortOrder
  }

  export type BranchAllocationMinOrderByAggregateInput = {
    id?: SortOrder
    branchId?: SortOrder
    allocatorAdminUserId?: SortOrder
    note?: SortOrder
    createdAt?: SortOrder
  }

  export type BranchAllocationRelationFilter = {
    is?: BranchAllocationWhereInput
    isNot?: BranchAllocationWhereInput
  }

  export type BranchAllocationItemAllocationIdProductIdCompoundUniqueInput = {
    allocationId: string
    productId: string
  }

  export type BranchAllocationItemCountOrderByAggregateInput = {
    id?: SortOrder
    allocationId?: SortOrder
    productId?: SortOrder
    weightGrams?: SortOrder
  }

  export type BranchAllocationItemAvgOrderByAggregateInput = {
    weightGrams?: SortOrder
  }

  export type BranchAllocationItemMaxOrderByAggregateInput = {
    id?: SortOrder
    allocationId?: SortOrder
    productId?: SortOrder
    weightGrams?: SortOrder
  }

  export type BranchAllocationItemMinOrderByAggregateInput = {
    id?: SortOrder
    allocationId?: SortOrder
    productId?: SortOrder
    weightGrams?: SortOrder
  }

  export type BranchAllocationItemSumOrderByAggregateInput = {
    weightGrams?: SortOrder
  }

  export type EnumMessageAudienceFilter<$PrismaModel = never> = {
    equals?: $Enums.MessageAudience | EnumMessageAudienceFieldRefInput<$PrismaModel>
    in?: $Enums.MessageAudience[] | ListEnumMessageAudienceFieldRefInput<$PrismaModel>
    notIn?: $Enums.MessageAudience[] | ListEnumMessageAudienceFieldRefInput<$PrismaModel>
    not?: NestedEnumMessageAudienceFilter<$PrismaModel> | $Enums.MessageAudience
  }

  export type SmsMessageCountOrderByAggregateInput = {
    id?: SortOrder
    audience?: SortOrder
    recipients?: SortOrder
    body?: SortOrder
    sentCount?: SortOrder
    sentByAdminUserId?: SortOrder
    createdAt?: SortOrder
  }

  export type SmsMessageAvgOrderByAggregateInput = {
    sentCount?: SortOrder
  }

  export type SmsMessageMaxOrderByAggregateInput = {
    id?: SortOrder
    audience?: SortOrder
    recipients?: SortOrder
    body?: SortOrder
    sentCount?: SortOrder
    sentByAdminUserId?: SortOrder
    createdAt?: SortOrder
  }

  export type SmsMessageMinOrderByAggregateInput = {
    id?: SortOrder
    audience?: SortOrder
    recipients?: SortOrder
    body?: SortOrder
    sentCount?: SortOrder
    sentByAdminUserId?: SortOrder
    createdAt?: SortOrder
  }

  export type SmsMessageSumOrderByAggregateInput = {
    sentCount?: SortOrder
  }

  export type EnumMessageAudienceWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.MessageAudience | EnumMessageAudienceFieldRefInput<$PrismaModel>
    in?: $Enums.MessageAudience[] | ListEnumMessageAudienceFieldRefInput<$PrismaModel>
    notIn?: $Enums.MessageAudience[] | ListEnumMessageAudienceFieldRefInput<$PrismaModel>
    not?: NestedEnumMessageAudienceWithAggregatesFilter<$PrismaModel> | $Enums.MessageAudience
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumMessageAudienceFilter<$PrismaModel>
    _max?: NestedEnumMessageAudienceFilter<$PrismaModel>
  }

  export type NotificationCountOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    body?: SortOrder
    audience?: SortOrder
    sentByAdminUserId?: SortOrder
    createdAt?: SortOrder
  }

  export type NotificationMaxOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    body?: SortOrder
    audience?: SortOrder
    sentByAdminUserId?: SortOrder
    createdAt?: SortOrder
  }

  export type NotificationMinOrderByAggregateInput = {
    id?: SortOrder
    title?: SortOrder
    body?: SortOrder
    audience?: SortOrder
    sentByAdminUserId?: SortOrder
    createdAt?: SortOrder
  }

  export type NotificationRelationFilter = {
    is?: NotificationWhereInput
    isNot?: NotificationWhereInput
  }

  export type NotificationRecipientNotificationIdCustomerIdCompoundUniqueInput = {
    notificationId: string
    customerId: string
  }

  export type NotificationRecipientCountOrderByAggregateInput = {
    id?: SortOrder
    notificationId?: SortOrder
    customerId?: SortOrder
    readAt?: SortOrder
  }

  export type NotificationRecipientMaxOrderByAggregateInput = {
    id?: SortOrder
    notificationId?: SortOrder
    customerId?: SortOrder
    readAt?: SortOrder
  }

  export type NotificationRecipientMinOrderByAggregateInput = {
    id?: SortOrder
    notificationId?: SortOrder
    customerId?: SortOrder
    readAt?: SortOrder
  }

  export type NewsletterSubscriberCountOrderByAggregateInput = {
    id?: SortOrder
    email?: SortOrder
    mobile?: SortOrder
    createdAt?: SortOrder
  }

  export type NewsletterSubscriberMaxOrderByAggregateInput = {
    id?: SortOrder
    email?: SortOrder
    mobile?: SortOrder
    createdAt?: SortOrder
  }

  export type NewsletterSubscriberMinOrderByAggregateInput = {
    id?: SortOrder
    email?: SortOrder
    mobile?: SortOrder
    createdAt?: SortOrder
  }

  export type CustomerActivityLogCountOrderByAggregateInput = {
    id?: SortOrder
    customerId?: SortOrder
    action?: SortOrder
    detail?: SortOrder
    createdAt?: SortOrder
  }

  export type CustomerActivityLogMaxOrderByAggregateInput = {
    id?: SortOrder
    customerId?: SortOrder
    action?: SortOrder
    detail?: SortOrder
    createdAt?: SortOrder
  }

  export type CustomerActivityLogMinOrderByAggregateInput = {
    id?: SortOrder
    customerId?: SortOrder
    action?: SortOrder
    detail?: SortOrder
    createdAt?: SortOrder
  }

  export type UploadedFileCountOrderByAggregateInput = {
    id?: SortOrder
    url?: SortOrder
    originalName?: SortOrder
    mimeType?: SortOrder
    sizeBytes?: SortOrder
    purpose?: SortOrder
    uploadedByAdminUserId?: SortOrder
    createdAt?: SortOrder
  }

  export type UploadedFileAvgOrderByAggregateInput = {
    sizeBytes?: SortOrder
  }

  export type UploadedFileMaxOrderByAggregateInput = {
    id?: SortOrder
    url?: SortOrder
    originalName?: SortOrder
    mimeType?: SortOrder
    sizeBytes?: SortOrder
    purpose?: SortOrder
    uploadedByAdminUserId?: SortOrder
    createdAt?: SortOrder
  }

  export type UploadedFileMinOrderByAggregateInput = {
    id?: SortOrder
    url?: SortOrder
    originalName?: SortOrder
    mimeType?: SortOrder
    sizeBytes?: SortOrder
    purpose?: SortOrder
    uploadedByAdminUserId?: SortOrder
    createdAt?: SortOrder
  }

  export type UploadedFileSumOrderByAggregateInput = {
    sizeBytes?: SortOrder
  }

  export type CustomerOtpCountOrderByAggregateInput = {
    id?: SortOrder
    mobile?: SortOrder
    customerId?: SortOrder
    codeHash?: SortOrder
    expiresAt?: SortOrder
    attempts?: SortOrder
    consumedAt?: SortOrder
    requestIp?: SortOrder
    createdAt?: SortOrder
  }

  export type CustomerOtpAvgOrderByAggregateInput = {
    attempts?: SortOrder
  }

  export type CustomerOtpMaxOrderByAggregateInput = {
    id?: SortOrder
    mobile?: SortOrder
    customerId?: SortOrder
    codeHash?: SortOrder
    expiresAt?: SortOrder
    attempts?: SortOrder
    consumedAt?: SortOrder
    requestIp?: SortOrder
    createdAt?: SortOrder
  }

  export type CustomerOtpMinOrderByAggregateInput = {
    id?: SortOrder
    mobile?: SortOrder
    customerId?: SortOrder
    codeHash?: SortOrder
    expiresAt?: SortOrder
    attempts?: SortOrder
    consumedAt?: SortOrder
    requestIp?: SortOrder
    createdAt?: SortOrder
  }

  export type CustomerOtpSumOrderByAggregateInput = {
    attempts?: SortOrder
  }

  export type CustomerCreateNestedManyWithoutCityInput = {
    create?: XOR<CustomerCreateWithoutCityInput, CustomerUncheckedCreateWithoutCityInput> | CustomerCreateWithoutCityInput[] | CustomerUncheckedCreateWithoutCityInput[]
    connectOrCreate?: CustomerCreateOrConnectWithoutCityInput | CustomerCreateOrConnectWithoutCityInput[]
    createMany?: CustomerCreateManyCityInputEnvelope
    connect?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
  }

  export type CustomerAddressCreateNestedManyWithoutCityInput = {
    create?: XOR<CustomerAddressCreateWithoutCityInput, CustomerAddressUncheckedCreateWithoutCityInput> | CustomerAddressCreateWithoutCityInput[] | CustomerAddressUncheckedCreateWithoutCityInput[]
    connectOrCreate?: CustomerAddressCreateOrConnectWithoutCityInput | CustomerAddressCreateOrConnectWithoutCityInput[]
    createMany?: CustomerAddressCreateManyCityInputEnvelope
    connect?: CustomerAddressWhereUniqueInput | CustomerAddressWhereUniqueInput[]
  }

  export type BranchCreateNestedManyWithoutCityInput = {
    create?: XOR<BranchCreateWithoutCityInput, BranchUncheckedCreateWithoutCityInput> | BranchCreateWithoutCityInput[] | BranchUncheckedCreateWithoutCityInput[]
    connectOrCreate?: BranchCreateOrConnectWithoutCityInput | BranchCreateOrConnectWithoutCityInput[]
    createMany?: BranchCreateManyCityInputEnvelope
    connect?: BranchWhereUniqueInput | BranchWhereUniqueInput[]
  }

  export type PreOrderCreateNestedManyWithoutCityInput = {
    create?: XOR<PreOrderCreateWithoutCityInput, PreOrderUncheckedCreateWithoutCityInput> | PreOrderCreateWithoutCityInput[] | PreOrderUncheckedCreateWithoutCityInput[]
    connectOrCreate?: PreOrderCreateOrConnectWithoutCityInput | PreOrderCreateOrConnectWithoutCityInput[]
    createMany?: PreOrderCreateManyCityInputEnvelope
    connect?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
  }

  export type SalesExpertProfileCreateNestedManyWithoutCityInput = {
    create?: XOR<SalesExpertProfileCreateWithoutCityInput, SalesExpertProfileUncheckedCreateWithoutCityInput> | SalesExpertProfileCreateWithoutCityInput[] | SalesExpertProfileUncheckedCreateWithoutCityInput[]
    connectOrCreate?: SalesExpertProfileCreateOrConnectWithoutCityInput | SalesExpertProfileCreateOrConnectWithoutCityInput[]
    createMany?: SalesExpertProfileCreateManyCityInputEnvelope
    connect?: SalesExpertProfileWhereUniqueInput | SalesExpertProfileWhereUniqueInput[]
  }

  export type CustomerUncheckedCreateNestedManyWithoutCityInput = {
    create?: XOR<CustomerCreateWithoutCityInput, CustomerUncheckedCreateWithoutCityInput> | CustomerCreateWithoutCityInput[] | CustomerUncheckedCreateWithoutCityInput[]
    connectOrCreate?: CustomerCreateOrConnectWithoutCityInput | CustomerCreateOrConnectWithoutCityInput[]
    createMany?: CustomerCreateManyCityInputEnvelope
    connect?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
  }

  export type CustomerAddressUncheckedCreateNestedManyWithoutCityInput = {
    create?: XOR<CustomerAddressCreateWithoutCityInput, CustomerAddressUncheckedCreateWithoutCityInput> | CustomerAddressCreateWithoutCityInput[] | CustomerAddressUncheckedCreateWithoutCityInput[]
    connectOrCreate?: CustomerAddressCreateOrConnectWithoutCityInput | CustomerAddressCreateOrConnectWithoutCityInput[]
    createMany?: CustomerAddressCreateManyCityInputEnvelope
    connect?: CustomerAddressWhereUniqueInput | CustomerAddressWhereUniqueInput[]
  }

  export type BranchUncheckedCreateNestedManyWithoutCityInput = {
    create?: XOR<BranchCreateWithoutCityInput, BranchUncheckedCreateWithoutCityInput> | BranchCreateWithoutCityInput[] | BranchUncheckedCreateWithoutCityInput[]
    connectOrCreate?: BranchCreateOrConnectWithoutCityInput | BranchCreateOrConnectWithoutCityInput[]
    createMany?: BranchCreateManyCityInputEnvelope
    connect?: BranchWhereUniqueInput | BranchWhereUniqueInput[]
  }

  export type PreOrderUncheckedCreateNestedManyWithoutCityInput = {
    create?: XOR<PreOrderCreateWithoutCityInput, PreOrderUncheckedCreateWithoutCityInput> | PreOrderCreateWithoutCityInput[] | PreOrderUncheckedCreateWithoutCityInput[]
    connectOrCreate?: PreOrderCreateOrConnectWithoutCityInput | PreOrderCreateOrConnectWithoutCityInput[]
    createMany?: PreOrderCreateManyCityInputEnvelope
    connect?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
  }

  export type SalesExpertProfileUncheckedCreateNestedManyWithoutCityInput = {
    create?: XOR<SalesExpertProfileCreateWithoutCityInput, SalesExpertProfileUncheckedCreateWithoutCityInput> | SalesExpertProfileCreateWithoutCityInput[] | SalesExpertProfileUncheckedCreateWithoutCityInput[]
    connectOrCreate?: SalesExpertProfileCreateOrConnectWithoutCityInput | SalesExpertProfileCreateOrConnectWithoutCityInput[]
    createMany?: SalesExpertProfileCreateManyCityInputEnvelope
    connect?: SalesExpertProfileWhereUniqueInput | SalesExpertProfileWhereUniqueInput[]
  }

  export type StringFieldUpdateOperationsInput = {
    set?: string
  }

  export type NullableStringFieldUpdateOperationsInput = {
    set?: string | null
  }

  export type NullableDecimalFieldUpdateOperationsInput = {
    set?: Decimal | DecimalJsLike | number | string | null
    increment?: Decimal | DecimalJsLike | number | string
    decrement?: Decimal | DecimalJsLike | number | string
    multiply?: Decimal | DecimalJsLike | number | string
    divide?: Decimal | DecimalJsLike | number | string
  }

  export type CustomerUpdateManyWithoutCityNestedInput = {
    create?: XOR<CustomerCreateWithoutCityInput, CustomerUncheckedCreateWithoutCityInput> | CustomerCreateWithoutCityInput[] | CustomerUncheckedCreateWithoutCityInput[]
    connectOrCreate?: CustomerCreateOrConnectWithoutCityInput | CustomerCreateOrConnectWithoutCityInput[]
    upsert?: CustomerUpsertWithWhereUniqueWithoutCityInput | CustomerUpsertWithWhereUniqueWithoutCityInput[]
    createMany?: CustomerCreateManyCityInputEnvelope
    set?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
    disconnect?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
    delete?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
    connect?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
    update?: CustomerUpdateWithWhereUniqueWithoutCityInput | CustomerUpdateWithWhereUniqueWithoutCityInput[]
    updateMany?: CustomerUpdateManyWithWhereWithoutCityInput | CustomerUpdateManyWithWhereWithoutCityInput[]
    deleteMany?: CustomerScalarWhereInput | CustomerScalarWhereInput[]
  }

  export type CustomerAddressUpdateManyWithoutCityNestedInput = {
    create?: XOR<CustomerAddressCreateWithoutCityInput, CustomerAddressUncheckedCreateWithoutCityInput> | CustomerAddressCreateWithoutCityInput[] | CustomerAddressUncheckedCreateWithoutCityInput[]
    connectOrCreate?: CustomerAddressCreateOrConnectWithoutCityInput | CustomerAddressCreateOrConnectWithoutCityInput[]
    upsert?: CustomerAddressUpsertWithWhereUniqueWithoutCityInput | CustomerAddressUpsertWithWhereUniqueWithoutCityInput[]
    createMany?: CustomerAddressCreateManyCityInputEnvelope
    set?: CustomerAddressWhereUniqueInput | CustomerAddressWhereUniqueInput[]
    disconnect?: CustomerAddressWhereUniqueInput | CustomerAddressWhereUniqueInput[]
    delete?: CustomerAddressWhereUniqueInput | CustomerAddressWhereUniqueInput[]
    connect?: CustomerAddressWhereUniqueInput | CustomerAddressWhereUniqueInput[]
    update?: CustomerAddressUpdateWithWhereUniqueWithoutCityInput | CustomerAddressUpdateWithWhereUniqueWithoutCityInput[]
    updateMany?: CustomerAddressUpdateManyWithWhereWithoutCityInput | CustomerAddressUpdateManyWithWhereWithoutCityInput[]
    deleteMany?: CustomerAddressScalarWhereInput | CustomerAddressScalarWhereInput[]
  }

  export type BranchUpdateManyWithoutCityNestedInput = {
    create?: XOR<BranchCreateWithoutCityInput, BranchUncheckedCreateWithoutCityInput> | BranchCreateWithoutCityInput[] | BranchUncheckedCreateWithoutCityInput[]
    connectOrCreate?: BranchCreateOrConnectWithoutCityInput | BranchCreateOrConnectWithoutCityInput[]
    upsert?: BranchUpsertWithWhereUniqueWithoutCityInput | BranchUpsertWithWhereUniqueWithoutCityInput[]
    createMany?: BranchCreateManyCityInputEnvelope
    set?: BranchWhereUniqueInput | BranchWhereUniqueInput[]
    disconnect?: BranchWhereUniqueInput | BranchWhereUniqueInput[]
    delete?: BranchWhereUniqueInput | BranchWhereUniqueInput[]
    connect?: BranchWhereUniqueInput | BranchWhereUniqueInput[]
    update?: BranchUpdateWithWhereUniqueWithoutCityInput | BranchUpdateWithWhereUniqueWithoutCityInput[]
    updateMany?: BranchUpdateManyWithWhereWithoutCityInput | BranchUpdateManyWithWhereWithoutCityInput[]
    deleteMany?: BranchScalarWhereInput | BranchScalarWhereInput[]
  }

  export type PreOrderUpdateManyWithoutCityNestedInput = {
    create?: XOR<PreOrderCreateWithoutCityInput, PreOrderUncheckedCreateWithoutCityInput> | PreOrderCreateWithoutCityInput[] | PreOrderUncheckedCreateWithoutCityInput[]
    connectOrCreate?: PreOrderCreateOrConnectWithoutCityInput | PreOrderCreateOrConnectWithoutCityInput[]
    upsert?: PreOrderUpsertWithWhereUniqueWithoutCityInput | PreOrderUpsertWithWhereUniqueWithoutCityInput[]
    createMany?: PreOrderCreateManyCityInputEnvelope
    set?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
    disconnect?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
    delete?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
    connect?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
    update?: PreOrderUpdateWithWhereUniqueWithoutCityInput | PreOrderUpdateWithWhereUniqueWithoutCityInput[]
    updateMany?: PreOrderUpdateManyWithWhereWithoutCityInput | PreOrderUpdateManyWithWhereWithoutCityInput[]
    deleteMany?: PreOrderScalarWhereInput | PreOrderScalarWhereInput[]
  }

  export type SalesExpertProfileUpdateManyWithoutCityNestedInput = {
    create?: XOR<SalesExpertProfileCreateWithoutCityInput, SalesExpertProfileUncheckedCreateWithoutCityInput> | SalesExpertProfileCreateWithoutCityInput[] | SalesExpertProfileUncheckedCreateWithoutCityInput[]
    connectOrCreate?: SalesExpertProfileCreateOrConnectWithoutCityInput | SalesExpertProfileCreateOrConnectWithoutCityInput[]
    upsert?: SalesExpertProfileUpsertWithWhereUniqueWithoutCityInput | SalesExpertProfileUpsertWithWhereUniqueWithoutCityInput[]
    createMany?: SalesExpertProfileCreateManyCityInputEnvelope
    set?: SalesExpertProfileWhereUniqueInput | SalesExpertProfileWhereUniqueInput[]
    disconnect?: SalesExpertProfileWhereUniqueInput | SalesExpertProfileWhereUniqueInput[]
    delete?: SalesExpertProfileWhereUniqueInput | SalesExpertProfileWhereUniqueInput[]
    connect?: SalesExpertProfileWhereUniqueInput | SalesExpertProfileWhereUniqueInput[]
    update?: SalesExpertProfileUpdateWithWhereUniqueWithoutCityInput | SalesExpertProfileUpdateWithWhereUniqueWithoutCityInput[]
    updateMany?: SalesExpertProfileUpdateManyWithWhereWithoutCityInput | SalesExpertProfileUpdateManyWithWhereWithoutCityInput[]
    deleteMany?: SalesExpertProfileScalarWhereInput | SalesExpertProfileScalarWhereInput[]
  }

  export type CustomerUncheckedUpdateManyWithoutCityNestedInput = {
    create?: XOR<CustomerCreateWithoutCityInput, CustomerUncheckedCreateWithoutCityInput> | CustomerCreateWithoutCityInput[] | CustomerUncheckedCreateWithoutCityInput[]
    connectOrCreate?: CustomerCreateOrConnectWithoutCityInput | CustomerCreateOrConnectWithoutCityInput[]
    upsert?: CustomerUpsertWithWhereUniqueWithoutCityInput | CustomerUpsertWithWhereUniqueWithoutCityInput[]
    createMany?: CustomerCreateManyCityInputEnvelope
    set?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
    disconnect?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
    delete?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
    connect?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
    update?: CustomerUpdateWithWhereUniqueWithoutCityInput | CustomerUpdateWithWhereUniqueWithoutCityInput[]
    updateMany?: CustomerUpdateManyWithWhereWithoutCityInput | CustomerUpdateManyWithWhereWithoutCityInput[]
    deleteMany?: CustomerScalarWhereInput | CustomerScalarWhereInput[]
  }

  export type CustomerAddressUncheckedUpdateManyWithoutCityNestedInput = {
    create?: XOR<CustomerAddressCreateWithoutCityInput, CustomerAddressUncheckedCreateWithoutCityInput> | CustomerAddressCreateWithoutCityInput[] | CustomerAddressUncheckedCreateWithoutCityInput[]
    connectOrCreate?: CustomerAddressCreateOrConnectWithoutCityInput | CustomerAddressCreateOrConnectWithoutCityInput[]
    upsert?: CustomerAddressUpsertWithWhereUniqueWithoutCityInput | CustomerAddressUpsertWithWhereUniqueWithoutCityInput[]
    createMany?: CustomerAddressCreateManyCityInputEnvelope
    set?: CustomerAddressWhereUniqueInput | CustomerAddressWhereUniqueInput[]
    disconnect?: CustomerAddressWhereUniqueInput | CustomerAddressWhereUniqueInput[]
    delete?: CustomerAddressWhereUniqueInput | CustomerAddressWhereUniqueInput[]
    connect?: CustomerAddressWhereUniqueInput | CustomerAddressWhereUniqueInput[]
    update?: CustomerAddressUpdateWithWhereUniqueWithoutCityInput | CustomerAddressUpdateWithWhereUniqueWithoutCityInput[]
    updateMany?: CustomerAddressUpdateManyWithWhereWithoutCityInput | CustomerAddressUpdateManyWithWhereWithoutCityInput[]
    deleteMany?: CustomerAddressScalarWhereInput | CustomerAddressScalarWhereInput[]
  }

  export type BranchUncheckedUpdateManyWithoutCityNestedInput = {
    create?: XOR<BranchCreateWithoutCityInput, BranchUncheckedCreateWithoutCityInput> | BranchCreateWithoutCityInput[] | BranchUncheckedCreateWithoutCityInput[]
    connectOrCreate?: BranchCreateOrConnectWithoutCityInput | BranchCreateOrConnectWithoutCityInput[]
    upsert?: BranchUpsertWithWhereUniqueWithoutCityInput | BranchUpsertWithWhereUniqueWithoutCityInput[]
    createMany?: BranchCreateManyCityInputEnvelope
    set?: BranchWhereUniqueInput | BranchWhereUniqueInput[]
    disconnect?: BranchWhereUniqueInput | BranchWhereUniqueInput[]
    delete?: BranchWhereUniqueInput | BranchWhereUniqueInput[]
    connect?: BranchWhereUniqueInput | BranchWhereUniqueInput[]
    update?: BranchUpdateWithWhereUniqueWithoutCityInput | BranchUpdateWithWhereUniqueWithoutCityInput[]
    updateMany?: BranchUpdateManyWithWhereWithoutCityInput | BranchUpdateManyWithWhereWithoutCityInput[]
    deleteMany?: BranchScalarWhereInput | BranchScalarWhereInput[]
  }

  export type PreOrderUncheckedUpdateManyWithoutCityNestedInput = {
    create?: XOR<PreOrderCreateWithoutCityInput, PreOrderUncheckedCreateWithoutCityInput> | PreOrderCreateWithoutCityInput[] | PreOrderUncheckedCreateWithoutCityInput[]
    connectOrCreate?: PreOrderCreateOrConnectWithoutCityInput | PreOrderCreateOrConnectWithoutCityInput[]
    upsert?: PreOrderUpsertWithWhereUniqueWithoutCityInput | PreOrderUpsertWithWhereUniqueWithoutCityInput[]
    createMany?: PreOrderCreateManyCityInputEnvelope
    set?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
    disconnect?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
    delete?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
    connect?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
    update?: PreOrderUpdateWithWhereUniqueWithoutCityInput | PreOrderUpdateWithWhereUniqueWithoutCityInput[]
    updateMany?: PreOrderUpdateManyWithWhereWithoutCityInput | PreOrderUpdateManyWithWhereWithoutCityInput[]
    deleteMany?: PreOrderScalarWhereInput | PreOrderScalarWhereInput[]
  }

  export type SalesExpertProfileUncheckedUpdateManyWithoutCityNestedInput = {
    create?: XOR<SalesExpertProfileCreateWithoutCityInput, SalesExpertProfileUncheckedCreateWithoutCityInput> | SalesExpertProfileCreateWithoutCityInput[] | SalesExpertProfileUncheckedCreateWithoutCityInput[]
    connectOrCreate?: SalesExpertProfileCreateOrConnectWithoutCityInput | SalesExpertProfileCreateOrConnectWithoutCityInput[]
    upsert?: SalesExpertProfileUpsertWithWhereUniqueWithoutCityInput | SalesExpertProfileUpsertWithWhereUniqueWithoutCityInput[]
    createMany?: SalesExpertProfileCreateManyCityInputEnvelope
    set?: SalesExpertProfileWhereUniqueInput | SalesExpertProfileWhereUniqueInput[]
    disconnect?: SalesExpertProfileWhereUniqueInput | SalesExpertProfileWhereUniqueInput[]
    delete?: SalesExpertProfileWhereUniqueInput | SalesExpertProfileWhereUniqueInput[]
    connect?: SalesExpertProfileWhereUniqueInput | SalesExpertProfileWhereUniqueInput[]
    update?: SalesExpertProfileUpdateWithWhereUniqueWithoutCityInput | SalesExpertProfileUpdateWithWhereUniqueWithoutCityInput[]
    updateMany?: SalesExpertProfileUpdateManyWithWhereWithoutCityInput | SalesExpertProfileUpdateManyWithWhereWithoutCityInput[]
    deleteMany?: SalesExpertProfileScalarWhereInput | SalesExpertProfileScalarWhereInput[]
  }

  export type UserTypeCreateNestedOneWithoutAdminUsersInput = {
    create?: XOR<UserTypeCreateWithoutAdminUsersInput, UserTypeUncheckedCreateWithoutAdminUsersInput>
    connectOrCreate?: UserTypeCreateOrConnectWithoutAdminUsersInput
    connect?: UserTypeWhereUniqueInput
  }

  export type BranchCreateNestedOneWithoutAdminUsersInput = {
    create?: XOR<BranchCreateWithoutAdminUsersInput, BranchUncheckedCreateWithoutAdminUsersInput>
    connectOrCreate?: BranchCreateOrConnectWithoutAdminUsersInput
    connect?: BranchWhereUniqueInput
  }

  export type UploadedFileCreateNestedOneWithoutAdminUserAvatarsInput = {
    create?: XOR<UploadedFileCreateWithoutAdminUserAvatarsInput, UploadedFileUncheckedCreateWithoutAdminUserAvatarsInput>
    connectOrCreate?: UploadedFileCreateOrConnectWithoutAdminUserAvatarsInput
    connect?: UploadedFileWhereUniqueInput
  }

  export type CustomerCreateNestedManyWithoutReferredByAgentInput = {
    create?: XOR<CustomerCreateWithoutReferredByAgentInput, CustomerUncheckedCreateWithoutReferredByAgentInput> | CustomerCreateWithoutReferredByAgentInput[] | CustomerUncheckedCreateWithoutReferredByAgentInput[]
    connectOrCreate?: CustomerCreateOrConnectWithoutReferredByAgentInput | CustomerCreateOrConnectWithoutReferredByAgentInput[]
    createMany?: CustomerCreateManyReferredByAgentInputEnvelope
    connect?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
  }

  export type WorkshopCreateNestedManyWithoutSupervisorInput = {
    create?: XOR<WorkshopCreateWithoutSupervisorInput, WorkshopUncheckedCreateWithoutSupervisorInput> | WorkshopCreateWithoutSupervisorInput[] | WorkshopUncheckedCreateWithoutSupervisorInput[]
    connectOrCreate?: WorkshopCreateOrConnectWithoutSupervisorInput | WorkshopCreateOrConnectWithoutSupervisorInput[]
    createMany?: WorkshopCreateManySupervisorInputEnvelope
    connect?: WorkshopWhereUniqueInput | WorkshopWhereUniqueInput[]
  }

  export type BranchAllocationCreateNestedManyWithoutAllocatorAdminUserInput = {
    create?: XOR<BranchAllocationCreateWithoutAllocatorAdminUserInput, BranchAllocationUncheckedCreateWithoutAllocatorAdminUserInput> | BranchAllocationCreateWithoutAllocatorAdminUserInput[] | BranchAllocationUncheckedCreateWithoutAllocatorAdminUserInput[]
    connectOrCreate?: BranchAllocationCreateOrConnectWithoutAllocatorAdminUserInput | BranchAllocationCreateOrConnectWithoutAllocatorAdminUserInput[]
    createMany?: BranchAllocationCreateManyAllocatorAdminUserInputEnvelope
    connect?: BranchAllocationWhereUniqueInput | BranchAllocationWhereUniqueInput[]
  }

  export type LedgerEntryCreateNestedManyWithoutPostedByAdminUserInput = {
    create?: XOR<LedgerEntryCreateWithoutPostedByAdminUserInput, LedgerEntryUncheckedCreateWithoutPostedByAdminUserInput> | LedgerEntryCreateWithoutPostedByAdminUserInput[] | LedgerEntryUncheckedCreateWithoutPostedByAdminUserInput[]
    connectOrCreate?: LedgerEntryCreateOrConnectWithoutPostedByAdminUserInput | LedgerEntryCreateOrConnectWithoutPostedByAdminUserInput[]
    createMany?: LedgerEntryCreateManyPostedByAdminUserInputEnvelope
    connect?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
  }

  export type OrderStatusEventCreateNestedManyWithoutActorAdminUserInput = {
    create?: XOR<OrderStatusEventCreateWithoutActorAdminUserInput, OrderStatusEventUncheckedCreateWithoutActorAdminUserInput> | OrderStatusEventCreateWithoutActorAdminUserInput[] | OrderStatusEventUncheckedCreateWithoutActorAdminUserInput[]
    connectOrCreate?: OrderStatusEventCreateOrConnectWithoutActorAdminUserInput | OrderStatusEventCreateOrConnectWithoutActorAdminUserInput[]
    createMany?: OrderStatusEventCreateManyActorAdminUserInputEnvelope
    connect?: OrderStatusEventWhereUniqueInput | OrderStatusEventWhereUniqueInput[]
  }

  export type PreOrderStatusEventCreateNestedManyWithoutActorAdminUserInput = {
    create?: XOR<PreOrderStatusEventCreateWithoutActorAdminUserInput, PreOrderStatusEventUncheckedCreateWithoutActorAdminUserInput> | PreOrderStatusEventCreateWithoutActorAdminUserInput[] | PreOrderStatusEventUncheckedCreateWithoutActorAdminUserInput[]
    connectOrCreate?: PreOrderStatusEventCreateOrConnectWithoutActorAdminUserInput | PreOrderStatusEventCreateOrConnectWithoutActorAdminUserInput[]
    createMany?: PreOrderStatusEventCreateManyActorAdminUserInputEnvelope
    connect?: PreOrderStatusEventWhereUniqueInput | PreOrderStatusEventWhereUniqueInput[]
  }

  export type SmsMessageCreateNestedManyWithoutSentByAdminUserInput = {
    create?: XOR<SmsMessageCreateWithoutSentByAdminUserInput, SmsMessageUncheckedCreateWithoutSentByAdminUserInput> | SmsMessageCreateWithoutSentByAdminUserInput[] | SmsMessageUncheckedCreateWithoutSentByAdminUserInput[]
    connectOrCreate?: SmsMessageCreateOrConnectWithoutSentByAdminUserInput | SmsMessageCreateOrConnectWithoutSentByAdminUserInput[]
    createMany?: SmsMessageCreateManySentByAdminUserInputEnvelope
    connect?: SmsMessageWhereUniqueInput | SmsMessageWhereUniqueInput[]
  }

  export type NotificationCreateNestedManyWithoutSentByAdminUserInput = {
    create?: XOR<NotificationCreateWithoutSentByAdminUserInput, NotificationUncheckedCreateWithoutSentByAdminUserInput> | NotificationCreateWithoutSentByAdminUserInput[] | NotificationUncheckedCreateWithoutSentByAdminUserInput[]
    connectOrCreate?: NotificationCreateOrConnectWithoutSentByAdminUserInput | NotificationCreateOrConnectWithoutSentByAdminUserInput[]
    createMany?: NotificationCreateManySentByAdminUserInputEnvelope
    connect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
  }

  export type UploadedFileCreateNestedManyWithoutUploadedByAdminUserInput = {
    create?: XOR<UploadedFileCreateWithoutUploadedByAdminUserInput, UploadedFileUncheckedCreateWithoutUploadedByAdminUserInput> | UploadedFileCreateWithoutUploadedByAdminUserInput[] | UploadedFileUncheckedCreateWithoutUploadedByAdminUserInput[]
    connectOrCreate?: UploadedFileCreateOrConnectWithoutUploadedByAdminUserInput | UploadedFileCreateOrConnectWithoutUploadedByAdminUserInput[]
    createMany?: UploadedFileCreateManyUploadedByAdminUserInputEnvelope
    connect?: UploadedFileWhereUniqueInput | UploadedFileWhereUniqueInput[]
  }

  export type SalesExpertProfileCreateNestedOneWithoutAdminUserInput = {
    create?: XOR<SalesExpertProfileCreateWithoutAdminUserInput, SalesExpertProfileUncheckedCreateWithoutAdminUserInput>
    connectOrCreate?: SalesExpertProfileCreateOrConnectWithoutAdminUserInput
    connect?: SalesExpertProfileWhereUniqueInput
  }

  export type AdminSessionCreateNestedManyWithoutAdminUserInput = {
    create?: XOR<AdminSessionCreateWithoutAdminUserInput, AdminSessionUncheckedCreateWithoutAdminUserInput> | AdminSessionCreateWithoutAdminUserInput[] | AdminSessionUncheckedCreateWithoutAdminUserInput[]
    connectOrCreate?: AdminSessionCreateOrConnectWithoutAdminUserInput | AdminSessionCreateOrConnectWithoutAdminUserInput[]
    createMany?: AdminSessionCreateManyAdminUserInputEnvelope
    connect?: AdminSessionWhereUniqueInput | AdminSessionWhereUniqueInput[]
  }

  export type CustomerUncheckedCreateNestedManyWithoutReferredByAgentInput = {
    create?: XOR<CustomerCreateWithoutReferredByAgentInput, CustomerUncheckedCreateWithoutReferredByAgentInput> | CustomerCreateWithoutReferredByAgentInput[] | CustomerUncheckedCreateWithoutReferredByAgentInput[]
    connectOrCreate?: CustomerCreateOrConnectWithoutReferredByAgentInput | CustomerCreateOrConnectWithoutReferredByAgentInput[]
    createMany?: CustomerCreateManyReferredByAgentInputEnvelope
    connect?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
  }

  export type WorkshopUncheckedCreateNestedManyWithoutSupervisorInput = {
    create?: XOR<WorkshopCreateWithoutSupervisorInput, WorkshopUncheckedCreateWithoutSupervisorInput> | WorkshopCreateWithoutSupervisorInput[] | WorkshopUncheckedCreateWithoutSupervisorInput[]
    connectOrCreate?: WorkshopCreateOrConnectWithoutSupervisorInput | WorkshopCreateOrConnectWithoutSupervisorInput[]
    createMany?: WorkshopCreateManySupervisorInputEnvelope
    connect?: WorkshopWhereUniqueInput | WorkshopWhereUniqueInput[]
  }

  export type BranchAllocationUncheckedCreateNestedManyWithoutAllocatorAdminUserInput = {
    create?: XOR<BranchAllocationCreateWithoutAllocatorAdminUserInput, BranchAllocationUncheckedCreateWithoutAllocatorAdminUserInput> | BranchAllocationCreateWithoutAllocatorAdminUserInput[] | BranchAllocationUncheckedCreateWithoutAllocatorAdminUserInput[]
    connectOrCreate?: BranchAllocationCreateOrConnectWithoutAllocatorAdminUserInput | BranchAllocationCreateOrConnectWithoutAllocatorAdminUserInput[]
    createMany?: BranchAllocationCreateManyAllocatorAdminUserInputEnvelope
    connect?: BranchAllocationWhereUniqueInput | BranchAllocationWhereUniqueInput[]
  }

  export type LedgerEntryUncheckedCreateNestedManyWithoutPostedByAdminUserInput = {
    create?: XOR<LedgerEntryCreateWithoutPostedByAdminUserInput, LedgerEntryUncheckedCreateWithoutPostedByAdminUserInput> | LedgerEntryCreateWithoutPostedByAdminUserInput[] | LedgerEntryUncheckedCreateWithoutPostedByAdminUserInput[]
    connectOrCreate?: LedgerEntryCreateOrConnectWithoutPostedByAdminUserInput | LedgerEntryCreateOrConnectWithoutPostedByAdminUserInput[]
    createMany?: LedgerEntryCreateManyPostedByAdminUserInputEnvelope
    connect?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
  }

  export type OrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput = {
    create?: XOR<OrderStatusEventCreateWithoutActorAdminUserInput, OrderStatusEventUncheckedCreateWithoutActorAdminUserInput> | OrderStatusEventCreateWithoutActorAdminUserInput[] | OrderStatusEventUncheckedCreateWithoutActorAdminUserInput[]
    connectOrCreate?: OrderStatusEventCreateOrConnectWithoutActorAdminUserInput | OrderStatusEventCreateOrConnectWithoutActorAdminUserInput[]
    createMany?: OrderStatusEventCreateManyActorAdminUserInputEnvelope
    connect?: OrderStatusEventWhereUniqueInput | OrderStatusEventWhereUniqueInput[]
  }

  export type PreOrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput = {
    create?: XOR<PreOrderStatusEventCreateWithoutActorAdminUserInput, PreOrderStatusEventUncheckedCreateWithoutActorAdminUserInput> | PreOrderStatusEventCreateWithoutActorAdminUserInput[] | PreOrderStatusEventUncheckedCreateWithoutActorAdminUserInput[]
    connectOrCreate?: PreOrderStatusEventCreateOrConnectWithoutActorAdminUserInput | PreOrderStatusEventCreateOrConnectWithoutActorAdminUserInput[]
    createMany?: PreOrderStatusEventCreateManyActorAdminUserInputEnvelope
    connect?: PreOrderStatusEventWhereUniqueInput | PreOrderStatusEventWhereUniqueInput[]
  }

  export type SmsMessageUncheckedCreateNestedManyWithoutSentByAdminUserInput = {
    create?: XOR<SmsMessageCreateWithoutSentByAdminUserInput, SmsMessageUncheckedCreateWithoutSentByAdminUserInput> | SmsMessageCreateWithoutSentByAdminUserInput[] | SmsMessageUncheckedCreateWithoutSentByAdminUserInput[]
    connectOrCreate?: SmsMessageCreateOrConnectWithoutSentByAdminUserInput | SmsMessageCreateOrConnectWithoutSentByAdminUserInput[]
    createMany?: SmsMessageCreateManySentByAdminUserInputEnvelope
    connect?: SmsMessageWhereUniqueInput | SmsMessageWhereUniqueInput[]
  }

  export type NotificationUncheckedCreateNestedManyWithoutSentByAdminUserInput = {
    create?: XOR<NotificationCreateWithoutSentByAdminUserInput, NotificationUncheckedCreateWithoutSentByAdminUserInput> | NotificationCreateWithoutSentByAdminUserInput[] | NotificationUncheckedCreateWithoutSentByAdminUserInput[]
    connectOrCreate?: NotificationCreateOrConnectWithoutSentByAdminUserInput | NotificationCreateOrConnectWithoutSentByAdminUserInput[]
    createMany?: NotificationCreateManySentByAdminUserInputEnvelope
    connect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
  }

  export type UploadedFileUncheckedCreateNestedManyWithoutUploadedByAdminUserInput = {
    create?: XOR<UploadedFileCreateWithoutUploadedByAdminUserInput, UploadedFileUncheckedCreateWithoutUploadedByAdminUserInput> | UploadedFileCreateWithoutUploadedByAdminUserInput[] | UploadedFileUncheckedCreateWithoutUploadedByAdminUserInput[]
    connectOrCreate?: UploadedFileCreateOrConnectWithoutUploadedByAdminUserInput | UploadedFileCreateOrConnectWithoutUploadedByAdminUserInput[]
    createMany?: UploadedFileCreateManyUploadedByAdminUserInputEnvelope
    connect?: UploadedFileWhereUniqueInput | UploadedFileWhereUniqueInput[]
  }

  export type SalesExpertProfileUncheckedCreateNestedOneWithoutAdminUserInput = {
    create?: XOR<SalesExpertProfileCreateWithoutAdminUserInput, SalesExpertProfileUncheckedCreateWithoutAdminUserInput>
    connectOrCreate?: SalesExpertProfileCreateOrConnectWithoutAdminUserInput
    connect?: SalesExpertProfileWhereUniqueInput
  }

  export type AdminSessionUncheckedCreateNestedManyWithoutAdminUserInput = {
    create?: XOR<AdminSessionCreateWithoutAdminUserInput, AdminSessionUncheckedCreateWithoutAdminUserInput> | AdminSessionCreateWithoutAdminUserInput[] | AdminSessionUncheckedCreateWithoutAdminUserInput[]
    connectOrCreate?: AdminSessionCreateOrConnectWithoutAdminUserInput | AdminSessionCreateOrConnectWithoutAdminUserInput[]
    createMany?: AdminSessionCreateManyAdminUserInputEnvelope
    connect?: AdminSessionWhereUniqueInput | AdminSessionWhereUniqueInput[]
  }

  export type EnumAdminRoleFieldUpdateOperationsInput = {
    set?: $Enums.AdminRole
  }

  export type BoolFieldUpdateOperationsInput = {
    set?: boolean
  }

  export type DateTimeFieldUpdateOperationsInput = {
    set?: Date | string
  }

  export type UserTypeUpdateOneWithoutAdminUsersNestedInput = {
    create?: XOR<UserTypeCreateWithoutAdminUsersInput, UserTypeUncheckedCreateWithoutAdminUsersInput>
    connectOrCreate?: UserTypeCreateOrConnectWithoutAdminUsersInput
    upsert?: UserTypeUpsertWithoutAdminUsersInput
    disconnect?: UserTypeWhereInput | boolean
    delete?: UserTypeWhereInput | boolean
    connect?: UserTypeWhereUniqueInput
    update?: XOR<XOR<UserTypeUpdateToOneWithWhereWithoutAdminUsersInput, UserTypeUpdateWithoutAdminUsersInput>, UserTypeUncheckedUpdateWithoutAdminUsersInput>
  }

  export type BranchUpdateOneWithoutAdminUsersNestedInput = {
    create?: XOR<BranchCreateWithoutAdminUsersInput, BranchUncheckedCreateWithoutAdminUsersInput>
    connectOrCreate?: BranchCreateOrConnectWithoutAdminUsersInput
    upsert?: BranchUpsertWithoutAdminUsersInput
    disconnect?: BranchWhereInput | boolean
    delete?: BranchWhereInput | boolean
    connect?: BranchWhereUniqueInput
    update?: XOR<XOR<BranchUpdateToOneWithWhereWithoutAdminUsersInput, BranchUpdateWithoutAdminUsersInput>, BranchUncheckedUpdateWithoutAdminUsersInput>
  }

  export type UploadedFileUpdateOneWithoutAdminUserAvatarsNestedInput = {
    create?: XOR<UploadedFileCreateWithoutAdminUserAvatarsInput, UploadedFileUncheckedCreateWithoutAdminUserAvatarsInput>
    connectOrCreate?: UploadedFileCreateOrConnectWithoutAdminUserAvatarsInput
    upsert?: UploadedFileUpsertWithoutAdminUserAvatarsInput
    disconnect?: UploadedFileWhereInput | boolean
    delete?: UploadedFileWhereInput | boolean
    connect?: UploadedFileWhereUniqueInput
    update?: XOR<XOR<UploadedFileUpdateToOneWithWhereWithoutAdminUserAvatarsInput, UploadedFileUpdateWithoutAdminUserAvatarsInput>, UploadedFileUncheckedUpdateWithoutAdminUserAvatarsInput>
  }

  export type CustomerUpdateManyWithoutReferredByAgentNestedInput = {
    create?: XOR<CustomerCreateWithoutReferredByAgentInput, CustomerUncheckedCreateWithoutReferredByAgentInput> | CustomerCreateWithoutReferredByAgentInput[] | CustomerUncheckedCreateWithoutReferredByAgentInput[]
    connectOrCreate?: CustomerCreateOrConnectWithoutReferredByAgentInput | CustomerCreateOrConnectWithoutReferredByAgentInput[]
    upsert?: CustomerUpsertWithWhereUniqueWithoutReferredByAgentInput | CustomerUpsertWithWhereUniqueWithoutReferredByAgentInput[]
    createMany?: CustomerCreateManyReferredByAgentInputEnvelope
    set?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
    disconnect?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
    delete?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
    connect?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
    update?: CustomerUpdateWithWhereUniqueWithoutReferredByAgentInput | CustomerUpdateWithWhereUniqueWithoutReferredByAgentInput[]
    updateMany?: CustomerUpdateManyWithWhereWithoutReferredByAgentInput | CustomerUpdateManyWithWhereWithoutReferredByAgentInput[]
    deleteMany?: CustomerScalarWhereInput | CustomerScalarWhereInput[]
  }

  export type WorkshopUpdateManyWithoutSupervisorNestedInput = {
    create?: XOR<WorkshopCreateWithoutSupervisorInput, WorkshopUncheckedCreateWithoutSupervisorInput> | WorkshopCreateWithoutSupervisorInput[] | WorkshopUncheckedCreateWithoutSupervisorInput[]
    connectOrCreate?: WorkshopCreateOrConnectWithoutSupervisorInput | WorkshopCreateOrConnectWithoutSupervisorInput[]
    upsert?: WorkshopUpsertWithWhereUniqueWithoutSupervisorInput | WorkshopUpsertWithWhereUniqueWithoutSupervisorInput[]
    createMany?: WorkshopCreateManySupervisorInputEnvelope
    set?: WorkshopWhereUniqueInput | WorkshopWhereUniqueInput[]
    disconnect?: WorkshopWhereUniqueInput | WorkshopWhereUniqueInput[]
    delete?: WorkshopWhereUniqueInput | WorkshopWhereUniqueInput[]
    connect?: WorkshopWhereUniqueInput | WorkshopWhereUniqueInput[]
    update?: WorkshopUpdateWithWhereUniqueWithoutSupervisorInput | WorkshopUpdateWithWhereUniqueWithoutSupervisorInput[]
    updateMany?: WorkshopUpdateManyWithWhereWithoutSupervisorInput | WorkshopUpdateManyWithWhereWithoutSupervisorInput[]
    deleteMany?: WorkshopScalarWhereInput | WorkshopScalarWhereInput[]
  }

  export type BranchAllocationUpdateManyWithoutAllocatorAdminUserNestedInput = {
    create?: XOR<BranchAllocationCreateWithoutAllocatorAdminUserInput, BranchAllocationUncheckedCreateWithoutAllocatorAdminUserInput> | BranchAllocationCreateWithoutAllocatorAdminUserInput[] | BranchAllocationUncheckedCreateWithoutAllocatorAdminUserInput[]
    connectOrCreate?: BranchAllocationCreateOrConnectWithoutAllocatorAdminUserInput | BranchAllocationCreateOrConnectWithoutAllocatorAdminUserInput[]
    upsert?: BranchAllocationUpsertWithWhereUniqueWithoutAllocatorAdminUserInput | BranchAllocationUpsertWithWhereUniqueWithoutAllocatorAdminUserInput[]
    createMany?: BranchAllocationCreateManyAllocatorAdminUserInputEnvelope
    set?: BranchAllocationWhereUniqueInput | BranchAllocationWhereUniqueInput[]
    disconnect?: BranchAllocationWhereUniqueInput | BranchAllocationWhereUniqueInput[]
    delete?: BranchAllocationWhereUniqueInput | BranchAllocationWhereUniqueInput[]
    connect?: BranchAllocationWhereUniqueInput | BranchAllocationWhereUniqueInput[]
    update?: BranchAllocationUpdateWithWhereUniqueWithoutAllocatorAdminUserInput | BranchAllocationUpdateWithWhereUniqueWithoutAllocatorAdminUserInput[]
    updateMany?: BranchAllocationUpdateManyWithWhereWithoutAllocatorAdminUserInput | BranchAllocationUpdateManyWithWhereWithoutAllocatorAdminUserInput[]
    deleteMany?: BranchAllocationScalarWhereInput | BranchAllocationScalarWhereInput[]
  }

  export type LedgerEntryUpdateManyWithoutPostedByAdminUserNestedInput = {
    create?: XOR<LedgerEntryCreateWithoutPostedByAdminUserInput, LedgerEntryUncheckedCreateWithoutPostedByAdminUserInput> | LedgerEntryCreateWithoutPostedByAdminUserInput[] | LedgerEntryUncheckedCreateWithoutPostedByAdminUserInput[]
    connectOrCreate?: LedgerEntryCreateOrConnectWithoutPostedByAdminUserInput | LedgerEntryCreateOrConnectWithoutPostedByAdminUserInput[]
    upsert?: LedgerEntryUpsertWithWhereUniqueWithoutPostedByAdminUserInput | LedgerEntryUpsertWithWhereUniqueWithoutPostedByAdminUserInput[]
    createMany?: LedgerEntryCreateManyPostedByAdminUserInputEnvelope
    set?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
    disconnect?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
    delete?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
    connect?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
    update?: LedgerEntryUpdateWithWhereUniqueWithoutPostedByAdminUserInput | LedgerEntryUpdateWithWhereUniqueWithoutPostedByAdminUserInput[]
    updateMany?: LedgerEntryUpdateManyWithWhereWithoutPostedByAdminUserInput | LedgerEntryUpdateManyWithWhereWithoutPostedByAdminUserInput[]
    deleteMany?: LedgerEntryScalarWhereInput | LedgerEntryScalarWhereInput[]
  }

  export type OrderStatusEventUpdateManyWithoutActorAdminUserNestedInput = {
    create?: XOR<OrderStatusEventCreateWithoutActorAdminUserInput, OrderStatusEventUncheckedCreateWithoutActorAdminUserInput> | OrderStatusEventCreateWithoutActorAdminUserInput[] | OrderStatusEventUncheckedCreateWithoutActorAdminUserInput[]
    connectOrCreate?: OrderStatusEventCreateOrConnectWithoutActorAdminUserInput | OrderStatusEventCreateOrConnectWithoutActorAdminUserInput[]
    upsert?: OrderStatusEventUpsertWithWhereUniqueWithoutActorAdminUserInput | OrderStatusEventUpsertWithWhereUniqueWithoutActorAdminUserInput[]
    createMany?: OrderStatusEventCreateManyActorAdminUserInputEnvelope
    set?: OrderStatusEventWhereUniqueInput | OrderStatusEventWhereUniqueInput[]
    disconnect?: OrderStatusEventWhereUniqueInput | OrderStatusEventWhereUniqueInput[]
    delete?: OrderStatusEventWhereUniqueInput | OrderStatusEventWhereUniqueInput[]
    connect?: OrderStatusEventWhereUniqueInput | OrderStatusEventWhereUniqueInput[]
    update?: OrderStatusEventUpdateWithWhereUniqueWithoutActorAdminUserInput | OrderStatusEventUpdateWithWhereUniqueWithoutActorAdminUserInput[]
    updateMany?: OrderStatusEventUpdateManyWithWhereWithoutActorAdminUserInput | OrderStatusEventUpdateManyWithWhereWithoutActorAdminUserInput[]
    deleteMany?: OrderStatusEventScalarWhereInput | OrderStatusEventScalarWhereInput[]
  }

  export type PreOrderStatusEventUpdateManyWithoutActorAdminUserNestedInput = {
    create?: XOR<PreOrderStatusEventCreateWithoutActorAdminUserInput, PreOrderStatusEventUncheckedCreateWithoutActorAdminUserInput> | PreOrderStatusEventCreateWithoutActorAdminUserInput[] | PreOrderStatusEventUncheckedCreateWithoutActorAdminUserInput[]
    connectOrCreate?: PreOrderStatusEventCreateOrConnectWithoutActorAdminUserInput | PreOrderStatusEventCreateOrConnectWithoutActorAdminUserInput[]
    upsert?: PreOrderStatusEventUpsertWithWhereUniqueWithoutActorAdminUserInput | PreOrderStatusEventUpsertWithWhereUniqueWithoutActorAdminUserInput[]
    createMany?: PreOrderStatusEventCreateManyActorAdminUserInputEnvelope
    set?: PreOrderStatusEventWhereUniqueInput | PreOrderStatusEventWhereUniqueInput[]
    disconnect?: PreOrderStatusEventWhereUniqueInput | PreOrderStatusEventWhereUniqueInput[]
    delete?: PreOrderStatusEventWhereUniqueInput | PreOrderStatusEventWhereUniqueInput[]
    connect?: PreOrderStatusEventWhereUniqueInput | PreOrderStatusEventWhereUniqueInput[]
    update?: PreOrderStatusEventUpdateWithWhereUniqueWithoutActorAdminUserInput | PreOrderStatusEventUpdateWithWhereUniqueWithoutActorAdminUserInput[]
    updateMany?: PreOrderStatusEventUpdateManyWithWhereWithoutActorAdminUserInput | PreOrderStatusEventUpdateManyWithWhereWithoutActorAdminUserInput[]
    deleteMany?: PreOrderStatusEventScalarWhereInput | PreOrderStatusEventScalarWhereInput[]
  }

  export type SmsMessageUpdateManyWithoutSentByAdminUserNestedInput = {
    create?: XOR<SmsMessageCreateWithoutSentByAdminUserInput, SmsMessageUncheckedCreateWithoutSentByAdminUserInput> | SmsMessageCreateWithoutSentByAdminUserInput[] | SmsMessageUncheckedCreateWithoutSentByAdminUserInput[]
    connectOrCreate?: SmsMessageCreateOrConnectWithoutSentByAdminUserInput | SmsMessageCreateOrConnectWithoutSentByAdminUserInput[]
    upsert?: SmsMessageUpsertWithWhereUniqueWithoutSentByAdminUserInput | SmsMessageUpsertWithWhereUniqueWithoutSentByAdminUserInput[]
    createMany?: SmsMessageCreateManySentByAdminUserInputEnvelope
    set?: SmsMessageWhereUniqueInput | SmsMessageWhereUniqueInput[]
    disconnect?: SmsMessageWhereUniqueInput | SmsMessageWhereUniqueInput[]
    delete?: SmsMessageWhereUniqueInput | SmsMessageWhereUniqueInput[]
    connect?: SmsMessageWhereUniqueInput | SmsMessageWhereUniqueInput[]
    update?: SmsMessageUpdateWithWhereUniqueWithoutSentByAdminUserInput | SmsMessageUpdateWithWhereUniqueWithoutSentByAdminUserInput[]
    updateMany?: SmsMessageUpdateManyWithWhereWithoutSentByAdminUserInput | SmsMessageUpdateManyWithWhereWithoutSentByAdminUserInput[]
    deleteMany?: SmsMessageScalarWhereInput | SmsMessageScalarWhereInput[]
  }

  export type NotificationUpdateManyWithoutSentByAdminUserNestedInput = {
    create?: XOR<NotificationCreateWithoutSentByAdminUserInput, NotificationUncheckedCreateWithoutSentByAdminUserInput> | NotificationCreateWithoutSentByAdminUserInput[] | NotificationUncheckedCreateWithoutSentByAdminUserInput[]
    connectOrCreate?: NotificationCreateOrConnectWithoutSentByAdminUserInput | NotificationCreateOrConnectWithoutSentByAdminUserInput[]
    upsert?: NotificationUpsertWithWhereUniqueWithoutSentByAdminUserInput | NotificationUpsertWithWhereUniqueWithoutSentByAdminUserInput[]
    createMany?: NotificationCreateManySentByAdminUserInputEnvelope
    set?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    disconnect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    delete?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    connect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    update?: NotificationUpdateWithWhereUniqueWithoutSentByAdminUserInput | NotificationUpdateWithWhereUniqueWithoutSentByAdminUserInput[]
    updateMany?: NotificationUpdateManyWithWhereWithoutSentByAdminUserInput | NotificationUpdateManyWithWhereWithoutSentByAdminUserInput[]
    deleteMany?: NotificationScalarWhereInput | NotificationScalarWhereInput[]
  }

  export type UploadedFileUpdateManyWithoutUploadedByAdminUserNestedInput = {
    create?: XOR<UploadedFileCreateWithoutUploadedByAdminUserInput, UploadedFileUncheckedCreateWithoutUploadedByAdminUserInput> | UploadedFileCreateWithoutUploadedByAdminUserInput[] | UploadedFileUncheckedCreateWithoutUploadedByAdminUserInput[]
    connectOrCreate?: UploadedFileCreateOrConnectWithoutUploadedByAdminUserInput | UploadedFileCreateOrConnectWithoutUploadedByAdminUserInput[]
    upsert?: UploadedFileUpsertWithWhereUniqueWithoutUploadedByAdminUserInput | UploadedFileUpsertWithWhereUniqueWithoutUploadedByAdminUserInput[]
    createMany?: UploadedFileCreateManyUploadedByAdminUserInputEnvelope
    set?: UploadedFileWhereUniqueInput | UploadedFileWhereUniqueInput[]
    disconnect?: UploadedFileWhereUniqueInput | UploadedFileWhereUniqueInput[]
    delete?: UploadedFileWhereUniqueInput | UploadedFileWhereUniqueInput[]
    connect?: UploadedFileWhereUniqueInput | UploadedFileWhereUniqueInput[]
    update?: UploadedFileUpdateWithWhereUniqueWithoutUploadedByAdminUserInput | UploadedFileUpdateWithWhereUniqueWithoutUploadedByAdminUserInput[]
    updateMany?: UploadedFileUpdateManyWithWhereWithoutUploadedByAdminUserInput | UploadedFileUpdateManyWithWhereWithoutUploadedByAdminUserInput[]
    deleteMany?: UploadedFileScalarWhereInput | UploadedFileScalarWhereInput[]
  }

  export type SalesExpertProfileUpdateOneWithoutAdminUserNestedInput = {
    create?: XOR<SalesExpertProfileCreateWithoutAdminUserInput, SalesExpertProfileUncheckedCreateWithoutAdminUserInput>
    connectOrCreate?: SalesExpertProfileCreateOrConnectWithoutAdminUserInput
    upsert?: SalesExpertProfileUpsertWithoutAdminUserInput
    disconnect?: SalesExpertProfileWhereInput | boolean
    delete?: SalesExpertProfileWhereInput | boolean
    connect?: SalesExpertProfileWhereUniqueInput
    update?: XOR<XOR<SalesExpertProfileUpdateToOneWithWhereWithoutAdminUserInput, SalesExpertProfileUpdateWithoutAdminUserInput>, SalesExpertProfileUncheckedUpdateWithoutAdminUserInput>
  }

  export type AdminSessionUpdateManyWithoutAdminUserNestedInput = {
    create?: XOR<AdminSessionCreateWithoutAdminUserInput, AdminSessionUncheckedCreateWithoutAdminUserInput> | AdminSessionCreateWithoutAdminUserInput[] | AdminSessionUncheckedCreateWithoutAdminUserInput[]
    connectOrCreate?: AdminSessionCreateOrConnectWithoutAdminUserInput | AdminSessionCreateOrConnectWithoutAdminUserInput[]
    upsert?: AdminSessionUpsertWithWhereUniqueWithoutAdminUserInput | AdminSessionUpsertWithWhereUniqueWithoutAdminUserInput[]
    createMany?: AdminSessionCreateManyAdminUserInputEnvelope
    set?: AdminSessionWhereUniqueInput | AdminSessionWhereUniqueInput[]
    disconnect?: AdminSessionWhereUniqueInput | AdminSessionWhereUniqueInput[]
    delete?: AdminSessionWhereUniqueInput | AdminSessionWhereUniqueInput[]
    connect?: AdminSessionWhereUniqueInput | AdminSessionWhereUniqueInput[]
    update?: AdminSessionUpdateWithWhereUniqueWithoutAdminUserInput | AdminSessionUpdateWithWhereUniqueWithoutAdminUserInput[]
    updateMany?: AdminSessionUpdateManyWithWhereWithoutAdminUserInput | AdminSessionUpdateManyWithWhereWithoutAdminUserInput[]
    deleteMany?: AdminSessionScalarWhereInput | AdminSessionScalarWhereInput[]
  }

  export type NullableIntFieldUpdateOperationsInput = {
    set?: number | null
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type CustomerUncheckedUpdateManyWithoutReferredByAgentNestedInput = {
    create?: XOR<CustomerCreateWithoutReferredByAgentInput, CustomerUncheckedCreateWithoutReferredByAgentInput> | CustomerCreateWithoutReferredByAgentInput[] | CustomerUncheckedCreateWithoutReferredByAgentInput[]
    connectOrCreate?: CustomerCreateOrConnectWithoutReferredByAgentInput | CustomerCreateOrConnectWithoutReferredByAgentInput[]
    upsert?: CustomerUpsertWithWhereUniqueWithoutReferredByAgentInput | CustomerUpsertWithWhereUniqueWithoutReferredByAgentInput[]
    createMany?: CustomerCreateManyReferredByAgentInputEnvelope
    set?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
    disconnect?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
    delete?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
    connect?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
    update?: CustomerUpdateWithWhereUniqueWithoutReferredByAgentInput | CustomerUpdateWithWhereUniqueWithoutReferredByAgentInput[]
    updateMany?: CustomerUpdateManyWithWhereWithoutReferredByAgentInput | CustomerUpdateManyWithWhereWithoutReferredByAgentInput[]
    deleteMany?: CustomerScalarWhereInput | CustomerScalarWhereInput[]
  }

  export type WorkshopUncheckedUpdateManyWithoutSupervisorNestedInput = {
    create?: XOR<WorkshopCreateWithoutSupervisorInput, WorkshopUncheckedCreateWithoutSupervisorInput> | WorkshopCreateWithoutSupervisorInput[] | WorkshopUncheckedCreateWithoutSupervisorInput[]
    connectOrCreate?: WorkshopCreateOrConnectWithoutSupervisorInput | WorkshopCreateOrConnectWithoutSupervisorInput[]
    upsert?: WorkshopUpsertWithWhereUniqueWithoutSupervisorInput | WorkshopUpsertWithWhereUniqueWithoutSupervisorInput[]
    createMany?: WorkshopCreateManySupervisorInputEnvelope
    set?: WorkshopWhereUniqueInput | WorkshopWhereUniqueInput[]
    disconnect?: WorkshopWhereUniqueInput | WorkshopWhereUniqueInput[]
    delete?: WorkshopWhereUniqueInput | WorkshopWhereUniqueInput[]
    connect?: WorkshopWhereUniqueInput | WorkshopWhereUniqueInput[]
    update?: WorkshopUpdateWithWhereUniqueWithoutSupervisorInput | WorkshopUpdateWithWhereUniqueWithoutSupervisorInput[]
    updateMany?: WorkshopUpdateManyWithWhereWithoutSupervisorInput | WorkshopUpdateManyWithWhereWithoutSupervisorInput[]
    deleteMany?: WorkshopScalarWhereInput | WorkshopScalarWhereInput[]
  }

  export type BranchAllocationUncheckedUpdateManyWithoutAllocatorAdminUserNestedInput = {
    create?: XOR<BranchAllocationCreateWithoutAllocatorAdminUserInput, BranchAllocationUncheckedCreateWithoutAllocatorAdminUserInput> | BranchAllocationCreateWithoutAllocatorAdminUserInput[] | BranchAllocationUncheckedCreateWithoutAllocatorAdminUserInput[]
    connectOrCreate?: BranchAllocationCreateOrConnectWithoutAllocatorAdminUserInput | BranchAllocationCreateOrConnectWithoutAllocatorAdminUserInput[]
    upsert?: BranchAllocationUpsertWithWhereUniqueWithoutAllocatorAdminUserInput | BranchAllocationUpsertWithWhereUniqueWithoutAllocatorAdminUserInput[]
    createMany?: BranchAllocationCreateManyAllocatorAdminUserInputEnvelope
    set?: BranchAllocationWhereUniqueInput | BranchAllocationWhereUniqueInput[]
    disconnect?: BranchAllocationWhereUniqueInput | BranchAllocationWhereUniqueInput[]
    delete?: BranchAllocationWhereUniqueInput | BranchAllocationWhereUniqueInput[]
    connect?: BranchAllocationWhereUniqueInput | BranchAllocationWhereUniqueInput[]
    update?: BranchAllocationUpdateWithWhereUniqueWithoutAllocatorAdminUserInput | BranchAllocationUpdateWithWhereUniqueWithoutAllocatorAdminUserInput[]
    updateMany?: BranchAllocationUpdateManyWithWhereWithoutAllocatorAdminUserInput | BranchAllocationUpdateManyWithWhereWithoutAllocatorAdminUserInput[]
    deleteMany?: BranchAllocationScalarWhereInput | BranchAllocationScalarWhereInput[]
  }

  export type LedgerEntryUncheckedUpdateManyWithoutPostedByAdminUserNestedInput = {
    create?: XOR<LedgerEntryCreateWithoutPostedByAdminUserInput, LedgerEntryUncheckedCreateWithoutPostedByAdminUserInput> | LedgerEntryCreateWithoutPostedByAdminUserInput[] | LedgerEntryUncheckedCreateWithoutPostedByAdminUserInput[]
    connectOrCreate?: LedgerEntryCreateOrConnectWithoutPostedByAdminUserInput | LedgerEntryCreateOrConnectWithoutPostedByAdminUserInput[]
    upsert?: LedgerEntryUpsertWithWhereUniqueWithoutPostedByAdminUserInput | LedgerEntryUpsertWithWhereUniqueWithoutPostedByAdminUserInput[]
    createMany?: LedgerEntryCreateManyPostedByAdminUserInputEnvelope
    set?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
    disconnect?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
    delete?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
    connect?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
    update?: LedgerEntryUpdateWithWhereUniqueWithoutPostedByAdminUserInput | LedgerEntryUpdateWithWhereUniqueWithoutPostedByAdminUserInput[]
    updateMany?: LedgerEntryUpdateManyWithWhereWithoutPostedByAdminUserInput | LedgerEntryUpdateManyWithWhereWithoutPostedByAdminUserInput[]
    deleteMany?: LedgerEntryScalarWhereInput | LedgerEntryScalarWhereInput[]
  }

  export type OrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput = {
    create?: XOR<OrderStatusEventCreateWithoutActorAdminUserInput, OrderStatusEventUncheckedCreateWithoutActorAdminUserInput> | OrderStatusEventCreateWithoutActorAdminUserInput[] | OrderStatusEventUncheckedCreateWithoutActorAdminUserInput[]
    connectOrCreate?: OrderStatusEventCreateOrConnectWithoutActorAdminUserInput | OrderStatusEventCreateOrConnectWithoutActorAdminUserInput[]
    upsert?: OrderStatusEventUpsertWithWhereUniqueWithoutActorAdminUserInput | OrderStatusEventUpsertWithWhereUniqueWithoutActorAdminUserInput[]
    createMany?: OrderStatusEventCreateManyActorAdminUserInputEnvelope
    set?: OrderStatusEventWhereUniqueInput | OrderStatusEventWhereUniqueInput[]
    disconnect?: OrderStatusEventWhereUniqueInput | OrderStatusEventWhereUniqueInput[]
    delete?: OrderStatusEventWhereUniqueInput | OrderStatusEventWhereUniqueInput[]
    connect?: OrderStatusEventWhereUniqueInput | OrderStatusEventWhereUniqueInput[]
    update?: OrderStatusEventUpdateWithWhereUniqueWithoutActorAdminUserInput | OrderStatusEventUpdateWithWhereUniqueWithoutActorAdminUserInput[]
    updateMany?: OrderStatusEventUpdateManyWithWhereWithoutActorAdminUserInput | OrderStatusEventUpdateManyWithWhereWithoutActorAdminUserInput[]
    deleteMany?: OrderStatusEventScalarWhereInput | OrderStatusEventScalarWhereInput[]
  }

  export type PreOrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput = {
    create?: XOR<PreOrderStatusEventCreateWithoutActorAdminUserInput, PreOrderStatusEventUncheckedCreateWithoutActorAdminUserInput> | PreOrderStatusEventCreateWithoutActorAdminUserInput[] | PreOrderStatusEventUncheckedCreateWithoutActorAdminUserInput[]
    connectOrCreate?: PreOrderStatusEventCreateOrConnectWithoutActorAdminUserInput | PreOrderStatusEventCreateOrConnectWithoutActorAdminUserInput[]
    upsert?: PreOrderStatusEventUpsertWithWhereUniqueWithoutActorAdminUserInput | PreOrderStatusEventUpsertWithWhereUniqueWithoutActorAdminUserInput[]
    createMany?: PreOrderStatusEventCreateManyActorAdminUserInputEnvelope
    set?: PreOrderStatusEventWhereUniqueInput | PreOrderStatusEventWhereUniqueInput[]
    disconnect?: PreOrderStatusEventWhereUniqueInput | PreOrderStatusEventWhereUniqueInput[]
    delete?: PreOrderStatusEventWhereUniqueInput | PreOrderStatusEventWhereUniqueInput[]
    connect?: PreOrderStatusEventWhereUniqueInput | PreOrderStatusEventWhereUniqueInput[]
    update?: PreOrderStatusEventUpdateWithWhereUniqueWithoutActorAdminUserInput | PreOrderStatusEventUpdateWithWhereUniqueWithoutActorAdminUserInput[]
    updateMany?: PreOrderStatusEventUpdateManyWithWhereWithoutActorAdminUserInput | PreOrderStatusEventUpdateManyWithWhereWithoutActorAdminUserInput[]
    deleteMany?: PreOrderStatusEventScalarWhereInput | PreOrderStatusEventScalarWhereInput[]
  }

  export type SmsMessageUncheckedUpdateManyWithoutSentByAdminUserNestedInput = {
    create?: XOR<SmsMessageCreateWithoutSentByAdminUserInput, SmsMessageUncheckedCreateWithoutSentByAdminUserInput> | SmsMessageCreateWithoutSentByAdminUserInput[] | SmsMessageUncheckedCreateWithoutSentByAdminUserInput[]
    connectOrCreate?: SmsMessageCreateOrConnectWithoutSentByAdminUserInput | SmsMessageCreateOrConnectWithoutSentByAdminUserInput[]
    upsert?: SmsMessageUpsertWithWhereUniqueWithoutSentByAdminUserInput | SmsMessageUpsertWithWhereUniqueWithoutSentByAdminUserInput[]
    createMany?: SmsMessageCreateManySentByAdminUserInputEnvelope
    set?: SmsMessageWhereUniqueInput | SmsMessageWhereUniqueInput[]
    disconnect?: SmsMessageWhereUniqueInput | SmsMessageWhereUniqueInput[]
    delete?: SmsMessageWhereUniqueInput | SmsMessageWhereUniqueInput[]
    connect?: SmsMessageWhereUniqueInput | SmsMessageWhereUniqueInput[]
    update?: SmsMessageUpdateWithWhereUniqueWithoutSentByAdminUserInput | SmsMessageUpdateWithWhereUniqueWithoutSentByAdminUserInput[]
    updateMany?: SmsMessageUpdateManyWithWhereWithoutSentByAdminUserInput | SmsMessageUpdateManyWithWhereWithoutSentByAdminUserInput[]
    deleteMany?: SmsMessageScalarWhereInput | SmsMessageScalarWhereInput[]
  }

  export type NotificationUncheckedUpdateManyWithoutSentByAdminUserNestedInput = {
    create?: XOR<NotificationCreateWithoutSentByAdminUserInput, NotificationUncheckedCreateWithoutSentByAdminUserInput> | NotificationCreateWithoutSentByAdminUserInput[] | NotificationUncheckedCreateWithoutSentByAdminUserInput[]
    connectOrCreate?: NotificationCreateOrConnectWithoutSentByAdminUserInput | NotificationCreateOrConnectWithoutSentByAdminUserInput[]
    upsert?: NotificationUpsertWithWhereUniqueWithoutSentByAdminUserInput | NotificationUpsertWithWhereUniqueWithoutSentByAdminUserInput[]
    createMany?: NotificationCreateManySentByAdminUserInputEnvelope
    set?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    disconnect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    delete?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    connect?: NotificationWhereUniqueInput | NotificationWhereUniqueInput[]
    update?: NotificationUpdateWithWhereUniqueWithoutSentByAdminUserInput | NotificationUpdateWithWhereUniqueWithoutSentByAdminUserInput[]
    updateMany?: NotificationUpdateManyWithWhereWithoutSentByAdminUserInput | NotificationUpdateManyWithWhereWithoutSentByAdminUserInput[]
    deleteMany?: NotificationScalarWhereInput | NotificationScalarWhereInput[]
  }

  export type UploadedFileUncheckedUpdateManyWithoutUploadedByAdminUserNestedInput = {
    create?: XOR<UploadedFileCreateWithoutUploadedByAdminUserInput, UploadedFileUncheckedCreateWithoutUploadedByAdminUserInput> | UploadedFileCreateWithoutUploadedByAdminUserInput[] | UploadedFileUncheckedCreateWithoutUploadedByAdminUserInput[]
    connectOrCreate?: UploadedFileCreateOrConnectWithoutUploadedByAdminUserInput | UploadedFileCreateOrConnectWithoutUploadedByAdminUserInput[]
    upsert?: UploadedFileUpsertWithWhereUniqueWithoutUploadedByAdminUserInput | UploadedFileUpsertWithWhereUniqueWithoutUploadedByAdminUserInput[]
    createMany?: UploadedFileCreateManyUploadedByAdminUserInputEnvelope
    set?: UploadedFileWhereUniqueInput | UploadedFileWhereUniqueInput[]
    disconnect?: UploadedFileWhereUniqueInput | UploadedFileWhereUniqueInput[]
    delete?: UploadedFileWhereUniqueInput | UploadedFileWhereUniqueInput[]
    connect?: UploadedFileWhereUniqueInput | UploadedFileWhereUniqueInput[]
    update?: UploadedFileUpdateWithWhereUniqueWithoutUploadedByAdminUserInput | UploadedFileUpdateWithWhereUniqueWithoutUploadedByAdminUserInput[]
    updateMany?: UploadedFileUpdateManyWithWhereWithoutUploadedByAdminUserInput | UploadedFileUpdateManyWithWhereWithoutUploadedByAdminUserInput[]
    deleteMany?: UploadedFileScalarWhereInput | UploadedFileScalarWhereInput[]
  }

  export type SalesExpertProfileUncheckedUpdateOneWithoutAdminUserNestedInput = {
    create?: XOR<SalesExpertProfileCreateWithoutAdminUserInput, SalesExpertProfileUncheckedCreateWithoutAdminUserInput>
    connectOrCreate?: SalesExpertProfileCreateOrConnectWithoutAdminUserInput
    upsert?: SalesExpertProfileUpsertWithoutAdminUserInput
    disconnect?: SalesExpertProfileWhereInput | boolean
    delete?: SalesExpertProfileWhereInput | boolean
    connect?: SalesExpertProfileWhereUniqueInput
    update?: XOR<XOR<SalesExpertProfileUpdateToOneWithWhereWithoutAdminUserInput, SalesExpertProfileUpdateWithoutAdminUserInput>, SalesExpertProfileUncheckedUpdateWithoutAdminUserInput>
  }

  export type AdminSessionUncheckedUpdateManyWithoutAdminUserNestedInput = {
    create?: XOR<AdminSessionCreateWithoutAdminUserInput, AdminSessionUncheckedCreateWithoutAdminUserInput> | AdminSessionCreateWithoutAdminUserInput[] | AdminSessionUncheckedCreateWithoutAdminUserInput[]
    connectOrCreate?: AdminSessionCreateOrConnectWithoutAdminUserInput | AdminSessionCreateOrConnectWithoutAdminUserInput[]
    upsert?: AdminSessionUpsertWithWhereUniqueWithoutAdminUserInput | AdminSessionUpsertWithWhereUniqueWithoutAdminUserInput[]
    createMany?: AdminSessionCreateManyAdminUserInputEnvelope
    set?: AdminSessionWhereUniqueInput | AdminSessionWhereUniqueInput[]
    disconnect?: AdminSessionWhereUniqueInput | AdminSessionWhereUniqueInput[]
    delete?: AdminSessionWhereUniqueInput | AdminSessionWhereUniqueInput[]
    connect?: AdminSessionWhereUniqueInput | AdminSessionWhereUniqueInput[]
    update?: AdminSessionUpdateWithWhereUniqueWithoutAdminUserInput | AdminSessionUpdateWithWhereUniqueWithoutAdminUserInput[]
    updateMany?: AdminSessionUpdateManyWithWhereWithoutAdminUserInput | AdminSessionUpdateManyWithWhereWithoutAdminUserInput[]
    deleteMany?: AdminSessionScalarWhereInput | AdminSessionScalarWhereInput[]
  }

  export type NullableDateTimeFieldUpdateOperationsInput = {
    set?: Date | string | null
  }

  export type AdminUserCreateNestedOneWithoutSessionsInput = {
    create?: XOR<AdminUserCreateWithoutSessionsInput, AdminUserUncheckedCreateWithoutSessionsInput>
    connectOrCreate?: AdminUserCreateOrConnectWithoutSessionsInput
    connect?: AdminUserWhereUniqueInput
  }

  export type AdminUserUpdateOneRequiredWithoutSessionsNestedInput = {
    create?: XOR<AdminUserCreateWithoutSessionsInput, AdminUserUncheckedCreateWithoutSessionsInput>
    connectOrCreate?: AdminUserCreateOrConnectWithoutSessionsInput
    upsert?: AdminUserUpsertWithoutSessionsInput
    connect?: AdminUserWhereUniqueInput
    update?: XOR<XOR<AdminUserUpdateToOneWithWhereWithoutSessionsInput, AdminUserUpdateWithoutSessionsInput>, AdminUserUncheckedUpdateWithoutSessionsInput>
  }

  export type AdminUserCreateNestedOneWithoutSalesExpertProfileInput = {
    create?: XOR<AdminUserCreateWithoutSalesExpertProfileInput, AdminUserUncheckedCreateWithoutSalesExpertProfileInput>
    connectOrCreate?: AdminUserCreateOrConnectWithoutSalesExpertProfileInput
    connect?: AdminUserWhereUniqueInput
  }

  export type CityCreateNestedOneWithoutSalesExpertProfilesInput = {
    create?: XOR<CityCreateWithoutSalesExpertProfilesInput, CityUncheckedCreateWithoutSalesExpertProfilesInput>
    connectOrCreate?: CityCreateOrConnectWithoutSalesExpertProfilesInput
    connect?: CityWhereUniqueInput
  }

  export type CustomerCreateNestedOneWithoutSalesExpertTradingForInput = {
    create?: XOR<CustomerCreateWithoutSalesExpertTradingForInput, CustomerUncheckedCreateWithoutSalesExpertTradingForInput>
    connectOrCreate?: CustomerCreateOrConnectWithoutSalesExpertTradingForInput
    connect?: CustomerWhereUniqueInput
  }

  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 AdminUserUpdateOneRequiredWithoutSalesExpertProfileNestedInput = {
    create?: XOR<AdminUserCreateWithoutSalesExpertProfileInput, AdminUserUncheckedCreateWithoutSalesExpertProfileInput>
    connectOrCreate?: AdminUserCreateOrConnectWithoutSalesExpertProfileInput
    upsert?: AdminUserUpsertWithoutSalesExpertProfileInput
    connect?: AdminUserWhereUniqueInput
    update?: XOR<XOR<AdminUserUpdateToOneWithWhereWithoutSalesExpertProfileInput, AdminUserUpdateWithoutSalesExpertProfileInput>, AdminUserUncheckedUpdateWithoutSalesExpertProfileInput>
  }

  export type CityUpdateOneWithoutSalesExpertProfilesNestedInput = {
    create?: XOR<CityCreateWithoutSalesExpertProfilesInput, CityUncheckedCreateWithoutSalesExpertProfilesInput>
    connectOrCreate?: CityCreateOrConnectWithoutSalesExpertProfilesInput
    upsert?: CityUpsertWithoutSalesExpertProfilesInput
    disconnect?: CityWhereInput | boolean
    delete?: CityWhereInput | boolean
    connect?: CityWhereUniqueInput
    update?: XOR<XOR<CityUpdateToOneWithWhereWithoutSalesExpertProfilesInput, CityUpdateWithoutSalesExpertProfilesInput>, CityUncheckedUpdateWithoutSalesExpertProfilesInput>
  }

  export type CustomerUpdateOneWithoutSalesExpertTradingForNestedInput = {
    create?: XOR<CustomerCreateWithoutSalesExpertTradingForInput, CustomerUncheckedCreateWithoutSalesExpertTradingForInput>
    connectOrCreate?: CustomerCreateOrConnectWithoutSalesExpertTradingForInput
    upsert?: CustomerUpsertWithoutSalesExpertTradingForInput
    disconnect?: CustomerWhereInput | boolean
    delete?: CustomerWhereInput | boolean
    connect?: CustomerWhereUniqueInput
    update?: XOR<XOR<CustomerUpdateToOneWithWhereWithoutSalesExpertTradingForInput, CustomerUpdateWithoutSalesExpertTradingForInput>, CustomerUncheckedUpdateWithoutSalesExpertTradingForInput>
  }

  export type CityCreateNestedOneWithoutCustomersInput = {
    create?: XOR<CityCreateWithoutCustomersInput, CityUncheckedCreateWithoutCustomersInput>
    connectOrCreate?: CityCreateOrConnectWithoutCustomersInput
    connect?: CityWhereUniqueInput
  }

  export type AdminUserCreateNestedOneWithoutReferredCustomersInput = {
    create?: XOR<AdminUserCreateWithoutReferredCustomersInput, AdminUserUncheckedCreateWithoutReferredCustomersInput>
    connectOrCreate?: AdminUserCreateOrConnectWithoutReferredCustomersInput
    connect?: AdminUserWhereUniqueInput
  }

  export type SalesExpertProfileCreateNestedOneWithoutTradingCustomerInput = {
    create?: XOR<SalesExpertProfileCreateWithoutTradingCustomerInput, SalesExpertProfileUncheckedCreateWithoutTradingCustomerInput>
    connectOrCreate?: SalesExpertProfileCreateOrConnectWithoutTradingCustomerInput
    connect?: SalesExpertProfileWhereUniqueInput
  }

  export type UploadedFileCreateNestedOneWithoutCustomerAvatarsInput = {
    create?: XOR<UploadedFileCreateWithoutCustomerAvatarsInput, UploadedFileUncheckedCreateWithoutCustomerAvatarsInput>
    connectOrCreate?: UploadedFileCreateOrConnectWithoutCustomerAvatarsInput
    connect?: UploadedFileWhereUniqueInput
  }

  export type CustomerAddressCreateNestedManyWithoutCustomerInput = {
    create?: XOR<CustomerAddressCreateWithoutCustomerInput, CustomerAddressUncheckedCreateWithoutCustomerInput> | CustomerAddressCreateWithoutCustomerInput[] | CustomerAddressUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: CustomerAddressCreateOrConnectWithoutCustomerInput | CustomerAddressCreateOrConnectWithoutCustomerInput[]
    createMany?: CustomerAddressCreateManyCustomerInputEnvelope
    connect?: CustomerAddressWhereUniqueInput | CustomerAddressWhereUniqueInput[]
  }

  export type OrderCreateNestedManyWithoutCustomerInput = {
    create?: XOR<OrderCreateWithoutCustomerInput, OrderUncheckedCreateWithoutCustomerInput> | OrderCreateWithoutCustomerInput[] | OrderUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: OrderCreateOrConnectWithoutCustomerInput | OrderCreateOrConnectWithoutCustomerInput[]
    createMany?: OrderCreateManyCustomerInputEnvelope
    connect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
  }

  export type PreOrderCreateNestedManyWithoutCustomerInput = {
    create?: XOR<PreOrderCreateWithoutCustomerInput, PreOrderUncheckedCreateWithoutCustomerInput> | PreOrderCreateWithoutCustomerInput[] | PreOrderUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: PreOrderCreateOrConnectWithoutCustomerInput | PreOrderCreateOrConnectWithoutCustomerInput[]
    createMany?: PreOrderCreateManyCustomerInputEnvelope
    connect?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
  }

  export type LedgerEntryCreateNestedManyWithoutCustomerInput = {
    create?: XOR<LedgerEntryCreateWithoutCustomerInput, LedgerEntryUncheckedCreateWithoutCustomerInput> | LedgerEntryCreateWithoutCustomerInput[] | LedgerEntryUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: LedgerEntryCreateOrConnectWithoutCustomerInput | LedgerEntryCreateOrConnectWithoutCustomerInput[]
    createMany?: LedgerEntryCreateManyCustomerInputEnvelope
    connect?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
  }

  export type WalletBonusCreateNestedManyWithoutCustomerInput = {
    create?: XOR<WalletBonusCreateWithoutCustomerInput, WalletBonusUncheckedCreateWithoutCustomerInput> | WalletBonusCreateWithoutCustomerInput[] | WalletBonusUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: WalletBonusCreateOrConnectWithoutCustomerInput | WalletBonusCreateOrConnectWithoutCustomerInput[]
    createMany?: WalletBonusCreateManyCustomerInputEnvelope
    connect?: WalletBonusWhereUniqueInput | WalletBonusWhereUniqueInput[]
  }

  export type CommentCreateNestedManyWithoutCustomerInput = {
    create?: XOR<CommentCreateWithoutCustomerInput, CommentUncheckedCreateWithoutCustomerInput> | CommentCreateWithoutCustomerInput[] | CommentUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: CommentCreateOrConnectWithoutCustomerInput | CommentCreateOrConnectWithoutCustomerInput[]
    createMany?: CommentCreateManyCustomerInputEnvelope
    connect?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
  }

  export type PromotionCreateNestedManyWithoutCustomerInput = {
    create?: XOR<PromotionCreateWithoutCustomerInput, PromotionUncheckedCreateWithoutCustomerInput> | PromotionCreateWithoutCustomerInput[] | PromotionUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: PromotionCreateOrConnectWithoutCustomerInput | PromotionCreateOrConnectWithoutCustomerInput[]
    createMany?: PromotionCreateManyCustomerInputEnvelope
    connect?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
  }

  export type NotificationRecipientCreateNestedManyWithoutCustomerInput = {
    create?: XOR<NotificationRecipientCreateWithoutCustomerInput, NotificationRecipientUncheckedCreateWithoutCustomerInput> | NotificationRecipientCreateWithoutCustomerInput[] | NotificationRecipientUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: NotificationRecipientCreateOrConnectWithoutCustomerInput | NotificationRecipientCreateOrConnectWithoutCustomerInput[]
    createMany?: NotificationRecipientCreateManyCustomerInputEnvelope
    connect?: NotificationRecipientWhereUniqueInput | NotificationRecipientWhereUniqueInput[]
  }

  export type CustomerActivityLogCreateNestedManyWithoutCustomerInput = {
    create?: XOR<CustomerActivityLogCreateWithoutCustomerInput, CustomerActivityLogUncheckedCreateWithoutCustomerInput> | CustomerActivityLogCreateWithoutCustomerInput[] | CustomerActivityLogUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: CustomerActivityLogCreateOrConnectWithoutCustomerInput | CustomerActivityLogCreateOrConnectWithoutCustomerInput[]
    createMany?: CustomerActivityLogCreateManyCustomerInputEnvelope
    connect?: CustomerActivityLogWhereUniqueInput | CustomerActivityLogWhereUniqueInput[]
  }

  export type CustomerOtpCreateNestedManyWithoutCustomerInput = {
    create?: XOR<CustomerOtpCreateWithoutCustomerInput, CustomerOtpUncheckedCreateWithoutCustomerInput> | CustomerOtpCreateWithoutCustomerInput[] | CustomerOtpUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: CustomerOtpCreateOrConnectWithoutCustomerInput | CustomerOtpCreateOrConnectWithoutCustomerInput[]
    createMany?: CustomerOtpCreateManyCustomerInputEnvelope
    connect?: CustomerOtpWhereUniqueInput | CustomerOtpWhereUniqueInput[]
  }

  export type SalesExpertProfileUncheckedCreateNestedOneWithoutTradingCustomerInput = {
    create?: XOR<SalesExpertProfileCreateWithoutTradingCustomerInput, SalesExpertProfileUncheckedCreateWithoutTradingCustomerInput>
    connectOrCreate?: SalesExpertProfileCreateOrConnectWithoutTradingCustomerInput
    connect?: SalesExpertProfileWhereUniqueInput
  }

  export type CustomerAddressUncheckedCreateNestedManyWithoutCustomerInput = {
    create?: XOR<CustomerAddressCreateWithoutCustomerInput, CustomerAddressUncheckedCreateWithoutCustomerInput> | CustomerAddressCreateWithoutCustomerInput[] | CustomerAddressUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: CustomerAddressCreateOrConnectWithoutCustomerInput | CustomerAddressCreateOrConnectWithoutCustomerInput[]
    createMany?: CustomerAddressCreateManyCustomerInputEnvelope
    connect?: CustomerAddressWhereUniqueInput | CustomerAddressWhereUniqueInput[]
  }

  export type OrderUncheckedCreateNestedManyWithoutCustomerInput = {
    create?: XOR<OrderCreateWithoutCustomerInput, OrderUncheckedCreateWithoutCustomerInput> | OrderCreateWithoutCustomerInput[] | OrderUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: OrderCreateOrConnectWithoutCustomerInput | OrderCreateOrConnectWithoutCustomerInput[]
    createMany?: OrderCreateManyCustomerInputEnvelope
    connect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
  }

  export type PreOrderUncheckedCreateNestedManyWithoutCustomerInput = {
    create?: XOR<PreOrderCreateWithoutCustomerInput, PreOrderUncheckedCreateWithoutCustomerInput> | PreOrderCreateWithoutCustomerInput[] | PreOrderUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: PreOrderCreateOrConnectWithoutCustomerInput | PreOrderCreateOrConnectWithoutCustomerInput[]
    createMany?: PreOrderCreateManyCustomerInputEnvelope
    connect?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
  }

  export type LedgerEntryUncheckedCreateNestedManyWithoutCustomerInput = {
    create?: XOR<LedgerEntryCreateWithoutCustomerInput, LedgerEntryUncheckedCreateWithoutCustomerInput> | LedgerEntryCreateWithoutCustomerInput[] | LedgerEntryUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: LedgerEntryCreateOrConnectWithoutCustomerInput | LedgerEntryCreateOrConnectWithoutCustomerInput[]
    createMany?: LedgerEntryCreateManyCustomerInputEnvelope
    connect?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
  }

  export type WalletBonusUncheckedCreateNestedManyWithoutCustomerInput = {
    create?: XOR<WalletBonusCreateWithoutCustomerInput, WalletBonusUncheckedCreateWithoutCustomerInput> | WalletBonusCreateWithoutCustomerInput[] | WalletBonusUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: WalletBonusCreateOrConnectWithoutCustomerInput | WalletBonusCreateOrConnectWithoutCustomerInput[]
    createMany?: WalletBonusCreateManyCustomerInputEnvelope
    connect?: WalletBonusWhereUniqueInput | WalletBonusWhereUniqueInput[]
  }

  export type CommentUncheckedCreateNestedManyWithoutCustomerInput = {
    create?: XOR<CommentCreateWithoutCustomerInput, CommentUncheckedCreateWithoutCustomerInput> | CommentCreateWithoutCustomerInput[] | CommentUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: CommentCreateOrConnectWithoutCustomerInput | CommentCreateOrConnectWithoutCustomerInput[]
    createMany?: CommentCreateManyCustomerInputEnvelope
    connect?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
  }

  export type PromotionUncheckedCreateNestedManyWithoutCustomerInput = {
    create?: XOR<PromotionCreateWithoutCustomerInput, PromotionUncheckedCreateWithoutCustomerInput> | PromotionCreateWithoutCustomerInput[] | PromotionUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: PromotionCreateOrConnectWithoutCustomerInput | PromotionCreateOrConnectWithoutCustomerInput[]
    createMany?: PromotionCreateManyCustomerInputEnvelope
    connect?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
  }

  export type NotificationRecipientUncheckedCreateNestedManyWithoutCustomerInput = {
    create?: XOR<NotificationRecipientCreateWithoutCustomerInput, NotificationRecipientUncheckedCreateWithoutCustomerInput> | NotificationRecipientCreateWithoutCustomerInput[] | NotificationRecipientUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: NotificationRecipientCreateOrConnectWithoutCustomerInput | NotificationRecipientCreateOrConnectWithoutCustomerInput[]
    createMany?: NotificationRecipientCreateManyCustomerInputEnvelope
    connect?: NotificationRecipientWhereUniqueInput | NotificationRecipientWhereUniqueInput[]
  }

  export type CustomerActivityLogUncheckedCreateNestedManyWithoutCustomerInput = {
    create?: XOR<CustomerActivityLogCreateWithoutCustomerInput, CustomerActivityLogUncheckedCreateWithoutCustomerInput> | CustomerActivityLogCreateWithoutCustomerInput[] | CustomerActivityLogUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: CustomerActivityLogCreateOrConnectWithoutCustomerInput | CustomerActivityLogCreateOrConnectWithoutCustomerInput[]
    createMany?: CustomerActivityLogCreateManyCustomerInputEnvelope
    connect?: CustomerActivityLogWhereUniqueInput | CustomerActivityLogWhereUniqueInput[]
  }

  export type CustomerOtpUncheckedCreateNestedManyWithoutCustomerInput = {
    create?: XOR<CustomerOtpCreateWithoutCustomerInput, CustomerOtpUncheckedCreateWithoutCustomerInput> | CustomerOtpCreateWithoutCustomerInput[] | CustomerOtpUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: CustomerOtpCreateOrConnectWithoutCustomerInput | CustomerOtpCreateOrConnectWithoutCustomerInput[]
    createMany?: CustomerOtpCreateManyCustomerInputEnvelope
    connect?: CustomerOtpWhereUniqueInput | CustomerOtpWhereUniqueInput[]
  }

  export type EnumCustomerKindFieldUpdateOperationsInput = {
    set?: $Enums.CustomerKind
  }

  export type EnumVerificationStepFieldUpdateOperationsInput = {
    set?: $Enums.VerificationStep
  }

  export type CityUpdateOneWithoutCustomersNestedInput = {
    create?: XOR<CityCreateWithoutCustomersInput, CityUncheckedCreateWithoutCustomersInput>
    connectOrCreate?: CityCreateOrConnectWithoutCustomersInput
    upsert?: CityUpsertWithoutCustomersInput
    disconnect?: CityWhereInput | boolean
    delete?: CityWhereInput | boolean
    connect?: CityWhereUniqueInput
    update?: XOR<XOR<CityUpdateToOneWithWhereWithoutCustomersInput, CityUpdateWithoutCustomersInput>, CityUncheckedUpdateWithoutCustomersInput>
  }

  export type AdminUserUpdateOneWithoutReferredCustomersNestedInput = {
    create?: XOR<AdminUserCreateWithoutReferredCustomersInput, AdminUserUncheckedCreateWithoutReferredCustomersInput>
    connectOrCreate?: AdminUserCreateOrConnectWithoutReferredCustomersInput
    upsert?: AdminUserUpsertWithoutReferredCustomersInput
    disconnect?: AdminUserWhereInput | boolean
    delete?: AdminUserWhereInput | boolean
    connect?: AdminUserWhereUniqueInput
    update?: XOR<XOR<AdminUserUpdateToOneWithWhereWithoutReferredCustomersInput, AdminUserUpdateWithoutReferredCustomersInput>, AdminUserUncheckedUpdateWithoutReferredCustomersInput>
  }

  export type SalesExpertProfileUpdateOneWithoutTradingCustomerNestedInput = {
    create?: XOR<SalesExpertProfileCreateWithoutTradingCustomerInput, SalesExpertProfileUncheckedCreateWithoutTradingCustomerInput>
    connectOrCreate?: SalesExpertProfileCreateOrConnectWithoutTradingCustomerInput
    upsert?: SalesExpertProfileUpsertWithoutTradingCustomerInput
    disconnect?: SalesExpertProfileWhereInput | boolean
    delete?: SalesExpertProfileWhereInput | boolean
    connect?: SalesExpertProfileWhereUniqueInput
    update?: XOR<XOR<SalesExpertProfileUpdateToOneWithWhereWithoutTradingCustomerInput, SalesExpertProfileUpdateWithoutTradingCustomerInput>, SalesExpertProfileUncheckedUpdateWithoutTradingCustomerInput>
  }

  export type UploadedFileUpdateOneWithoutCustomerAvatarsNestedInput = {
    create?: XOR<UploadedFileCreateWithoutCustomerAvatarsInput, UploadedFileUncheckedCreateWithoutCustomerAvatarsInput>
    connectOrCreate?: UploadedFileCreateOrConnectWithoutCustomerAvatarsInput
    upsert?: UploadedFileUpsertWithoutCustomerAvatarsInput
    disconnect?: UploadedFileWhereInput | boolean
    delete?: UploadedFileWhereInput | boolean
    connect?: UploadedFileWhereUniqueInput
    update?: XOR<XOR<UploadedFileUpdateToOneWithWhereWithoutCustomerAvatarsInput, UploadedFileUpdateWithoutCustomerAvatarsInput>, UploadedFileUncheckedUpdateWithoutCustomerAvatarsInput>
  }

  export type CustomerAddressUpdateManyWithoutCustomerNestedInput = {
    create?: XOR<CustomerAddressCreateWithoutCustomerInput, CustomerAddressUncheckedCreateWithoutCustomerInput> | CustomerAddressCreateWithoutCustomerInput[] | CustomerAddressUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: CustomerAddressCreateOrConnectWithoutCustomerInput | CustomerAddressCreateOrConnectWithoutCustomerInput[]
    upsert?: CustomerAddressUpsertWithWhereUniqueWithoutCustomerInput | CustomerAddressUpsertWithWhereUniqueWithoutCustomerInput[]
    createMany?: CustomerAddressCreateManyCustomerInputEnvelope
    set?: CustomerAddressWhereUniqueInput | CustomerAddressWhereUniqueInput[]
    disconnect?: CustomerAddressWhereUniqueInput | CustomerAddressWhereUniqueInput[]
    delete?: CustomerAddressWhereUniqueInput | CustomerAddressWhereUniqueInput[]
    connect?: CustomerAddressWhereUniqueInput | CustomerAddressWhereUniqueInput[]
    update?: CustomerAddressUpdateWithWhereUniqueWithoutCustomerInput | CustomerAddressUpdateWithWhereUniqueWithoutCustomerInput[]
    updateMany?: CustomerAddressUpdateManyWithWhereWithoutCustomerInput | CustomerAddressUpdateManyWithWhereWithoutCustomerInput[]
    deleteMany?: CustomerAddressScalarWhereInput | CustomerAddressScalarWhereInput[]
  }

  export type OrderUpdateManyWithoutCustomerNestedInput = {
    create?: XOR<OrderCreateWithoutCustomerInput, OrderUncheckedCreateWithoutCustomerInput> | OrderCreateWithoutCustomerInput[] | OrderUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: OrderCreateOrConnectWithoutCustomerInput | OrderCreateOrConnectWithoutCustomerInput[]
    upsert?: OrderUpsertWithWhereUniqueWithoutCustomerInput | OrderUpsertWithWhereUniqueWithoutCustomerInput[]
    createMany?: OrderCreateManyCustomerInputEnvelope
    set?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    disconnect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    delete?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    connect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    update?: OrderUpdateWithWhereUniqueWithoutCustomerInput | OrderUpdateWithWhereUniqueWithoutCustomerInput[]
    updateMany?: OrderUpdateManyWithWhereWithoutCustomerInput | OrderUpdateManyWithWhereWithoutCustomerInput[]
    deleteMany?: OrderScalarWhereInput | OrderScalarWhereInput[]
  }

  export type PreOrderUpdateManyWithoutCustomerNestedInput = {
    create?: XOR<PreOrderCreateWithoutCustomerInput, PreOrderUncheckedCreateWithoutCustomerInput> | PreOrderCreateWithoutCustomerInput[] | PreOrderUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: PreOrderCreateOrConnectWithoutCustomerInput | PreOrderCreateOrConnectWithoutCustomerInput[]
    upsert?: PreOrderUpsertWithWhereUniqueWithoutCustomerInput | PreOrderUpsertWithWhereUniqueWithoutCustomerInput[]
    createMany?: PreOrderCreateManyCustomerInputEnvelope
    set?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
    disconnect?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
    delete?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
    connect?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
    update?: PreOrderUpdateWithWhereUniqueWithoutCustomerInput | PreOrderUpdateWithWhereUniqueWithoutCustomerInput[]
    updateMany?: PreOrderUpdateManyWithWhereWithoutCustomerInput | PreOrderUpdateManyWithWhereWithoutCustomerInput[]
    deleteMany?: PreOrderScalarWhereInput | PreOrderScalarWhereInput[]
  }

  export type LedgerEntryUpdateManyWithoutCustomerNestedInput = {
    create?: XOR<LedgerEntryCreateWithoutCustomerInput, LedgerEntryUncheckedCreateWithoutCustomerInput> | LedgerEntryCreateWithoutCustomerInput[] | LedgerEntryUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: LedgerEntryCreateOrConnectWithoutCustomerInput | LedgerEntryCreateOrConnectWithoutCustomerInput[]
    upsert?: LedgerEntryUpsertWithWhereUniqueWithoutCustomerInput | LedgerEntryUpsertWithWhereUniqueWithoutCustomerInput[]
    createMany?: LedgerEntryCreateManyCustomerInputEnvelope
    set?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
    disconnect?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
    delete?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
    connect?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
    update?: LedgerEntryUpdateWithWhereUniqueWithoutCustomerInput | LedgerEntryUpdateWithWhereUniqueWithoutCustomerInput[]
    updateMany?: LedgerEntryUpdateManyWithWhereWithoutCustomerInput | LedgerEntryUpdateManyWithWhereWithoutCustomerInput[]
    deleteMany?: LedgerEntryScalarWhereInput | LedgerEntryScalarWhereInput[]
  }

  export type WalletBonusUpdateManyWithoutCustomerNestedInput = {
    create?: XOR<WalletBonusCreateWithoutCustomerInput, WalletBonusUncheckedCreateWithoutCustomerInput> | WalletBonusCreateWithoutCustomerInput[] | WalletBonusUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: WalletBonusCreateOrConnectWithoutCustomerInput | WalletBonusCreateOrConnectWithoutCustomerInput[]
    upsert?: WalletBonusUpsertWithWhereUniqueWithoutCustomerInput | WalletBonusUpsertWithWhereUniqueWithoutCustomerInput[]
    createMany?: WalletBonusCreateManyCustomerInputEnvelope
    set?: WalletBonusWhereUniqueInput | WalletBonusWhereUniqueInput[]
    disconnect?: WalletBonusWhereUniqueInput | WalletBonusWhereUniqueInput[]
    delete?: WalletBonusWhereUniqueInput | WalletBonusWhereUniqueInput[]
    connect?: WalletBonusWhereUniqueInput | WalletBonusWhereUniqueInput[]
    update?: WalletBonusUpdateWithWhereUniqueWithoutCustomerInput | WalletBonusUpdateWithWhereUniqueWithoutCustomerInput[]
    updateMany?: WalletBonusUpdateManyWithWhereWithoutCustomerInput | WalletBonusUpdateManyWithWhereWithoutCustomerInput[]
    deleteMany?: WalletBonusScalarWhereInput | WalletBonusScalarWhereInput[]
  }

  export type CommentUpdateManyWithoutCustomerNestedInput = {
    create?: XOR<CommentCreateWithoutCustomerInput, CommentUncheckedCreateWithoutCustomerInput> | CommentCreateWithoutCustomerInput[] | CommentUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: CommentCreateOrConnectWithoutCustomerInput | CommentCreateOrConnectWithoutCustomerInput[]
    upsert?: CommentUpsertWithWhereUniqueWithoutCustomerInput | CommentUpsertWithWhereUniqueWithoutCustomerInput[]
    createMany?: CommentCreateManyCustomerInputEnvelope
    set?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
    disconnect?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
    delete?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
    connect?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
    update?: CommentUpdateWithWhereUniqueWithoutCustomerInput | CommentUpdateWithWhereUniqueWithoutCustomerInput[]
    updateMany?: CommentUpdateManyWithWhereWithoutCustomerInput | CommentUpdateManyWithWhereWithoutCustomerInput[]
    deleteMany?: CommentScalarWhereInput | CommentScalarWhereInput[]
  }

  export type PromotionUpdateManyWithoutCustomerNestedInput = {
    create?: XOR<PromotionCreateWithoutCustomerInput, PromotionUncheckedCreateWithoutCustomerInput> | PromotionCreateWithoutCustomerInput[] | PromotionUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: PromotionCreateOrConnectWithoutCustomerInput | PromotionCreateOrConnectWithoutCustomerInput[]
    upsert?: PromotionUpsertWithWhereUniqueWithoutCustomerInput | PromotionUpsertWithWhereUniqueWithoutCustomerInput[]
    createMany?: PromotionCreateManyCustomerInputEnvelope
    set?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    disconnect?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    delete?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    connect?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    update?: PromotionUpdateWithWhereUniqueWithoutCustomerInput | PromotionUpdateWithWhereUniqueWithoutCustomerInput[]
    updateMany?: PromotionUpdateManyWithWhereWithoutCustomerInput | PromotionUpdateManyWithWhereWithoutCustomerInput[]
    deleteMany?: PromotionScalarWhereInput | PromotionScalarWhereInput[]
  }

  export type NotificationRecipientUpdateManyWithoutCustomerNestedInput = {
    create?: XOR<NotificationRecipientCreateWithoutCustomerInput, NotificationRecipientUncheckedCreateWithoutCustomerInput> | NotificationRecipientCreateWithoutCustomerInput[] | NotificationRecipientUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: NotificationRecipientCreateOrConnectWithoutCustomerInput | NotificationRecipientCreateOrConnectWithoutCustomerInput[]
    upsert?: NotificationRecipientUpsertWithWhereUniqueWithoutCustomerInput | NotificationRecipientUpsertWithWhereUniqueWithoutCustomerInput[]
    createMany?: NotificationRecipientCreateManyCustomerInputEnvelope
    set?: NotificationRecipientWhereUniqueInput | NotificationRecipientWhereUniqueInput[]
    disconnect?: NotificationRecipientWhereUniqueInput | NotificationRecipientWhereUniqueInput[]
    delete?: NotificationRecipientWhereUniqueInput | NotificationRecipientWhereUniqueInput[]
    connect?: NotificationRecipientWhereUniqueInput | NotificationRecipientWhereUniqueInput[]
    update?: NotificationRecipientUpdateWithWhereUniqueWithoutCustomerInput | NotificationRecipientUpdateWithWhereUniqueWithoutCustomerInput[]
    updateMany?: NotificationRecipientUpdateManyWithWhereWithoutCustomerInput | NotificationRecipientUpdateManyWithWhereWithoutCustomerInput[]
    deleteMany?: NotificationRecipientScalarWhereInput | NotificationRecipientScalarWhereInput[]
  }

  export type CustomerActivityLogUpdateManyWithoutCustomerNestedInput = {
    create?: XOR<CustomerActivityLogCreateWithoutCustomerInput, CustomerActivityLogUncheckedCreateWithoutCustomerInput> | CustomerActivityLogCreateWithoutCustomerInput[] | CustomerActivityLogUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: CustomerActivityLogCreateOrConnectWithoutCustomerInput | CustomerActivityLogCreateOrConnectWithoutCustomerInput[]
    upsert?: CustomerActivityLogUpsertWithWhereUniqueWithoutCustomerInput | CustomerActivityLogUpsertWithWhereUniqueWithoutCustomerInput[]
    createMany?: CustomerActivityLogCreateManyCustomerInputEnvelope
    set?: CustomerActivityLogWhereUniqueInput | CustomerActivityLogWhereUniqueInput[]
    disconnect?: CustomerActivityLogWhereUniqueInput | CustomerActivityLogWhereUniqueInput[]
    delete?: CustomerActivityLogWhereUniqueInput | CustomerActivityLogWhereUniqueInput[]
    connect?: CustomerActivityLogWhereUniqueInput | CustomerActivityLogWhereUniqueInput[]
    update?: CustomerActivityLogUpdateWithWhereUniqueWithoutCustomerInput | CustomerActivityLogUpdateWithWhereUniqueWithoutCustomerInput[]
    updateMany?: CustomerActivityLogUpdateManyWithWhereWithoutCustomerInput | CustomerActivityLogUpdateManyWithWhereWithoutCustomerInput[]
    deleteMany?: CustomerActivityLogScalarWhereInput | CustomerActivityLogScalarWhereInput[]
  }

  export type CustomerOtpUpdateManyWithoutCustomerNestedInput = {
    create?: XOR<CustomerOtpCreateWithoutCustomerInput, CustomerOtpUncheckedCreateWithoutCustomerInput> | CustomerOtpCreateWithoutCustomerInput[] | CustomerOtpUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: CustomerOtpCreateOrConnectWithoutCustomerInput | CustomerOtpCreateOrConnectWithoutCustomerInput[]
    upsert?: CustomerOtpUpsertWithWhereUniqueWithoutCustomerInput | CustomerOtpUpsertWithWhereUniqueWithoutCustomerInput[]
    createMany?: CustomerOtpCreateManyCustomerInputEnvelope
    set?: CustomerOtpWhereUniqueInput | CustomerOtpWhereUniqueInput[]
    disconnect?: CustomerOtpWhereUniqueInput | CustomerOtpWhereUniqueInput[]
    delete?: CustomerOtpWhereUniqueInput | CustomerOtpWhereUniqueInput[]
    connect?: CustomerOtpWhereUniqueInput | CustomerOtpWhereUniqueInput[]
    update?: CustomerOtpUpdateWithWhereUniqueWithoutCustomerInput | CustomerOtpUpdateWithWhereUniqueWithoutCustomerInput[]
    updateMany?: CustomerOtpUpdateManyWithWhereWithoutCustomerInput | CustomerOtpUpdateManyWithWhereWithoutCustomerInput[]
    deleteMany?: CustomerOtpScalarWhereInput | CustomerOtpScalarWhereInput[]
  }

  export type SalesExpertProfileUncheckedUpdateOneWithoutTradingCustomerNestedInput = {
    create?: XOR<SalesExpertProfileCreateWithoutTradingCustomerInput, SalesExpertProfileUncheckedCreateWithoutTradingCustomerInput>
    connectOrCreate?: SalesExpertProfileCreateOrConnectWithoutTradingCustomerInput
    upsert?: SalesExpertProfileUpsertWithoutTradingCustomerInput
    disconnect?: SalesExpertProfileWhereInput | boolean
    delete?: SalesExpertProfileWhereInput | boolean
    connect?: SalesExpertProfileWhereUniqueInput
    update?: XOR<XOR<SalesExpertProfileUpdateToOneWithWhereWithoutTradingCustomerInput, SalesExpertProfileUpdateWithoutTradingCustomerInput>, SalesExpertProfileUncheckedUpdateWithoutTradingCustomerInput>
  }

  export type CustomerAddressUncheckedUpdateManyWithoutCustomerNestedInput = {
    create?: XOR<CustomerAddressCreateWithoutCustomerInput, CustomerAddressUncheckedCreateWithoutCustomerInput> | CustomerAddressCreateWithoutCustomerInput[] | CustomerAddressUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: CustomerAddressCreateOrConnectWithoutCustomerInput | CustomerAddressCreateOrConnectWithoutCustomerInput[]
    upsert?: CustomerAddressUpsertWithWhereUniqueWithoutCustomerInput | CustomerAddressUpsertWithWhereUniqueWithoutCustomerInput[]
    createMany?: CustomerAddressCreateManyCustomerInputEnvelope
    set?: CustomerAddressWhereUniqueInput | CustomerAddressWhereUniqueInput[]
    disconnect?: CustomerAddressWhereUniqueInput | CustomerAddressWhereUniqueInput[]
    delete?: CustomerAddressWhereUniqueInput | CustomerAddressWhereUniqueInput[]
    connect?: CustomerAddressWhereUniqueInput | CustomerAddressWhereUniqueInput[]
    update?: CustomerAddressUpdateWithWhereUniqueWithoutCustomerInput | CustomerAddressUpdateWithWhereUniqueWithoutCustomerInput[]
    updateMany?: CustomerAddressUpdateManyWithWhereWithoutCustomerInput | CustomerAddressUpdateManyWithWhereWithoutCustomerInput[]
    deleteMany?: CustomerAddressScalarWhereInput | CustomerAddressScalarWhereInput[]
  }

  export type OrderUncheckedUpdateManyWithoutCustomerNestedInput = {
    create?: XOR<OrderCreateWithoutCustomerInput, OrderUncheckedCreateWithoutCustomerInput> | OrderCreateWithoutCustomerInput[] | OrderUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: OrderCreateOrConnectWithoutCustomerInput | OrderCreateOrConnectWithoutCustomerInput[]
    upsert?: OrderUpsertWithWhereUniqueWithoutCustomerInput | OrderUpsertWithWhereUniqueWithoutCustomerInput[]
    createMany?: OrderCreateManyCustomerInputEnvelope
    set?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    disconnect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    delete?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    connect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    update?: OrderUpdateWithWhereUniqueWithoutCustomerInput | OrderUpdateWithWhereUniqueWithoutCustomerInput[]
    updateMany?: OrderUpdateManyWithWhereWithoutCustomerInput | OrderUpdateManyWithWhereWithoutCustomerInput[]
    deleteMany?: OrderScalarWhereInput | OrderScalarWhereInput[]
  }

  export type PreOrderUncheckedUpdateManyWithoutCustomerNestedInput = {
    create?: XOR<PreOrderCreateWithoutCustomerInput, PreOrderUncheckedCreateWithoutCustomerInput> | PreOrderCreateWithoutCustomerInput[] | PreOrderUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: PreOrderCreateOrConnectWithoutCustomerInput | PreOrderCreateOrConnectWithoutCustomerInput[]
    upsert?: PreOrderUpsertWithWhereUniqueWithoutCustomerInput | PreOrderUpsertWithWhereUniqueWithoutCustomerInput[]
    createMany?: PreOrderCreateManyCustomerInputEnvelope
    set?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
    disconnect?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
    delete?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
    connect?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
    update?: PreOrderUpdateWithWhereUniqueWithoutCustomerInput | PreOrderUpdateWithWhereUniqueWithoutCustomerInput[]
    updateMany?: PreOrderUpdateManyWithWhereWithoutCustomerInput | PreOrderUpdateManyWithWhereWithoutCustomerInput[]
    deleteMany?: PreOrderScalarWhereInput | PreOrderScalarWhereInput[]
  }

  export type LedgerEntryUncheckedUpdateManyWithoutCustomerNestedInput = {
    create?: XOR<LedgerEntryCreateWithoutCustomerInput, LedgerEntryUncheckedCreateWithoutCustomerInput> | LedgerEntryCreateWithoutCustomerInput[] | LedgerEntryUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: LedgerEntryCreateOrConnectWithoutCustomerInput | LedgerEntryCreateOrConnectWithoutCustomerInput[]
    upsert?: LedgerEntryUpsertWithWhereUniqueWithoutCustomerInput | LedgerEntryUpsertWithWhereUniqueWithoutCustomerInput[]
    createMany?: LedgerEntryCreateManyCustomerInputEnvelope
    set?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
    disconnect?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
    delete?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
    connect?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
    update?: LedgerEntryUpdateWithWhereUniqueWithoutCustomerInput | LedgerEntryUpdateWithWhereUniqueWithoutCustomerInput[]
    updateMany?: LedgerEntryUpdateManyWithWhereWithoutCustomerInput | LedgerEntryUpdateManyWithWhereWithoutCustomerInput[]
    deleteMany?: LedgerEntryScalarWhereInput | LedgerEntryScalarWhereInput[]
  }

  export type WalletBonusUncheckedUpdateManyWithoutCustomerNestedInput = {
    create?: XOR<WalletBonusCreateWithoutCustomerInput, WalletBonusUncheckedCreateWithoutCustomerInput> | WalletBonusCreateWithoutCustomerInput[] | WalletBonusUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: WalletBonusCreateOrConnectWithoutCustomerInput | WalletBonusCreateOrConnectWithoutCustomerInput[]
    upsert?: WalletBonusUpsertWithWhereUniqueWithoutCustomerInput | WalletBonusUpsertWithWhereUniqueWithoutCustomerInput[]
    createMany?: WalletBonusCreateManyCustomerInputEnvelope
    set?: WalletBonusWhereUniqueInput | WalletBonusWhereUniqueInput[]
    disconnect?: WalletBonusWhereUniqueInput | WalletBonusWhereUniqueInput[]
    delete?: WalletBonusWhereUniqueInput | WalletBonusWhereUniqueInput[]
    connect?: WalletBonusWhereUniqueInput | WalletBonusWhereUniqueInput[]
    update?: WalletBonusUpdateWithWhereUniqueWithoutCustomerInput | WalletBonusUpdateWithWhereUniqueWithoutCustomerInput[]
    updateMany?: WalletBonusUpdateManyWithWhereWithoutCustomerInput | WalletBonusUpdateManyWithWhereWithoutCustomerInput[]
    deleteMany?: WalletBonusScalarWhereInput | WalletBonusScalarWhereInput[]
  }

  export type CommentUncheckedUpdateManyWithoutCustomerNestedInput = {
    create?: XOR<CommentCreateWithoutCustomerInput, CommentUncheckedCreateWithoutCustomerInput> | CommentCreateWithoutCustomerInput[] | CommentUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: CommentCreateOrConnectWithoutCustomerInput | CommentCreateOrConnectWithoutCustomerInput[]
    upsert?: CommentUpsertWithWhereUniqueWithoutCustomerInput | CommentUpsertWithWhereUniqueWithoutCustomerInput[]
    createMany?: CommentCreateManyCustomerInputEnvelope
    set?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
    disconnect?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
    delete?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
    connect?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
    update?: CommentUpdateWithWhereUniqueWithoutCustomerInput | CommentUpdateWithWhereUniqueWithoutCustomerInput[]
    updateMany?: CommentUpdateManyWithWhereWithoutCustomerInput | CommentUpdateManyWithWhereWithoutCustomerInput[]
    deleteMany?: CommentScalarWhereInput | CommentScalarWhereInput[]
  }

  export type PromotionUncheckedUpdateManyWithoutCustomerNestedInput = {
    create?: XOR<PromotionCreateWithoutCustomerInput, PromotionUncheckedCreateWithoutCustomerInput> | PromotionCreateWithoutCustomerInput[] | PromotionUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: PromotionCreateOrConnectWithoutCustomerInput | PromotionCreateOrConnectWithoutCustomerInput[]
    upsert?: PromotionUpsertWithWhereUniqueWithoutCustomerInput | PromotionUpsertWithWhereUniqueWithoutCustomerInput[]
    createMany?: PromotionCreateManyCustomerInputEnvelope
    set?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    disconnect?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    delete?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    connect?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    update?: PromotionUpdateWithWhereUniqueWithoutCustomerInput | PromotionUpdateWithWhereUniqueWithoutCustomerInput[]
    updateMany?: PromotionUpdateManyWithWhereWithoutCustomerInput | PromotionUpdateManyWithWhereWithoutCustomerInput[]
    deleteMany?: PromotionScalarWhereInput | PromotionScalarWhereInput[]
  }

  export type NotificationRecipientUncheckedUpdateManyWithoutCustomerNestedInput = {
    create?: XOR<NotificationRecipientCreateWithoutCustomerInput, NotificationRecipientUncheckedCreateWithoutCustomerInput> | NotificationRecipientCreateWithoutCustomerInput[] | NotificationRecipientUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: NotificationRecipientCreateOrConnectWithoutCustomerInput | NotificationRecipientCreateOrConnectWithoutCustomerInput[]
    upsert?: NotificationRecipientUpsertWithWhereUniqueWithoutCustomerInput | NotificationRecipientUpsertWithWhereUniqueWithoutCustomerInput[]
    createMany?: NotificationRecipientCreateManyCustomerInputEnvelope
    set?: NotificationRecipientWhereUniqueInput | NotificationRecipientWhereUniqueInput[]
    disconnect?: NotificationRecipientWhereUniqueInput | NotificationRecipientWhereUniqueInput[]
    delete?: NotificationRecipientWhereUniqueInput | NotificationRecipientWhereUniqueInput[]
    connect?: NotificationRecipientWhereUniqueInput | NotificationRecipientWhereUniqueInput[]
    update?: NotificationRecipientUpdateWithWhereUniqueWithoutCustomerInput | NotificationRecipientUpdateWithWhereUniqueWithoutCustomerInput[]
    updateMany?: NotificationRecipientUpdateManyWithWhereWithoutCustomerInput | NotificationRecipientUpdateManyWithWhereWithoutCustomerInput[]
    deleteMany?: NotificationRecipientScalarWhereInput | NotificationRecipientScalarWhereInput[]
  }

  export type CustomerActivityLogUncheckedUpdateManyWithoutCustomerNestedInput = {
    create?: XOR<CustomerActivityLogCreateWithoutCustomerInput, CustomerActivityLogUncheckedCreateWithoutCustomerInput> | CustomerActivityLogCreateWithoutCustomerInput[] | CustomerActivityLogUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: CustomerActivityLogCreateOrConnectWithoutCustomerInput | CustomerActivityLogCreateOrConnectWithoutCustomerInput[]
    upsert?: CustomerActivityLogUpsertWithWhereUniqueWithoutCustomerInput | CustomerActivityLogUpsertWithWhereUniqueWithoutCustomerInput[]
    createMany?: CustomerActivityLogCreateManyCustomerInputEnvelope
    set?: CustomerActivityLogWhereUniqueInput | CustomerActivityLogWhereUniqueInput[]
    disconnect?: CustomerActivityLogWhereUniqueInput | CustomerActivityLogWhereUniqueInput[]
    delete?: CustomerActivityLogWhereUniqueInput | CustomerActivityLogWhereUniqueInput[]
    connect?: CustomerActivityLogWhereUniqueInput | CustomerActivityLogWhereUniqueInput[]
    update?: CustomerActivityLogUpdateWithWhereUniqueWithoutCustomerInput | CustomerActivityLogUpdateWithWhereUniqueWithoutCustomerInput[]
    updateMany?: CustomerActivityLogUpdateManyWithWhereWithoutCustomerInput | CustomerActivityLogUpdateManyWithWhereWithoutCustomerInput[]
    deleteMany?: CustomerActivityLogScalarWhereInput | CustomerActivityLogScalarWhereInput[]
  }

  export type CustomerOtpUncheckedUpdateManyWithoutCustomerNestedInput = {
    create?: XOR<CustomerOtpCreateWithoutCustomerInput, CustomerOtpUncheckedCreateWithoutCustomerInput> | CustomerOtpCreateWithoutCustomerInput[] | CustomerOtpUncheckedCreateWithoutCustomerInput[]
    connectOrCreate?: CustomerOtpCreateOrConnectWithoutCustomerInput | CustomerOtpCreateOrConnectWithoutCustomerInput[]
    upsert?: CustomerOtpUpsertWithWhereUniqueWithoutCustomerInput | CustomerOtpUpsertWithWhereUniqueWithoutCustomerInput[]
    createMany?: CustomerOtpCreateManyCustomerInputEnvelope
    set?: CustomerOtpWhereUniqueInput | CustomerOtpWhereUniqueInput[]
    disconnect?: CustomerOtpWhereUniqueInput | CustomerOtpWhereUniqueInput[]
    delete?: CustomerOtpWhereUniqueInput | CustomerOtpWhereUniqueInput[]
    connect?: CustomerOtpWhereUniqueInput | CustomerOtpWhereUniqueInput[]
    update?: CustomerOtpUpdateWithWhereUniqueWithoutCustomerInput | CustomerOtpUpdateWithWhereUniqueWithoutCustomerInput[]
    updateMany?: CustomerOtpUpdateManyWithWhereWithoutCustomerInput | CustomerOtpUpdateManyWithWhereWithoutCustomerInput[]
    deleteMany?: CustomerOtpScalarWhereInput | CustomerOtpScalarWhereInput[]
  }

  export type CustomerCreateNestedOneWithoutAddressesInput = {
    create?: XOR<CustomerCreateWithoutAddressesInput, CustomerUncheckedCreateWithoutAddressesInput>
    connectOrCreate?: CustomerCreateOrConnectWithoutAddressesInput
    connect?: CustomerWhereUniqueInput
  }

  export type CityCreateNestedOneWithoutAddressesInput = {
    create?: XOR<CityCreateWithoutAddressesInput, CityUncheckedCreateWithoutAddressesInput>
    connectOrCreate?: CityCreateOrConnectWithoutAddressesInput
    connect?: CityWhereUniqueInput
  }

  export type CustomerUpdateOneRequiredWithoutAddressesNestedInput = {
    create?: XOR<CustomerCreateWithoutAddressesInput, CustomerUncheckedCreateWithoutAddressesInput>
    connectOrCreate?: CustomerCreateOrConnectWithoutAddressesInput
    upsert?: CustomerUpsertWithoutAddressesInput
    connect?: CustomerWhereUniqueInput
    update?: XOR<XOR<CustomerUpdateToOneWithWhereWithoutAddressesInput, CustomerUpdateWithoutAddressesInput>, CustomerUncheckedUpdateWithoutAddressesInput>
  }

  export type CityUpdateOneWithoutAddressesNestedInput = {
    create?: XOR<CityCreateWithoutAddressesInput, CityUncheckedCreateWithoutAddressesInput>
    connectOrCreate?: CityCreateOrConnectWithoutAddressesInput
    upsert?: CityUpsertWithoutAddressesInput
    disconnect?: CityWhereInput | boolean
    delete?: CityWhereInput | boolean
    connect?: CityWhereUniqueInput
    update?: XOR<XOR<CityUpdateToOneWithWhereWithoutAddressesInput, CityUpdateWithoutAddressesInput>, CityUncheckedUpdateWithoutAddressesInput>
  }

  export type CityCreateNestedOneWithoutBranchesInput = {
    create?: XOR<CityCreateWithoutBranchesInput, CityUncheckedCreateWithoutBranchesInput>
    connectOrCreate?: CityCreateOrConnectWithoutBranchesInput
    connect?: CityWhereUniqueInput
  }

  export type AdminUserCreateNestedManyWithoutBranchInput = {
    create?: XOR<AdminUserCreateWithoutBranchInput, AdminUserUncheckedCreateWithoutBranchInput> | AdminUserCreateWithoutBranchInput[] | AdminUserUncheckedCreateWithoutBranchInput[]
    connectOrCreate?: AdminUserCreateOrConnectWithoutBranchInput | AdminUserCreateOrConnectWithoutBranchInput[]
    createMany?: AdminUserCreateManyBranchInputEnvelope
    connect?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
  }

  export type OrderCreateNestedManyWithoutBranchInput = {
    create?: XOR<OrderCreateWithoutBranchInput, OrderUncheckedCreateWithoutBranchInput> | OrderCreateWithoutBranchInput[] | OrderUncheckedCreateWithoutBranchInput[]
    connectOrCreate?: OrderCreateOrConnectWithoutBranchInput | OrderCreateOrConnectWithoutBranchInput[]
    createMany?: OrderCreateManyBranchInputEnvelope
    connect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
  }

  export type BranchAllocationCreateNestedManyWithoutBranchInput = {
    create?: XOR<BranchAllocationCreateWithoutBranchInput, BranchAllocationUncheckedCreateWithoutBranchInput> | BranchAllocationCreateWithoutBranchInput[] | BranchAllocationUncheckedCreateWithoutBranchInput[]
    connectOrCreate?: BranchAllocationCreateOrConnectWithoutBranchInput | BranchAllocationCreateOrConnectWithoutBranchInput[]
    createMany?: BranchAllocationCreateManyBranchInputEnvelope
    connect?: BranchAllocationWhereUniqueInput | BranchAllocationWhereUniqueInput[]
  }

  export type AdminUserUncheckedCreateNestedManyWithoutBranchInput = {
    create?: XOR<AdminUserCreateWithoutBranchInput, AdminUserUncheckedCreateWithoutBranchInput> | AdminUserCreateWithoutBranchInput[] | AdminUserUncheckedCreateWithoutBranchInput[]
    connectOrCreate?: AdminUserCreateOrConnectWithoutBranchInput | AdminUserCreateOrConnectWithoutBranchInput[]
    createMany?: AdminUserCreateManyBranchInputEnvelope
    connect?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
  }

  export type OrderUncheckedCreateNestedManyWithoutBranchInput = {
    create?: XOR<OrderCreateWithoutBranchInput, OrderUncheckedCreateWithoutBranchInput> | OrderCreateWithoutBranchInput[] | OrderUncheckedCreateWithoutBranchInput[]
    connectOrCreate?: OrderCreateOrConnectWithoutBranchInput | OrderCreateOrConnectWithoutBranchInput[]
    createMany?: OrderCreateManyBranchInputEnvelope
    connect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
  }

  export type BranchAllocationUncheckedCreateNestedManyWithoutBranchInput = {
    create?: XOR<BranchAllocationCreateWithoutBranchInput, BranchAllocationUncheckedCreateWithoutBranchInput> | BranchAllocationCreateWithoutBranchInput[] | BranchAllocationUncheckedCreateWithoutBranchInput[]
    connectOrCreate?: BranchAllocationCreateOrConnectWithoutBranchInput | BranchAllocationCreateOrConnectWithoutBranchInput[]
    createMany?: BranchAllocationCreateManyBranchInputEnvelope
    connect?: BranchAllocationWhereUniqueInput | BranchAllocationWhereUniqueInput[]
  }

  export type CityUpdateOneWithoutBranchesNestedInput = {
    create?: XOR<CityCreateWithoutBranchesInput, CityUncheckedCreateWithoutBranchesInput>
    connectOrCreate?: CityCreateOrConnectWithoutBranchesInput
    upsert?: CityUpsertWithoutBranchesInput
    disconnect?: CityWhereInput | boolean
    delete?: CityWhereInput | boolean
    connect?: CityWhereUniqueInput
    update?: XOR<XOR<CityUpdateToOneWithWhereWithoutBranchesInput, CityUpdateWithoutBranchesInput>, CityUncheckedUpdateWithoutBranchesInput>
  }

  export type AdminUserUpdateManyWithoutBranchNestedInput = {
    create?: XOR<AdminUserCreateWithoutBranchInput, AdminUserUncheckedCreateWithoutBranchInput> | AdminUserCreateWithoutBranchInput[] | AdminUserUncheckedCreateWithoutBranchInput[]
    connectOrCreate?: AdminUserCreateOrConnectWithoutBranchInput | AdminUserCreateOrConnectWithoutBranchInput[]
    upsert?: AdminUserUpsertWithWhereUniqueWithoutBranchInput | AdminUserUpsertWithWhereUniqueWithoutBranchInput[]
    createMany?: AdminUserCreateManyBranchInputEnvelope
    set?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
    disconnect?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
    delete?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
    connect?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
    update?: AdminUserUpdateWithWhereUniqueWithoutBranchInput | AdminUserUpdateWithWhereUniqueWithoutBranchInput[]
    updateMany?: AdminUserUpdateManyWithWhereWithoutBranchInput | AdminUserUpdateManyWithWhereWithoutBranchInput[]
    deleteMany?: AdminUserScalarWhereInput | AdminUserScalarWhereInput[]
  }

  export type OrderUpdateManyWithoutBranchNestedInput = {
    create?: XOR<OrderCreateWithoutBranchInput, OrderUncheckedCreateWithoutBranchInput> | OrderCreateWithoutBranchInput[] | OrderUncheckedCreateWithoutBranchInput[]
    connectOrCreate?: OrderCreateOrConnectWithoutBranchInput | OrderCreateOrConnectWithoutBranchInput[]
    upsert?: OrderUpsertWithWhereUniqueWithoutBranchInput | OrderUpsertWithWhereUniqueWithoutBranchInput[]
    createMany?: OrderCreateManyBranchInputEnvelope
    set?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    disconnect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    delete?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    connect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    update?: OrderUpdateWithWhereUniqueWithoutBranchInput | OrderUpdateWithWhereUniqueWithoutBranchInput[]
    updateMany?: OrderUpdateManyWithWhereWithoutBranchInput | OrderUpdateManyWithWhereWithoutBranchInput[]
    deleteMany?: OrderScalarWhereInput | OrderScalarWhereInput[]
  }

  export type BranchAllocationUpdateManyWithoutBranchNestedInput = {
    create?: XOR<BranchAllocationCreateWithoutBranchInput, BranchAllocationUncheckedCreateWithoutBranchInput> | BranchAllocationCreateWithoutBranchInput[] | BranchAllocationUncheckedCreateWithoutBranchInput[]
    connectOrCreate?: BranchAllocationCreateOrConnectWithoutBranchInput | BranchAllocationCreateOrConnectWithoutBranchInput[]
    upsert?: BranchAllocationUpsertWithWhereUniqueWithoutBranchInput | BranchAllocationUpsertWithWhereUniqueWithoutBranchInput[]
    createMany?: BranchAllocationCreateManyBranchInputEnvelope
    set?: BranchAllocationWhereUniqueInput | BranchAllocationWhereUniqueInput[]
    disconnect?: BranchAllocationWhereUniqueInput | BranchAllocationWhereUniqueInput[]
    delete?: BranchAllocationWhereUniqueInput | BranchAllocationWhereUniqueInput[]
    connect?: BranchAllocationWhereUniqueInput | BranchAllocationWhereUniqueInput[]
    update?: BranchAllocationUpdateWithWhereUniqueWithoutBranchInput | BranchAllocationUpdateWithWhereUniqueWithoutBranchInput[]
    updateMany?: BranchAllocationUpdateManyWithWhereWithoutBranchInput | BranchAllocationUpdateManyWithWhereWithoutBranchInput[]
    deleteMany?: BranchAllocationScalarWhereInput | BranchAllocationScalarWhereInput[]
  }

  export type AdminUserUncheckedUpdateManyWithoutBranchNestedInput = {
    create?: XOR<AdminUserCreateWithoutBranchInput, AdminUserUncheckedCreateWithoutBranchInput> | AdminUserCreateWithoutBranchInput[] | AdminUserUncheckedCreateWithoutBranchInput[]
    connectOrCreate?: AdminUserCreateOrConnectWithoutBranchInput | AdminUserCreateOrConnectWithoutBranchInput[]
    upsert?: AdminUserUpsertWithWhereUniqueWithoutBranchInput | AdminUserUpsertWithWhereUniqueWithoutBranchInput[]
    createMany?: AdminUserCreateManyBranchInputEnvelope
    set?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
    disconnect?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
    delete?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
    connect?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
    update?: AdminUserUpdateWithWhereUniqueWithoutBranchInput | AdminUserUpdateWithWhereUniqueWithoutBranchInput[]
    updateMany?: AdminUserUpdateManyWithWhereWithoutBranchInput | AdminUserUpdateManyWithWhereWithoutBranchInput[]
    deleteMany?: AdminUserScalarWhereInput | AdminUserScalarWhereInput[]
  }

  export type OrderUncheckedUpdateManyWithoutBranchNestedInput = {
    create?: XOR<OrderCreateWithoutBranchInput, OrderUncheckedCreateWithoutBranchInput> | OrderCreateWithoutBranchInput[] | OrderUncheckedCreateWithoutBranchInput[]
    connectOrCreate?: OrderCreateOrConnectWithoutBranchInput | OrderCreateOrConnectWithoutBranchInput[]
    upsert?: OrderUpsertWithWhereUniqueWithoutBranchInput | OrderUpsertWithWhereUniqueWithoutBranchInput[]
    createMany?: OrderCreateManyBranchInputEnvelope
    set?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    disconnect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    delete?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    connect?: OrderWhereUniqueInput | OrderWhereUniqueInput[]
    update?: OrderUpdateWithWhereUniqueWithoutBranchInput | OrderUpdateWithWhereUniqueWithoutBranchInput[]
    updateMany?: OrderUpdateManyWithWhereWithoutBranchInput | OrderUpdateManyWithWhereWithoutBranchInput[]
    deleteMany?: OrderScalarWhereInput | OrderScalarWhereInput[]
  }

  export type BranchAllocationUncheckedUpdateManyWithoutBranchNestedInput = {
    create?: XOR<BranchAllocationCreateWithoutBranchInput, BranchAllocationUncheckedCreateWithoutBranchInput> | BranchAllocationCreateWithoutBranchInput[] | BranchAllocationUncheckedCreateWithoutBranchInput[]
    connectOrCreate?: BranchAllocationCreateOrConnectWithoutBranchInput | BranchAllocationCreateOrConnectWithoutBranchInput[]
    upsert?: BranchAllocationUpsertWithWhereUniqueWithoutBranchInput | BranchAllocationUpsertWithWhereUniqueWithoutBranchInput[]
    createMany?: BranchAllocationCreateManyBranchInputEnvelope
    set?: BranchAllocationWhereUniqueInput | BranchAllocationWhereUniqueInput[]
    disconnect?: BranchAllocationWhereUniqueInput | BranchAllocationWhereUniqueInput[]
    delete?: BranchAllocationWhereUniqueInput | BranchAllocationWhereUniqueInput[]
    connect?: BranchAllocationWhereUniqueInput | BranchAllocationWhereUniqueInput[]
    update?: BranchAllocationUpdateWithWhereUniqueWithoutBranchInput | BranchAllocationUpdateWithWhereUniqueWithoutBranchInput[]
    updateMany?: BranchAllocationUpdateManyWithWhereWithoutBranchInput | BranchAllocationUpdateManyWithWhereWithoutBranchInput[]
    deleteMany?: BranchAllocationScalarWhereInput | BranchAllocationScalarWhereInput[]
  }

  export type AdminUserCreateNestedOneWithoutSupervisedWorkshopsInput = {
    create?: XOR<AdminUserCreateWithoutSupervisedWorkshopsInput, AdminUserUncheckedCreateWithoutSupervisedWorkshopsInput>
    connectOrCreate?: AdminUserCreateOrConnectWithoutSupervisedWorkshopsInput
    connect?: AdminUserWhereUniqueInput
  }

  export type PreOrderCreateNestedManyWithoutWorkshopInput = {
    create?: XOR<PreOrderCreateWithoutWorkshopInput, PreOrderUncheckedCreateWithoutWorkshopInput> | PreOrderCreateWithoutWorkshopInput[] | PreOrderUncheckedCreateWithoutWorkshopInput[]
    connectOrCreate?: PreOrderCreateOrConnectWithoutWorkshopInput | PreOrderCreateOrConnectWithoutWorkshopInput[]
    createMany?: PreOrderCreateManyWorkshopInputEnvelope
    connect?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
  }

  export type PreOrderUncheckedCreateNestedManyWithoutWorkshopInput = {
    create?: XOR<PreOrderCreateWithoutWorkshopInput, PreOrderUncheckedCreateWithoutWorkshopInput> | PreOrderCreateWithoutWorkshopInput[] | PreOrderUncheckedCreateWithoutWorkshopInput[]
    connectOrCreate?: PreOrderCreateOrConnectWithoutWorkshopInput | PreOrderCreateOrConnectWithoutWorkshopInput[]
    createMany?: PreOrderCreateManyWorkshopInputEnvelope
    connect?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
  }

  export type AdminUserUpdateOneWithoutSupervisedWorkshopsNestedInput = {
    create?: XOR<AdminUserCreateWithoutSupervisedWorkshopsInput, AdminUserUncheckedCreateWithoutSupervisedWorkshopsInput>
    connectOrCreate?: AdminUserCreateOrConnectWithoutSupervisedWorkshopsInput
    upsert?: AdminUserUpsertWithoutSupervisedWorkshopsInput
    disconnect?: AdminUserWhereInput | boolean
    delete?: AdminUserWhereInput | boolean
    connect?: AdminUserWhereUniqueInput
    update?: XOR<XOR<AdminUserUpdateToOneWithWhereWithoutSupervisedWorkshopsInput, AdminUserUpdateWithoutSupervisedWorkshopsInput>, AdminUserUncheckedUpdateWithoutSupervisedWorkshopsInput>
  }

  export type PreOrderUpdateManyWithoutWorkshopNestedInput = {
    create?: XOR<PreOrderCreateWithoutWorkshopInput, PreOrderUncheckedCreateWithoutWorkshopInput> | PreOrderCreateWithoutWorkshopInput[] | PreOrderUncheckedCreateWithoutWorkshopInput[]
    connectOrCreate?: PreOrderCreateOrConnectWithoutWorkshopInput | PreOrderCreateOrConnectWithoutWorkshopInput[]
    upsert?: PreOrderUpsertWithWhereUniqueWithoutWorkshopInput | PreOrderUpsertWithWhereUniqueWithoutWorkshopInput[]
    createMany?: PreOrderCreateManyWorkshopInputEnvelope
    set?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
    disconnect?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
    delete?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
    connect?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
    update?: PreOrderUpdateWithWhereUniqueWithoutWorkshopInput | PreOrderUpdateWithWhereUniqueWithoutWorkshopInput[]
    updateMany?: PreOrderUpdateManyWithWhereWithoutWorkshopInput | PreOrderUpdateManyWithWhereWithoutWorkshopInput[]
    deleteMany?: PreOrderScalarWhereInput | PreOrderScalarWhereInput[]
  }

  export type PreOrderUncheckedUpdateManyWithoutWorkshopNestedInput = {
    create?: XOR<PreOrderCreateWithoutWorkshopInput, PreOrderUncheckedCreateWithoutWorkshopInput> | PreOrderCreateWithoutWorkshopInput[] | PreOrderUncheckedCreateWithoutWorkshopInput[]
    connectOrCreate?: PreOrderCreateOrConnectWithoutWorkshopInput | PreOrderCreateOrConnectWithoutWorkshopInput[]
    upsert?: PreOrderUpsertWithWhereUniqueWithoutWorkshopInput | PreOrderUpsertWithWhereUniqueWithoutWorkshopInput[]
    createMany?: PreOrderCreateManyWorkshopInputEnvelope
    set?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
    disconnect?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
    delete?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
    connect?: PreOrderWhereUniqueInput | PreOrderWhereUniqueInput[]
    update?: PreOrderUpdateWithWhereUniqueWithoutWorkshopInput | PreOrderUpdateWithWhereUniqueWithoutWorkshopInput[]
    updateMany?: PreOrderUpdateManyWithWhereWithoutWorkshopInput | PreOrderUpdateManyWithWhereWithoutWorkshopInput[]
    deleteMany?: PreOrderScalarWhereInput | PreOrderScalarWhereInput[]
  }

  export type CategoryCreateNestedOneWithoutChildrenInput = {
    create?: XOR<CategoryCreateWithoutChildrenInput, CategoryUncheckedCreateWithoutChildrenInput>
    connectOrCreate?: CategoryCreateOrConnectWithoutChildrenInput
    connect?: CategoryWhereUniqueInput
  }

  export type CategoryCreateNestedManyWithoutParentInput = {
    create?: XOR<CategoryCreateWithoutParentInput, CategoryUncheckedCreateWithoutParentInput> | CategoryCreateWithoutParentInput[] | CategoryUncheckedCreateWithoutParentInput[]
    connectOrCreate?: CategoryCreateOrConnectWithoutParentInput | CategoryCreateOrConnectWithoutParentInput[]
    createMany?: CategoryCreateManyParentInputEnvelope
    connect?: CategoryWhereUniqueInput | CategoryWhereUniqueInput[]
  }

  export type ProductCreateNestedManyWithoutCategoryInput = {
    create?: XOR<ProductCreateWithoutCategoryInput, ProductUncheckedCreateWithoutCategoryInput> | ProductCreateWithoutCategoryInput[] | ProductUncheckedCreateWithoutCategoryInput[]
    connectOrCreate?: ProductCreateOrConnectWithoutCategoryInput | ProductCreateOrConnectWithoutCategoryInput[]
    createMany?: ProductCreateManyCategoryInputEnvelope
    connect?: ProductWhereUniqueInput | ProductWhereUniqueInput[]
  }

  export type PromotionCreateNestedManyWithoutCategoryInput = {
    create?: XOR<PromotionCreateWithoutCategoryInput, PromotionUncheckedCreateWithoutCategoryInput> | PromotionCreateWithoutCategoryInput[] | PromotionUncheckedCreateWithoutCategoryInput[]
    connectOrCreate?: PromotionCreateOrConnectWithoutCategoryInput | PromotionCreateOrConnectWithoutCategoryInput[]
    createMany?: PromotionCreateManyCategoryInputEnvelope
    connect?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
  }

  export type CategoryUncheckedCreateNestedManyWithoutParentInput = {
    create?: XOR<CategoryCreateWithoutParentInput, CategoryUncheckedCreateWithoutParentInput> | CategoryCreateWithoutParentInput[] | CategoryUncheckedCreateWithoutParentInput[]
    connectOrCreate?: CategoryCreateOrConnectWithoutParentInput | CategoryCreateOrConnectWithoutParentInput[]
    createMany?: CategoryCreateManyParentInputEnvelope
    connect?: CategoryWhereUniqueInput | CategoryWhereUniqueInput[]
  }

  export type ProductUncheckedCreateNestedManyWithoutCategoryInput = {
    create?: XOR<ProductCreateWithoutCategoryInput, ProductUncheckedCreateWithoutCategoryInput> | ProductCreateWithoutCategoryInput[] | ProductUncheckedCreateWithoutCategoryInput[]
    connectOrCreate?: ProductCreateOrConnectWithoutCategoryInput | ProductCreateOrConnectWithoutCategoryInput[]
    createMany?: ProductCreateManyCategoryInputEnvelope
    connect?: ProductWhereUniqueInput | ProductWhereUniqueInput[]
  }

  export type PromotionUncheckedCreateNestedManyWithoutCategoryInput = {
    create?: XOR<PromotionCreateWithoutCategoryInput, PromotionUncheckedCreateWithoutCategoryInput> | PromotionCreateWithoutCategoryInput[] | PromotionUncheckedCreateWithoutCategoryInput[]
    connectOrCreate?: PromotionCreateOrConnectWithoutCategoryInput | PromotionCreateOrConnectWithoutCategoryInput[]
    createMany?: PromotionCreateManyCategoryInputEnvelope
    connect?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
  }

  export type IntFieldUpdateOperationsInput = {
    set?: number
    increment?: number
    decrement?: number
    multiply?: number
    divide?: number
  }

  export type CategoryUpdateOneWithoutChildrenNestedInput = {
    create?: XOR<CategoryCreateWithoutChildrenInput, CategoryUncheckedCreateWithoutChildrenInput>
    connectOrCreate?: CategoryCreateOrConnectWithoutChildrenInput
    upsert?: CategoryUpsertWithoutChildrenInput
    disconnect?: CategoryWhereInput | boolean
    delete?: CategoryWhereInput | boolean
    connect?: CategoryWhereUniqueInput
    update?: XOR<XOR<CategoryUpdateToOneWithWhereWithoutChildrenInput, CategoryUpdateWithoutChildrenInput>, CategoryUncheckedUpdateWithoutChildrenInput>
  }

  export type CategoryUpdateManyWithoutParentNestedInput = {
    create?: XOR<CategoryCreateWithoutParentInput, CategoryUncheckedCreateWithoutParentInput> | CategoryCreateWithoutParentInput[] | CategoryUncheckedCreateWithoutParentInput[]
    connectOrCreate?: CategoryCreateOrConnectWithoutParentInput | CategoryCreateOrConnectWithoutParentInput[]
    upsert?: CategoryUpsertWithWhereUniqueWithoutParentInput | CategoryUpsertWithWhereUniqueWithoutParentInput[]
    createMany?: CategoryCreateManyParentInputEnvelope
    set?: CategoryWhereUniqueInput | CategoryWhereUniqueInput[]
    disconnect?: CategoryWhereUniqueInput | CategoryWhereUniqueInput[]
    delete?: CategoryWhereUniqueInput | CategoryWhereUniqueInput[]
    connect?: CategoryWhereUniqueInput | CategoryWhereUniqueInput[]
    update?: CategoryUpdateWithWhereUniqueWithoutParentInput | CategoryUpdateWithWhereUniqueWithoutParentInput[]
    updateMany?: CategoryUpdateManyWithWhereWithoutParentInput | CategoryUpdateManyWithWhereWithoutParentInput[]
    deleteMany?: CategoryScalarWhereInput | CategoryScalarWhereInput[]
  }

  export type ProductUpdateManyWithoutCategoryNestedInput = {
    create?: XOR<ProductCreateWithoutCategoryInput, ProductUncheckedCreateWithoutCategoryInput> | ProductCreateWithoutCategoryInput[] | ProductUncheckedCreateWithoutCategoryInput[]
    connectOrCreate?: ProductCreateOrConnectWithoutCategoryInput | ProductCreateOrConnectWithoutCategoryInput[]
    upsert?: ProductUpsertWithWhereUniqueWithoutCategoryInput | ProductUpsertWithWhereUniqueWithoutCategoryInput[]
    createMany?: ProductCreateManyCategoryInputEnvelope
    set?: ProductWhereUniqueInput | ProductWhereUniqueInput[]
    disconnect?: ProductWhereUniqueInput | ProductWhereUniqueInput[]
    delete?: ProductWhereUniqueInput | ProductWhereUniqueInput[]
    connect?: ProductWhereUniqueInput | ProductWhereUniqueInput[]
    update?: ProductUpdateWithWhereUniqueWithoutCategoryInput | ProductUpdateWithWhereUniqueWithoutCategoryInput[]
    updateMany?: ProductUpdateManyWithWhereWithoutCategoryInput | ProductUpdateManyWithWhereWithoutCategoryInput[]
    deleteMany?: ProductScalarWhereInput | ProductScalarWhereInput[]
  }

  export type PromotionUpdateManyWithoutCategoryNestedInput = {
    create?: XOR<PromotionCreateWithoutCategoryInput, PromotionUncheckedCreateWithoutCategoryInput> | PromotionCreateWithoutCategoryInput[] | PromotionUncheckedCreateWithoutCategoryInput[]
    connectOrCreate?: PromotionCreateOrConnectWithoutCategoryInput | PromotionCreateOrConnectWithoutCategoryInput[]
    upsert?: PromotionUpsertWithWhereUniqueWithoutCategoryInput | PromotionUpsertWithWhereUniqueWithoutCategoryInput[]
    createMany?: PromotionCreateManyCategoryInputEnvelope
    set?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    disconnect?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    delete?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    connect?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    update?: PromotionUpdateWithWhereUniqueWithoutCategoryInput | PromotionUpdateWithWhereUniqueWithoutCategoryInput[]
    updateMany?: PromotionUpdateManyWithWhereWithoutCategoryInput | PromotionUpdateManyWithWhereWithoutCategoryInput[]
    deleteMany?: PromotionScalarWhereInput | PromotionScalarWhereInput[]
  }

  export type CategoryUncheckedUpdateManyWithoutParentNestedInput = {
    create?: XOR<CategoryCreateWithoutParentInput, CategoryUncheckedCreateWithoutParentInput> | CategoryCreateWithoutParentInput[] | CategoryUncheckedCreateWithoutParentInput[]
    connectOrCreate?: CategoryCreateOrConnectWithoutParentInput | CategoryCreateOrConnectWithoutParentInput[]
    upsert?: CategoryUpsertWithWhereUniqueWithoutParentInput | CategoryUpsertWithWhereUniqueWithoutParentInput[]
    createMany?: CategoryCreateManyParentInputEnvelope
    set?: CategoryWhereUniqueInput | CategoryWhereUniqueInput[]
    disconnect?: CategoryWhereUniqueInput | CategoryWhereUniqueInput[]
    delete?: CategoryWhereUniqueInput | CategoryWhereUniqueInput[]
    connect?: CategoryWhereUniqueInput | CategoryWhereUniqueInput[]
    update?: CategoryUpdateWithWhereUniqueWithoutParentInput | CategoryUpdateWithWhereUniqueWithoutParentInput[]
    updateMany?: CategoryUpdateManyWithWhereWithoutParentInput | CategoryUpdateManyWithWhereWithoutParentInput[]
    deleteMany?: CategoryScalarWhereInput | CategoryScalarWhereInput[]
  }

  export type ProductUncheckedUpdateManyWithoutCategoryNestedInput = {
    create?: XOR<ProductCreateWithoutCategoryInput, ProductUncheckedCreateWithoutCategoryInput> | ProductCreateWithoutCategoryInput[] | ProductUncheckedCreateWithoutCategoryInput[]
    connectOrCreate?: ProductCreateOrConnectWithoutCategoryInput | ProductCreateOrConnectWithoutCategoryInput[]
    upsert?: ProductUpsertWithWhereUniqueWithoutCategoryInput | ProductUpsertWithWhereUniqueWithoutCategoryInput[]
    createMany?: ProductCreateManyCategoryInputEnvelope
    set?: ProductWhereUniqueInput | ProductWhereUniqueInput[]
    disconnect?: ProductWhereUniqueInput | ProductWhereUniqueInput[]
    delete?: ProductWhereUniqueInput | ProductWhereUniqueInput[]
    connect?: ProductWhereUniqueInput | ProductWhereUniqueInput[]
    update?: ProductUpdateWithWhereUniqueWithoutCategoryInput | ProductUpdateWithWhereUniqueWithoutCategoryInput[]
    updateMany?: ProductUpdateManyWithWhereWithoutCategoryInput | ProductUpdateManyWithWhereWithoutCategoryInput[]
    deleteMany?: ProductScalarWhereInput | ProductScalarWhereInput[]
  }

  export type PromotionUncheckedUpdateManyWithoutCategoryNestedInput = {
    create?: XOR<PromotionCreateWithoutCategoryInput, PromotionUncheckedCreateWithoutCategoryInput> | PromotionCreateWithoutCategoryInput[] | PromotionUncheckedCreateWithoutCategoryInput[]
    connectOrCreate?: PromotionCreateOrConnectWithoutCategoryInput | PromotionCreateOrConnectWithoutCategoryInput[]
    upsert?: PromotionUpsertWithWhereUniqueWithoutCategoryInput | PromotionUpsertWithWhereUniqueWithoutCategoryInput[]
    createMany?: PromotionCreateManyCategoryInputEnvelope
    set?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    disconnect?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    delete?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    connect?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    update?: PromotionUpdateWithWhereUniqueWithoutCategoryInput | PromotionUpdateWithWhereUniqueWithoutCategoryInput[]
    updateMany?: PromotionUpdateManyWithWhereWithoutCategoryInput | PromotionUpdateManyWithWhereWithoutCategoryInput[]
    deleteMany?: PromotionScalarWhereInput | PromotionScalarWhereInput[]
  }

  export type ProductCreateNestedManyWithoutBrandInput = {
    create?: XOR<ProductCreateWithoutBrandInput, ProductUncheckedCreateWithoutBrandInput> | ProductCreateWithoutBrandInput[] | ProductUncheckedCreateWithoutBrandInput[]
    connectOrCreate?: ProductCreateOrConnectWithoutBrandInput | ProductCreateOrConnectWithoutBrandInput[]
    createMany?: ProductCreateManyBrandInputEnvelope
    connect?: ProductWhereUniqueInput | ProductWhereUniqueInput[]
  }

  export type PromotionCreateNestedManyWithoutBrandInput = {
    create?: XOR<PromotionCreateWithoutBrandInput, PromotionUncheckedCreateWithoutBrandInput> | PromotionCreateWithoutBrandInput[] | PromotionUncheckedCreateWithoutBrandInput[]
    connectOrCreate?: PromotionCreateOrConnectWithoutBrandInput | PromotionCreateOrConnectWithoutBrandInput[]
    createMany?: PromotionCreateManyBrandInputEnvelope
    connect?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
  }

  export type ProductUncheckedCreateNestedManyWithoutBrandInput = {
    create?: XOR<ProductCreateWithoutBrandInput, ProductUncheckedCreateWithoutBrandInput> | ProductCreateWithoutBrandInput[] | ProductUncheckedCreateWithoutBrandInput[]
    connectOrCreate?: ProductCreateOrConnectWithoutBrandInput | ProductCreateOrConnectWithoutBrandInput[]
    createMany?: ProductCreateManyBrandInputEnvelope
    connect?: ProductWhereUniqueInput | ProductWhereUniqueInput[]
  }

  export type PromotionUncheckedCreateNestedManyWithoutBrandInput = {
    create?: XOR<PromotionCreateWithoutBrandInput, PromotionUncheckedCreateWithoutBrandInput> | PromotionCreateWithoutBrandInput[] | PromotionUncheckedCreateWithoutBrandInput[]
    connectOrCreate?: PromotionCreateOrConnectWithoutBrandInput | PromotionCreateOrConnectWithoutBrandInput[]
    createMany?: PromotionCreateManyBrandInputEnvelope
    connect?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
  }

  export type ProductUpdateManyWithoutBrandNestedInput = {
    create?: XOR<ProductCreateWithoutBrandInput, ProductUncheckedCreateWithoutBrandInput> | ProductCreateWithoutBrandInput[] | ProductUncheckedCreateWithoutBrandInput[]
    connectOrCreate?: ProductCreateOrConnectWithoutBrandInput | ProductCreateOrConnectWithoutBrandInput[]
    upsert?: ProductUpsertWithWhereUniqueWithoutBrandInput | ProductUpsertWithWhereUniqueWithoutBrandInput[]
    createMany?: ProductCreateManyBrandInputEnvelope
    set?: ProductWhereUniqueInput | ProductWhereUniqueInput[]
    disconnect?: ProductWhereUniqueInput | ProductWhereUniqueInput[]
    delete?: ProductWhereUniqueInput | ProductWhereUniqueInput[]
    connect?: ProductWhereUniqueInput | ProductWhereUniqueInput[]
    update?: ProductUpdateWithWhereUniqueWithoutBrandInput | ProductUpdateWithWhereUniqueWithoutBrandInput[]
    updateMany?: ProductUpdateManyWithWhereWithoutBrandInput | ProductUpdateManyWithWhereWithoutBrandInput[]
    deleteMany?: ProductScalarWhereInput | ProductScalarWhereInput[]
  }

  export type PromotionUpdateManyWithoutBrandNestedInput = {
    create?: XOR<PromotionCreateWithoutBrandInput, PromotionUncheckedCreateWithoutBrandInput> | PromotionCreateWithoutBrandInput[] | PromotionUncheckedCreateWithoutBrandInput[]
    connectOrCreate?: PromotionCreateOrConnectWithoutBrandInput | PromotionCreateOrConnectWithoutBrandInput[]
    upsert?: PromotionUpsertWithWhereUniqueWithoutBrandInput | PromotionUpsertWithWhereUniqueWithoutBrandInput[]
    createMany?: PromotionCreateManyBrandInputEnvelope
    set?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    disconnect?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    delete?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    connect?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    update?: PromotionUpdateWithWhereUniqueWithoutBrandInput | PromotionUpdateWithWhereUniqueWithoutBrandInput[]
    updateMany?: PromotionUpdateManyWithWhereWithoutBrandInput | PromotionUpdateManyWithWhereWithoutBrandInput[]
    deleteMany?: PromotionScalarWhereInput | PromotionScalarWhereInput[]
  }

  export type ProductUncheckedUpdateManyWithoutBrandNestedInput = {
    create?: XOR<ProductCreateWithoutBrandInput, ProductUncheckedCreateWithoutBrandInput> | ProductCreateWithoutBrandInput[] | ProductUncheckedCreateWithoutBrandInput[]
    connectOrCreate?: ProductCreateOrConnectWithoutBrandInput | ProductCreateOrConnectWithoutBrandInput[]
    upsert?: ProductUpsertWithWhereUniqueWithoutBrandInput | ProductUpsertWithWhereUniqueWithoutBrandInput[]
    createMany?: ProductCreateManyBrandInputEnvelope
    set?: ProductWhereUniqueInput | ProductWhereUniqueInput[]
    disconnect?: ProductWhereUniqueInput | ProductWhereUniqueInput[]
    delete?: ProductWhereUniqueInput | ProductWhereUniqueInput[]
    connect?: ProductWhereUniqueInput | ProductWhereUniqueInput[]
    update?: ProductUpdateWithWhereUniqueWithoutBrandInput | ProductUpdateWithWhereUniqueWithoutBrandInput[]
    updateMany?: ProductUpdateManyWithWhereWithoutBrandInput | ProductUpdateManyWithWhereWithoutBrandInput[]
    deleteMany?: ProductScalarWhereInput | ProductScalarWhereInput[]
  }

  export type PromotionUncheckedUpdateManyWithoutBrandNestedInput = {
    create?: XOR<PromotionCreateWithoutBrandInput, PromotionUncheckedCreateWithoutBrandInput> | PromotionCreateWithoutBrandInput[] | PromotionUncheckedCreateWithoutBrandInput[]
    connectOrCreate?: PromotionCreateOrConnectWithoutBrandInput | PromotionCreateOrConnectWithoutBrandInput[]
    upsert?: PromotionUpsertWithWhereUniqueWithoutBrandInput | PromotionUpsertWithWhereUniqueWithoutBrandInput[]
    createMany?: PromotionCreateManyBrandInputEnvelope
    set?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    disconnect?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    delete?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    connect?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    update?: PromotionUpdateWithWhereUniqueWithoutBrandInput | PromotionUpdateWithWhereUniqueWithoutBrandInput[]
    updateMany?: PromotionUpdateManyWithWhereWithoutBrandInput | PromotionUpdateManyWithWhereWithoutBrandInput[]
    deleteMany?: PromotionScalarWhereInput | PromotionScalarWhereInput[]
  }

  export type CollectionProductCreateNestedManyWithoutCollectionInput = {
    create?: XOR<CollectionProductCreateWithoutCollectionInput, CollectionProductUncheckedCreateWithoutCollectionInput> | CollectionProductCreateWithoutCollectionInput[] | CollectionProductUncheckedCreateWithoutCollectionInput[]
    connectOrCreate?: CollectionProductCreateOrConnectWithoutCollectionInput | CollectionProductCreateOrConnectWithoutCollectionInput[]
    createMany?: CollectionProductCreateManyCollectionInputEnvelope
    connect?: CollectionProductWhereUniqueInput | CollectionProductWhereUniqueInput[]
  }

  export type CollectionProductUncheckedCreateNestedManyWithoutCollectionInput = {
    create?: XOR<CollectionProductCreateWithoutCollectionInput, CollectionProductUncheckedCreateWithoutCollectionInput> | CollectionProductCreateWithoutCollectionInput[] | CollectionProductUncheckedCreateWithoutCollectionInput[]
    connectOrCreate?: CollectionProductCreateOrConnectWithoutCollectionInput | CollectionProductCreateOrConnectWithoutCollectionInput[]
    createMany?: CollectionProductCreateManyCollectionInputEnvelope
    connect?: CollectionProductWhereUniqueInput | CollectionProductWhereUniqueInput[]
  }

  export type CollectionProductUpdateManyWithoutCollectionNestedInput = {
    create?: XOR<CollectionProductCreateWithoutCollectionInput, CollectionProductUncheckedCreateWithoutCollectionInput> | CollectionProductCreateWithoutCollectionInput[] | CollectionProductUncheckedCreateWithoutCollectionInput[]
    connectOrCreate?: CollectionProductCreateOrConnectWithoutCollectionInput | CollectionProductCreateOrConnectWithoutCollectionInput[]
    upsert?: CollectionProductUpsertWithWhereUniqueWithoutCollectionInput | CollectionProductUpsertWithWhereUniqueWithoutCollectionInput[]
    createMany?: CollectionProductCreateManyCollectionInputEnvelope
    set?: CollectionProductWhereUniqueInput | CollectionProductWhereUniqueInput[]
    disconnect?: CollectionProductWhereUniqueInput | CollectionProductWhereUniqueInput[]
    delete?: CollectionProductWhereUniqueInput | CollectionProductWhereUniqueInput[]
    connect?: CollectionProductWhereUniqueInput | CollectionProductWhereUniqueInput[]
    update?: CollectionProductUpdateWithWhereUniqueWithoutCollectionInput | CollectionProductUpdateWithWhereUniqueWithoutCollectionInput[]
    updateMany?: CollectionProductUpdateManyWithWhereWithoutCollectionInput | CollectionProductUpdateManyWithWhereWithoutCollectionInput[]
    deleteMany?: CollectionProductScalarWhereInput | CollectionProductScalarWhereInput[]
  }

  export type CollectionProductUncheckedUpdateManyWithoutCollectionNestedInput = {
    create?: XOR<CollectionProductCreateWithoutCollectionInput, CollectionProductUncheckedCreateWithoutCollectionInput> | CollectionProductCreateWithoutCollectionInput[] | CollectionProductUncheckedCreateWithoutCollectionInput[]
    connectOrCreate?: CollectionProductCreateOrConnectWithoutCollectionInput | CollectionProductCreateOrConnectWithoutCollectionInput[]
    upsert?: CollectionProductUpsertWithWhereUniqueWithoutCollectionInput | CollectionProductUpsertWithWhereUniqueWithoutCollectionInput[]
    createMany?: CollectionProductCreateManyCollectionInputEnvelope
    set?: CollectionProductWhereUniqueInput | CollectionProductWhereUniqueInput[]
    disconnect?: CollectionProductWhereUniqueInput | CollectionProductWhereUniqueInput[]
    delete?: CollectionProductWhereUniqueInput | CollectionProductWhereUniqueInput[]
    connect?: CollectionProductWhereUniqueInput | CollectionProductWhereUniqueInput[]
    update?: CollectionProductUpdateWithWhereUniqueWithoutCollectionInput | CollectionProductUpdateWithWhereUniqueWithoutCollectionInput[]
    updateMany?: CollectionProductUpdateManyWithWhereWithoutCollectionInput | CollectionProductUpdateManyWithWhereWithoutCollectionInput[]
    deleteMany?: CollectionProductScalarWhereInput | CollectionProductScalarWhereInput[]
  }

  export type CollectionCreateNestedOneWithoutProductsInput = {
    create?: XOR<CollectionCreateWithoutProductsInput, CollectionUncheckedCreateWithoutProductsInput>
    connectOrCreate?: CollectionCreateOrConnectWithoutProductsInput
    connect?: CollectionWhereUniqueInput
  }

  export type ProductCreateNestedOneWithoutCollectionsInput = {
    create?: XOR<ProductCreateWithoutCollectionsInput, ProductUncheckedCreateWithoutCollectionsInput>
    connectOrCreate?: ProductCreateOrConnectWithoutCollectionsInput
    connect?: ProductWhereUniqueInput
  }

  export type CollectionUpdateOneRequiredWithoutProductsNestedInput = {
    create?: XOR<CollectionCreateWithoutProductsInput, CollectionUncheckedCreateWithoutProductsInput>
    connectOrCreate?: CollectionCreateOrConnectWithoutProductsInput
    upsert?: CollectionUpsertWithoutProductsInput
    connect?: CollectionWhereUniqueInput
    update?: XOR<XOR<CollectionUpdateToOneWithWhereWithoutProductsInput, CollectionUpdateWithoutProductsInput>, CollectionUncheckedUpdateWithoutProductsInput>
  }

  export type ProductUpdateOneRequiredWithoutCollectionsNestedInput = {
    create?: XOR<ProductCreateWithoutCollectionsInput, ProductUncheckedCreateWithoutCollectionsInput>
    connectOrCreate?: ProductCreateOrConnectWithoutCollectionsInput
    upsert?: ProductUpsertWithoutCollectionsInput
    connect?: ProductWhereUniqueInput
    update?: XOR<XOR<ProductUpdateToOneWithWhereWithoutCollectionsInput, ProductUpdateWithoutCollectionsInput>, ProductUncheckedUpdateWithoutCollectionsInput>
  }

  export type CategoryCreateNestedOneWithoutProductsInput = {
    create?: XOR<CategoryCreateWithoutProductsInput, CategoryUncheckedCreateWithoutProductsInput>
    connectOrCreate?: CategoryCreateOrConnectWithoutProductsInput
    connect?: CategoryWhereUniqueInput
  }

  export type BrandCreateNestedOneWithoutProductsInput = {
    create?: XOR<BrandCreateWithoutProductsInput, BrandUncheckedCreateWithoutProductsInput>
    connectOrCreate?: BrandCreateOrConnectWithoutProductsInput
    connect?: BrandWhereUniqueInput
  }

  export type ProductVariantCreateNestedManyWithoutProductInput = {
    create?: XOR<ProductVariantCreateWithoutProductInput, ProductVariantUncheckedCreateWithoutProductInput> | ProductVariantCreateWithoutProductInput[] | ProductVariantUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductVariantCreateOrConnectWithoutProductInput | ProductVariantCreateOrConnectWithoutProductInput[]
    createMany?: ProductVariantCreateManyProductInputEnvelope
    connect?: ProductVariantWhereUniqueInput | ProductVariantWhereUniqueInput[]
  }

  export type ProductImageCreateNestedManyWithoutProductInput = {
    create?: XOR<ProductImageCreateWithoutProductInput, ProductImageUncheckedCreateWithoutProductInput> | ProductImageCreateWithoutProductInput[] | ProductImageUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductImageCreateOrConnectWithoutProductInput | ProductImageCreateOrConnectWithoutProductInput[]
    createMany?: ProductImageCreateManyProductInputEnvelope
    connect?: ProductImageWhereUniqueInput | ProductImageWhereUniqueInput[]
  }

  export type CollectionProductCreateNestedManyWithoutProductInput = {
    create?: XOR<CollectionProductCreateWithoutProductInput, CollectionProductUncheckedCreateWithoutProductInput> | CollectionProductCreateWithoutProductInput[] | CollectionProductUncheckedCreateWithoutProductInput[]
    connectOrCreate?: CollectionProductCreateOrConnectWithoutProductInput | CollectionProductCreateOrConnectWithoutProductInput[]
    createMany?: CollectionProductCreateManyProductInputEnvelope
    connect?: CollectionProductWhereUniqueInput | CollectionProductWhereUniqueInput[]
  }

  export type CommentCreateNestedManyWithoutProductInput = {
    create?: XOR<CommentCreateWithoutProductInput, CommentUncheckedCreateWithoutProductInput> | CommentCreateWithoutProductInput[] | CommentUncheckedCreateWithoutProductInput[]
    connectOrCreate?: CommentCreateOrConnectWithoutProductInput | CommentCreateOrConnectWithoutProductInput[]
    createMany?: CommentCreateManyProductInputEnvelope
    connect?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
  }

  export type PromotionCreateNestedManyWithoutProductInput = {
    create?: XOR<PromotionCreateWithoutProductInput, PromotionUncheckedCreateWithoutProductInput> | PromotionCreateWithoutProductInput[] | PromotionUncheckedCreateWithoutProductInput[]
    connectOrCreate?: PromotionCreateOrConnectWithoutProductInput | PromotionCreateOrConnectWithoutProductInput[]
    createMany?: PromotionCreateManyProductInputEnvelope
    connect?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
  }

  export type BranchAllocationItemCreateNestedManyWithoutProductInput = {
    create?: XOR<BranchAllocationItemCreateWithoutProductInput, BranchAllocationItemUncheckedCreateWithoutProductInput> | BranchAllocationItemCreateWithoutProductInput[] | BranchAllocationItemUncheckedCreateWithoutProductInput[]
    connectOrCreate?: BranchAllocationItemCreateOrConnectWithoutProductInput | BranchAllocationItemCreateOrConnectWithoutProductInput[]
    createMany?: BranchAllocationItemCreateManyProductInputEnvelope
    connect?: BranchAllocationItemWhereUniqueInput | BranchAllocationItemWhereUniqueInput[]
  }

  export type ProductVariantUncheckedCreateNestedManyWithoutProductInput = {
    create?: XOR<ProductVariantCreateWithoutProductInput, ProductVariantUncheckedCreateWithoutProductInput> | ProductVariantCreateWithoutProductInput[] | ProductVariantUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductVariantCreateOrConnectWithoutProductInput | ProductVariantCreateOrConnectWithoutProductInput[]
    createMany?: ProductVariantCreateManyProductInputEnvelope
    connect?: ProductVariantWhereUniqueInput | ProductVariantWhereUniqueInput[]
  }

  export type ProductImageUncheckedCreateNestedManyWithoutProductInput = {
    create?: XOR<ProductImageCreateWithoutProductInput, ProductImageUncheckedCreateWithoutProductInput> | ProductImageCreateWithoutProductInput[] | ProductImageUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductImageCreateOrConnectWithoutProductInput | ProductImageCreateOrConnectWithoutProductInput[]
    createMany?: ProductImageCreateManyProductInputEnvelope
    connect?: ProductImageWhereUniqueInput | ProductImageWhereUniqueInput[]
  }

  export type CollectionProductUncheckedCreateNestedManyWithoutProductInput = {
    create?: XOR<CollectionProductCreateWithoutProductInput, CollectionProductUncheckedCreateWithoutProductInput> | CollectionProductCreateWithoutProductInput[] | CollectionProductUncheckedCreateWithoutProductInput[]
    connectOrCreate?: CollectionProductCreateOrConnectWithoutProductInput | CollectionProductCreateOrConnectWithoutProductInput[]
    createMany?: CollectionProductCreateManyProductInputEnvelope
    connect?: CollectionProductWhereUniqueInput | CollectionProductWhereUniqueInput[]
  }

  export type CommentUncheckedCreateNestedManyWithoutProductInput = {
    create?: XOR<CommentCreateWithoutProductInput, CommentUncheckedCreateWithoutProductInput> | CommentCreateWithoutProductInput[] | CommentUncheckedCreateWithoutProductInput[]
    connectOrCreate?: CommentCreateOrConnectWithoutProductInput | CommentCreateOrConnectWithoutProductInput[]
    createMany?: CommentCreateManyProductInputEnvelope
    connect?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
  }

  export type PromotionUncheckedCreateNestedManyWithoutProductInput = {
    create?: XOR<PromotionCreateWithoutProductInput, PromotionUncheckedCreateWithoutProductInput> | PromotionCreateWithoutProductInput[] | PromotionUncheckedCreateWithoutProductInput[]
    connectOrCreate?: PromotionCreateOrConnectWithoutProductInput | PromotionCreateOrConnectWithoutProductInput[]
    createMany?: PromotionCreateManyProductInputEnvelope
    connect?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
  }

  export type BranchAllocationItemUncheckedCreateNestedManyWithoutProductInput = {
    create?: XOR<BranchAllocationItemCreateWithoutProductInput, BranchAllocationItemUncheckedCreateWithoutProductInput> | BranchAllocationItemCreateWithoutProductInput[] | BranchAllocationItemUncheckedCreateWithoutProductInput[]
    connectOrCreate?: BranchAllocationItemCreateOrConnectWithoutProductInput | BranchAllocationItemCreateOrConnectWithoutProductInput[]
    createMany?: BranchAllocationItemCreateManyProductInputEnvelope
    connect?: BranchAllocationItemWhereUniqueInput | BranchAllocationItemWhereUniqueInput[]
  }

  export type CategoryUpdateOneWithoutProductsNestedInput = {
    create?: XOR<CategoryCreateWithoutProductsInput, CategoryUncheckedCreateWithoutProductsInput>
    connectOrCreate?: CategoryCreateOrConnectWithoutProductsInput
    upsert?: CategoryUpsertWithoutProductsInput
    disconnect?: CategoryWhereInput | boolean
    delete?: CategoryWhereInput | boolean
    connect?: CategoryWhereUniqueInput
    update?: XOR<XOR<CategoryUpdateToOneWithWhereWithoutProductsInput, CategoryUpdateWithoutProductsInput>, CategoryUncheckedUpdateWithoutProductsInput>
  }

  export type BrandUpdateOneWithoutProductsNestedInput = {
    create?: XOR<BrandCreateWithoutProductsInput, BrandUncheckedCreateWithoutProductsInput>
    connectOrCreate?: BrandCreateOrConnectWithoutProductsInput
    upsert?: BrandUpsertWithoutProductsInput
    disconnect?: BrandWhereInput | boolean
    delete?: BrandWhereInput | boolean
    connect?: BrandWhereUniqueInput
    update?: XOR<XOR<BrandUpdateToOneWithWhereWithoutProductsInput, BrandUpdateWithoutProductsInput>, BrandUncheckedUpdateWithoutProductsInput>
  }

  export type ProductVariantUpdateManyWithoutProductNestedInput = {
    create?: XOR<ProductVariantCreateWithoutProductInput, ProductVariantUncheckedCreateWithoutProductInput> | ProductVariantCreateWithoutProductInput[] | ProductVariantUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductVariantCreateOrConnectWithoutProductInput | ProductVariantCreateOrConnectWithoutProductInput[]
    upsert?: ProductVariantUpsertWithWhereUniqueWithoutProductInput | ProductVariantUpsertWithWhereUniqueWithoutProductInput[]
    createMany?: ProductVariantCreateManyProductInputEnvelope
    set?: ProductVariantWhereUniqueInput | ProductVariantWhereUniqueInput[]
    disconnect?: ProductVariantWhereUniqueInput | ProductVariantWhereUniqueInput[]
    delete?: ProductVariantWhereUniqueInput | ProductVariantWhereUniqueInput[]
    connect?: ProductVariantWhereUniqueInput | ProductVariantWhereUniqueInput[]
    update?: ProductVariantUpdateWithWhereUniqueWithoutProductInput | ProductVariantUpdateWithWhereUniqueWithoutProductInput[]
    updateMany?: ProductVariantUpdateManyWithWhereWithoutProductInput | ProductVariantUpdateManyWithWhereWithoutProductInput[]
    deleteMany?: ProductVariantScalarWhereInput | ProductVariantScalarWhereInput[]
  }

  export type ProductImageUpdateManyWithoutProductNestedInput = {
    create?: XOR<ProductImageCreateWithoutProductInput, ProductImageUncheckedCreateWithoutProductInput> | ProductImageCreateWithoutProductInput[] | ProductImageUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductImageCreateOrConnectWithoutProductInput | ProductImageCreateOrConnectWithoutProductInput[]
    upsert?: ProductImageUpsertWithWhereUniqueWithoutProductInput | ProductImageUpsertWithWhereUniqueWithoutProductInput[]
    createMany?: ProductImageCreateManyProductInputEnvelope
    set?: ProductImageWhereUniqueInput | ProductImageWhereUniqueInput[]
    disconnect?: ProductImageWhereUniqueInput | ProductImageWhereUniqueInput[]
    delete?: ProductImageWhereUniqueInput | ProductImageWhereUniqueInput[]
    connect?: ProductImageWhereUniqueInput | ProductImageWhereUniqueInput[]
    update?: ProductImageUpdateWithWhereUniqueWithoutProductInput | ProductImageUpdateWithWhereUniqueWithoutProductInput[]
    updateMany?: ProductImageUpdateManyWithWhereWithoutProductInput | ProductImageUpdateManyWithWhereWithoutProductInput[]
    deleteMany?: ProductImageScalarWhereInput | ProductImageScalarWhereInput[]
  }

  export type CollectionProductUpdateManyWithoutProductNestedInput = {
    create?: XOR<CollectionProductCreateWithoutProductInput, CollectionProductUncheckedCreateWithoutProductInput> | CollectionProductCreateWithoutProductInput[] | CollectionProductUncheckedCreateWithoutProductInput[]
    connectOrCreate?: CollectionProductCreateOrConnectWithoutProductInput | CollectionProductCreateOrConnectWithoutProductInput[]
    upsert?: CollectionProductUpsertWithWhereUniqueWithoutProductInput | CollectionProductUpsertWithWhereUniqueWithoutProductInput[]
    createMany?: CollectionProductCreateManyProductInputEnvelope
    set?: CollectionProductWhereUniqueInput | CollectionProductWhereUniqueInput[]
    disconnect?: CollectionProductWhereUniqueInput | CollectionProductWhereUniqueInput[]
    delete?: CollectionProductWhereUniqueInput | CollectionProductWhereUniqueInput[]
    connect?: CollectionProductWhereUniqueInput | CollectionProductWhereUniqueInput[]
    update?: CollectionProductUpdateWithWhereUniqueWithoutProductInput | CollectionProductUpdateWithWhereUniqueWithoutProductInput[]
    updateMany?: CollectionProductUpdateManyWithWhereWithoutProductInput | CollectionProductUpdateManyWithWhereWithoutProductInput[]
    deleteMany?: CollectionProductScalarWhereInput | CollectionProductScalarWhereInput[]
  }

  export type CommentUpdateManyWithoutProductNestedInput = {
    create?: XOR<CommentCreateWithoutProductInput, CommentUncheckedCreateWithoutProductInput> | CommentCreateWithoutProductInput[] | CommentUncheckedCreateWithoutProductInput[]
    connectOrCreate?: CommentCreateOrConnectWithoutProductInput | CommentCreateOrConnectWithoutProductInput[]
    upsert?: CommentUpsertWithWhereUniqueWithoutProductInput | CommentUpsertWithWhereUniqueWithoutProductInput[]
    createMany?: CommentCreateManyProductInputEnvelope
    set?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
    disconnect?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
    delete?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
    connect?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
    update?: CommentUpdateWithWhereUniqueWithoutProductInput | CommentUpdateWithWhereUniqueWithoutProductInput[]
    updateMany?: CommentUpdateManyWithWhereWithoutProductInput | CommentUpdateManyWithWhereWithoutProductInput[]
    deleteMany?: CommentScalarWhereInput | CommentScalarWhereInput[]
  }

  export type PromotionUpdateManyWithoutProductNestedInput = {
    create?: XOR<PromotionCreateWithoutProductInput, PromotionUncheckedCreateWithoutProductInput> | PromotionCreateWithoutProductInput[] | PromotionUncheckedCreateWithoutProductInput[]
    connectOrCreate?: PromotionCreateOrConnectWithoutProductInput | PromotionCreateOrConnectWithoutProductInput[]
    upsert?: PromotionUpsertWithWhereUniqueWithoutProductInput | PromotionUpsertWithWhereUniqueWithoutProductInput[]
    createMany?: PromotionCreateManyProductInputEnvelope
    set?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    disconnect?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    delete?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    connect?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    update?: PromotionUpdateWithWhereUniqueWithoutProductInput | PromotionUpdateWithWhereUniqueWithoutProductInput[]
    updateMany?: PromotionUpdateManyWithWhereWithoutProductInput | PromotionUpdateManyWithWhereWithoutProductInput[]
    deleteMany?: PromotionScalarWhereInput | PromotionScalarWhereInput[]
  }

  export type BranchAllocationItemUpdateManyWithoutProductNestedInput = {
    create?: XOR<BranchAllocationItemCreateWithoutProductInput, BranchAllocationItemUncheckedCreateWithoutProductInput> | BranchAllocationItemCreateWithoutProductInput[] | BranchAllocationItemUncheckedCreateWithoutProductInput[]
    connectOrCreate?: BranchAllocationItemCreateOrConnectWithoutProductInput | BranchAllocationItemCreateOrConnectWithoutProductInput[]
    upsert?: BranchAllocationItemUpsertWithWhereUniqueWithoutProductInput | BranchAllocationItemUpsertWithWhereUniqueWithoutProductInput[]
    createMany?: BranchAllocationItemCreateManyProductInputEnvelope
    set?: BranchAllocationItemWhereUniqueInput | BranchAllocationItemWhereUniqueInput[]
    disconnect?: BranchAllocationItemWhereUniqueInput | BranchAllocationItemWhereUniqueInput[]
    delete?: BranchAllocationItemWhereUniqueInput | BranchAllocationItemWhereUniqueInput[]
    connect?: BranchAllocationItemWhereUniqueInput | BranchAllocationItemWhereUniqueInput[]
    update?: BranchAllocationItemUpdateWithWhereUniqueWithoutProductInput | BranchAllocationItemUpdateWithWhereUniqueWithoutProductInput[]
    updateMany?: BranchAllocationItemUpdateManyWithWhereWithoutProductInput | BranchAllocationItemUpdateManyWithWhereWithoutProductInput[]
    deleteMany?: BranchAllocationItemScalarWhereInput | BranchAllocationItemScalarWhereInput[]
  }

  export type ProductVariantUncheckedUpdateManyWithoutProductNestedInput = {
    create?: XOR<ProductVariantCreateWithoutProductInput, ProductVariantUncheckedCreateWithoutProductInput> | ProductVariantCreateWithoutProductInput[] | ProductVariantUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductVariantCreateOrConnectWithoutProductInput | ProductVariantCreateOrConnectWithoutProductInput[]
    upsert?: ProductVariantUpsertWithWhereUniqueWithoutProductInput | ProductVariantUpsertWithWhereUniqueWithoutProductInput[]
    createMany?: ProductVariantCreateManyProductInputEnvelope
    set?: ProductVariantWhereUniqueInput | ProductVariantWhereUniqueInput[]
    disconnect?: ProductVariantWhereUniqueInput | ProductVariantWhereUniqueInput[]
    delete?: ProductVariantWhereUniqueInput | ProductVariantWhereUniqueInput[]
    connect?: ProductVariantWhereUniqueInput | ProductVariantWhereUniqueInput[]
    update?: ProductVariantUpdateWithWhereUniqueWithoutProductInput | ProductVariantUpdateWithWhereUniqueWithoutProductInput[]
    updateMany?: ProductVariantUpdateManyWithWhereWithoutProductInput | ProductVariantUpdateManyWithWhereWithoutProductInput[]
    deleteMany?: ProductVariantScalarWhereInput | ProductVariantScalarWhereInput[]
  }

  export type ProductImageUncheckedUpdateManyWithoutProductNestedInput = {
    create?: XOR<ProductImageCreateWithoutProductInput, ProductImageUncheckedCreateWithoutProductInput> | ProductImageCreateWithoutProductInput[] | ProductImageUncheckedCreateWithoutProductInput[]
    connectOrCreate?: ProductImageCreateOrConnectWithoutProductInput | ProductImageCreateOrConnectWithoutProductInput[]
    upsert?: ProductImageUpsertWithWhereUniqueWithoutProductInput | ProductImageUpsertWithWhereUniqueWithoutProductInput[]
    createMany?: ProductImageCreateManyProductInputEnvelope
    set?: ProductImageWhereUniqueInput | ProductImageWhereUniqueInput[]
    disconnect?: ProductImageWhereUniqueInput | ProductImageWhereUniqueInput[]
    delete?: ProductImageWhereUniqueInput | ProductImageWhereUniqueInput[]
    connect?: ProductImageWhereUniqueInput | ProductImageWhereUniqueInput[]
    update?: ProductImageUpdateWithWhereUniqueWithoutProductInput | ProductImageUpdateWithWhereUniqueWithoutProductInput[]
    updateMany?: ProductImageUpdateManyWithWhereWithoutProductInput | ProductImageUpdateManyWithWhereWithoutProductInput[]
    deleteMany?: ProductImageScalarWhereInput | ProductImageScalarWhereInput[]
  }

  export type CollectionProductUncheckedUpdateManyWithoutProductNestedInput = {
    create?: XOR<CollectionProductCreateWithoutProductInput, CollectionProductUncheckedCreateWithoutProductInput> | CollectionProductCreateWithoutProductInput[] | CollectionProductUncheckedCreateWithoutProductInput[]
    connectOrCreate?: CollectionProductCreateOrConnectWithoutProductInput | CollectionProductCreateOrConnectWithoutProductInput[]
    upsert?: CollectionProductUpsertWithWhereUniqueWithoutProductInput | CollectionProductUpsertWithWhereUniqueWithoutProductInput[]
    createMany?: CollectionProductCreateManyProductInputEnvelope
    set?: CollectionProductWhereUniqueInput | CollectionProductWhereUniqueInput[]
    disconnect?: CollectionProductWhereUniqueInput | CollectionProductWhereUniqueInput[]
    delete?: CollectionProductWhereUniqueInput | CollectionProductWhereUniqueInput[]
    connect?: CollectionProductWhereUniqueInput | CollectionProductWhereUniqueInput[]
    update?: CollectionProductUpdateWithWhereUniqueWithoutProductInput | CollectionProductUpdateWithWhereUniqueWithoutProductInput[]
    updateMany?: CollectionProductUpdateManyWithWhereWithoutProductInput | CollectionProductUpdateManyWithWhereWithoutProductInput[]
    deleteMany?: CollectionProductScalarWhereInput | CollectionProductScalarWhereInput[]
  }

  export type CommentUncheckedUpdateManyWithoutProductNestedInput = {
    create?: XOR<CommentCreateWithoutProductInput, CommentUncheckedCreateWithoutProductInput> | CommentCreateWithoutProductInput[] | CommentUncheckedCreateWithoutProductInput[]
    connectOrCreate?: CommentCreateOrConnectWithoutProductInput | CommentCreateOrConnectWithoutProductInput[]
    upsert?: CommentUpsertWithWhereUniqueWithoutProductInput | CommentUpsertWithWhereUniqueWithoutProductInput[]
    createMany?: CommentCreateManyProductInputEnvelope
    set?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
    disconnect?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
    delete?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
    connect?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
    update?: CommentUpdateWithWhereUniqueWithoutProductInput | CommentUpdateWithWhereUniqueWithoutProductInput[]
    updateMany?: CommentUpdateManyWithWhereWithoutProductInput | CommentUpdateManyWithWhereWithoutProductInput[]
    deleteMany?: CommentScalarWhereInput | CommentScalarWhereInput[]
  }

  export type PromotionUncheckedUpdateManyWithoutProductNestedInput = {
    create?: XOR<PromotionCreateWithoutProductInput, PromotionUncheckedCreateWithoutProductInput> | PromotionCreateWithoutProductInput[] | PromotionUncheckedCreateWithoutProductInput[]
    connectOrCreate?: PromotionCreateOrConnectWithoutProductInput | PromotionCreateOrConnectWithoutProductInput[]
    upsert?: PromotionUpsertWithWhereUniqueWithoutProductInput | PromotionUpsertWithWhereUniqueWithoutProductInput[]
    createMany?: PromotionCreateManyProductInputEnvelope
    set?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    disconnect?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    delete?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    connect?: PromotionWhereUniqueInput | PromotionWhereUniqueInput[]
    update?: PromotionUpdateWithWhereUniqueWithoutProductInput | PromotionUpdateWithWhereUniqueWithoutProductInput[]
    updateMany?: PromotionUpdateManyWithWhereWithoutProductInput | PromotionUpdateManyWithWhereWithoutProductInput[]
    deleteMany?: PromotionScalarWhereInput | PromotionScalarWhereInput[]
  }

  export type BranchAllocationItemUncheckedUpdateManyWithoutProductNestedInput = {
    create?: XOR<BranchAllocationItemCreateWithoutProductInput, BranchAllocationItemUncheckedCreateWithoutProductInput> | BranchAllocationItemCreateWithoutProductInput[] | BranchAllocationItemUncheckedCreateWithoutProductInput[]
    connectOrCreate?: BranchAllocationItemCreateOrConnectWithoutProductInput | BranchAllocationItemCreateOrConnectWithoutProductInput[]
    upsert?: BranchAllocationItemUpsertWithWhereUniqueWithoutProductInput | BranchAllocationItemUpsertWithWhereUniqueWithoutProductInput[]
    createMany?: BranchAllocationItemCreateManyProductInputEnvelope
    set?: BranchAllocationItemWhereUniqueInput | BranchAllocationItemWhereUniqueInput[]
    disconnect?: BranchAllocationItemWhereUniqueInput | BranchAllocationItemWhereUniqueInput[]
    delete?: BranchAllocationItemWhereUniqueInput | BranchAllocationItemWhereUniqueInput[]
    connect?: BranchAllocationItemWhereUniqueInput | BranchAllocationItemWhereUniqueInput[]
    update?: BranchAllocationItemUpdateWithWhereUniqueWithoutProductInput | BranchAllocationItemUpdateWithWhereUniqueWithoutProductInput[]
    updateMany?: BranchAllocationItemUpdateManyWithWhereWithoutProductInput | BranchAllocationItemUpdateManyWithWhereWithoutProductInput[]
    deleteMany?: BranchAllocationItemScalarWhereInput | BranchAllocationItemScalarWhereInput[]
  }

  export type ProductCreateNestedOneWithoutImagesInput = {
    create?: XOR<ProductCreateWithoutImagesInput, ProductUncheckedCreateWithoutImagesInput>
    connectOrCreate?: ProductCreateOrConnectWithoutImagesInput
    connect?: ProductWhereUniqueInput
  }

  export type ProductVariantCreateNestedManyWithoutImageInput = {
    create?: XOR<ProductVariantCreateWithoutImageInput, ProductVariantUncheckedCreateWithoutImageInput> | ProductVariantCreateWithoutImageInput[] | ProductVariantUncheckedCreateWithoutImageInput[]
    connectOrCreate?: ProductVariantCreateOrConnectWithoutImageInput | ProductVariantCreateOrConnectWithoutImageInput[]
    createMany?: ProductVariantCreateManyImageInputEnvelope
    connect?: ProductVariantWhereUniqueInput | ProductVariantWhereUniqueInput[]
  }

  export type ProductVariantUncheckedCreateNestedManyWithoutImageInput = {
    create?: XOR<ProductVariantCreateWithoutImageInput, ProductVariantUncheckedCreateWithoutImageInput> | ProductVariantCreateWithoutImageInput[] | ProductVariantUncheckedCreateWithoutImageInput[]
    connectOrCreate?: ProductVariantCreateOrConnectWithoutImageInput | ProductVariantCreateOrConnectWithoutImageInput[]
    createMany?: ProductVariantCreateManyImageInputEnvelope
    connect?: ProductVariantWhereUniqueInput | ProductVariantWhereUniqueInput[]
  }

  export type EnumProductImageRoleFieldUpdateOperationsInput = {
    set?: $Enums.ProductImageRole
  }

  export type ProductUpdateOneRequiredWithoutImagesNestedInput = {
    create?: XOR<ProductCreateWithoutImagesInput, ProductUncheckedCreateWithoutImagesInput>
    connectOrCreate?: ProductCreateOrConnectWithoutImagesInput
    upsert?: ProductUpsertWithoutImagesInput
    connect?: ProductWhereUniqueInput
    update?: XOR<XOR<ProductUpdateToOneWithWhereWithoutImagesInput, ProductUpdateWithoutImagesInput>, ProductUncheckedUpdateWithoutImagesInput>
  }

  export type ProductVariantUpdateManyWithoutImageNestedInput = {
    create?: XOR<ProductVariantCreateWithoutImageInput, ProductVariantUncheckedCreateWithoutImageInput> | ProductVariantCreateWithoutImageInput[] | ProductVariantUncheckedCreateWithoutImageInput[]
    connectOrCreate?: ProductVariantCreateOrConnectWithoutImageInput | ProductVariantCreateOrConnectWithoutImageInput[]
    upsert?: ProductVariantUpsertWithWhereUniqueWithoutImageInput | ProductVariantUpsertWithWhereUniqueWithoutImageInput[]
    createMany?: ProductVariantCreateManyImageInputEnvelope
    set?: ProductVariantWhereUniqueInput | ProductVariantWhereUniqueInput[]
    disconnect?: ProductVariantWhereUniqueInput | ProductVariantWhereUniqueInput[]
    delete?: ProductVariantWhereUniqueInput | ProductVariantWhereUniqueInput[]
    connect?: ProductVariantWhereUniqueInput | ProductVariantWhereUniqueInput[]
    update?: ProductVariantUpdateWithWhereUniqueWithoutImageInput | ProductVariantUpdateWithWhereUniqueWithoutImageInput[]
    updateMany?: ProductVariantUpdateManyWithWhereWithoutImageInput | ProductVariantUpdateManyWithWhereWithoutImageInput[]
    deleteMany?: ProductVariantScalarWhereInput | ProductVariantScalarWhereInput[]
  }

  export type ProductVariantUncheckedUpdateManyWithoutImageNestedInput = {
    create?: XOR<ProductVariantCreateWithoutImageInput, ProductVariantUncheckedCreateWithoutImageInput> | ProductVariantCreateWithoutImageInput[] | ProductVariantUncheckedCreateWithoutImageInput[]
    connectOrCreate?: ProductVariantCreateOrConnectWithoutImageInput | ProductVariantCreateOrConnectWithoutImageInput[]
    upsert?: ProductVariantUpsertWithWhereUniqueWithoutImageInput | ProductVariantUpsertWithWhereUniqueWithoutImageInput[]
    createMany?: ProductVariantCreateManyImageInputEnvelope
    set?: ProductVariantWhereUniqueInput | ProductVariantWhereUniqueInput[]
    disconnect?: ProductVariantWhereUniqueInput | ProductVariantWhereUniqueInput[]
    delete?: ProductVariantWhereUniqueInput | ProductVariantWhereUniqueInput[]
    connect?: ProductVariantWhereUniqueInput | ProductVariantWhereUniqueInput[]
    update?: ProductVariantUpdateWithWhereUniqueWithoutImageInput | ProductVariantUpdateWithWhereUniqueWithoutImageInput[]
    updateMany?: ProductVariantUpdateManyWithWhereWithoutImageInput | ProductVariantUpdateManyWithWhereWithoutImageInput[]
    deleteMany?: ProductVariantScalarWhereInput | ProductVariantScalarWhereInput[]
  }

  export type ProductCreateNestedOneWithoutVariantsInput = {
    create?: XOR<ProductCreateWithoutVariantsInput, ProductUncheckedCreateWithoutVariantsInput>
    connectOrCreate?: ProductCreateOrConnectWithoutVariantsInput
    connect?: ProductWhereUniqueInput
  }

  export type ProductImageCreateNestedOneWithoutVariantsInput = {
    create?: XOR<ProductImageCreateWithoutVariantsInput, ProductImageUncheckedCreateWithoutVariantsInput>
    connectOrCreate?: ProductImageCreateOrConnectWithoutVariantsInput
    connect?: ProductImageWhereUniqueInput
  }

  export type OrderItemCreateNestedManyWithoutProductVariantInput = {
    create?: XOR<OrderItemCreateWithoutProductVariantInput, OrderItemUncheckedCreateWithoutProductVariantInput> | OrderItemCreateWithoutProductVariantInput[] | OrderItemUncheckedCreateWithoutProductVariantInput[]
    connectOrCreate?: OrderItemCreateOrConnectWithoutProductVariantInput | OrderItemCreateOrConnectWithoutProductVariantInput[]
    createMany?: OrderItemCreateManyProductVariantInputEnvelope
    connect?: OrderItemWhereUniqueInput | OrderItemWhereUniqueInput[]
  }

  export type OrderItemUncheckedCreateNestedManyWithoutProductVariantInput = {
    create?: XOR<OrderItemCreateWithoutProductVariantInput, OrderItemUncheckedCreateWithoutProductVariantInput> | OrderItemCreateWithoutProductVariantInput[] | OrderItemUncheckedCreateWithoutProductVariantInput[]
    connectOrCreate?: OrderItemCreateOrConnectWithoutProductVariantInput | OrderItemCreateOrConnectWithoutProductVariantInput[]
    createMany?: OrderItemCreateManyProductVariantInputEnvelope
    connect?: OrderItemWhereUniqueInput | OrderItemWhereUniqueInput[]
  }

  export type ProductUpdateOneRequiredWithoutVariantsNestedInput = {
    create?: XOR<ProductCreateWithoutVariantsInput, ProductUncheckedCreateWithoutVariantsInput>
    connectOrCreate?: ProductCreateOrConnectWithoutVariantsInput
    upsert?: ProductUpsertWithoutVariantsInput
    connect?: ProductWhereUniqueInput
    update?: XOR<XOR<ProductUpdateToOneWithWhereWithoutVariantsInput, ProductUpdateWithoutVariantsInput>, ProductUncheckedUpdateWithoutVariantsInput>
  }

  export type ProductImageUpdateOneWithoutVariantsNestedInput = {
    create?: XOR<ProductImageCreateWithoutVariantsInput, ProductImageUncheckedCreateWithoutVariantsInput>
    connectOrCreate?: ProductImageCreateOrConnectWithoutVariantsInput
    upsert?: ProductImageUpsertWithoutVariantsInput
    disconnect?: ProductImageWhereInput | boolean
    delete?: ProductImageWhereInput | boolean
    connect?: ProductImageWhereUniqueInput
    update?: XOR<XOR<ProductImageUpdateToOneWithWhereWithoutVariantsInput, ProductImageUpdateWithoutVariantsInput>, ProductImageUncheckedUpdateWithoutVariantsInput>
  }

  export type OrderItemUpdateManyWithoutProductVariantNestedInput = {
    create?: XOR<OrderItemCreateWithoutProductVariantInput, OrderItemUncheckedCreateWithoutProductVariantInput> | OrderItemCreateWithoutProductVariantInput[] | OrderItemUncheckedCreateWithoutProductVariantInput[]
    connectOrCreate?: OrderItemCreateOrConnectWithoutProductVariantInput | OrderItemCreateOrConnectWithoutProductVariantInput[]
    upsert?: OrderItemUpsertWithWhereUniqueWithoutProductVariantInput | OrderItemUpsertWithWhereUniqueWithoutProductVariantInput[]
    createMany?: OrderItemCreateManyProductVariantInputEnvelope
    set?: OrderItemWhereUniqueInput | OrderItemWhereUniqueInput[]
    disconnect?: OrderItemWhereUniqueInput | OrderItemWhereUniqueInput[]
    delete?: OrderItemWhereUniqueInput | OrderItemWhereUniqueInput[]
    connect?: OrderItemWhereUniqueInput | OrderItemWhereUniqueInput[]
    update?: OrderItemUpdateWithWhereUniqueWithoutProductVariantInput | OrderItemUpdateWithWhereUniqueWithoutProductVariantInput[]
    updateMany?: OrderItemUpdateManyWithWhereWithoutProductVariantInput | OrderItemUpdateManyWithWhereWithoutProductVariantInput[]
    deleteMany?: OrderItemScalarWhereInput | OrderItemScalarWhereInput[]
  }

  export type OrderItemUncheckedUpdateManyWithoutProductVariantNestedInput = {
    create?: XOR<OrderItemCreateWithoutProductVariantInput, OrderItemUncheckedCreateWithoutProductVariantInput> | OrderItemCreateWithoutProductVariantInput[] | OrderItemUncheckedCreateWithoutProductVariantInput[]
    connectOrCreate?: OrderItemCreateOrConnectWithoutProductVariantInput | OrderItemCreateOrConnectWithoutProductVariantInput[]
    upsert?: OrderItemUpsertWithWhereUniqueWithoutProductVariantInput | OrderItemUpsertWithWhereUniqueWithoutProductVariantInput[]
    createMany?: OrderItemCreateManyProductVariantInputEnvelope
    set?: OrderItemWhereUniqueInput | OrderItemWhereUniqueInput[]
    disconnect?: OrderItemWhereUniqueInput | OrderItemWhereUniqueInput[]
    delete?: OrderItemWhereUniqueInput | OrderItemWhereUniqueInput[]
    connect?: OrderItemWhereUniqueInput | OrderItemWhereUniqueInput[]
    update?: OrderItemUpdateWithWhereUniqueWithoutProductVariantInput | OrderItemUpdateWithWhereUniqueWithoutProductVariantInput[]
    updateMany?: OrderItemUpdateManyWithWhereWithoutProductVariantInput | OrderItemUpdateManyWithWhereWithoutProductVariantInput[]
    deleteMany?: OrderItemScalarWhereInput | OrderItemScalarWhereInput[]
  }

  export type CustomerCreateNestedOneWithoutOrdersInput = {
    create?: XOR<CustomerCreateWithoutOrdersInput, CustomerUncheckedCreateWithoutOrdersInput>
    connectOrCreate?: CustomerCreateOrConnectWithoutOrdersInput
    connect?: CustomerWhereUniqueInput
  }

  export type BranchCreateNestedOneWithoutOrdersInput = {
    create?: XOR<BranchCreateWithoutOrdersInput, BranchUncheckedCreateWithoutOrdersInput>
    connectOrCreate?: BranchCreateOrConnectWithoutOrdersInput
    connect?: BranchWhereUniqueInput
  }

  export type OrderItemCreateNestedManyWithoutOrderInput = {
    create?: XOR<OrderItemCreateWithoutOrderInput, OrderItemUncheckedCreateWithoutOrderInput> | OrderItemCreateWithoutOrderInput[] | OrderItemUncheckedCreateWithoutOrderInput[]
    connectOrCreate?: OrderItemCreateOrConnectWithoutOrderInput | OrderItemCreateOrConnectWithoutOrderInput[]
    createMany?: OrderItemCreateManyOrderInputEnvelope
    connect?: OrderItemWhereUniqueInput | OrderItemWhereUniqueInput[]
  }

  export type OrderStatusEventCreateNestedManyWithoutOrderInput = {
    create?: XOR<OrderStatusEventCreateWithoutOrderInput, OrderStatusEventUncheckedCreateWithoutOrderInput> | OrderStatusEventCreateWithoutOrderInput[] | OrderStatusEventUncheckedCreateWithoutOrderInput[]
    connectOrCreate?: OrderStatusEventCreateOrConnectWithoutOrderInput | OrderStatusEventCreateOrConnectWithoutOrderInput[]
    createMany?: OrderStatusEventCreateManyOrderInputEnvelope
    connect?: OrderStatusEventWhereUniqueInput | OrderStatusEventWhereUniqueInput[]
  }

  export type LedgerEntryCreateNestedManyWithoutOrderInput = {
    create?: XOR<LedgerEntryCreateWithoutOrderInput, LedgerEntryUncheckedCreateWithoutOrderInput> | LedgerEntryCreateWithoutOrderInput[] | LedgerEntryUncheckedCreateWithoutOrderInput[]
    connectOrCreate?: LedgerEntryCreateOrConnectWithoutOrderInput | LedgerEntryCreateOrConnectWithoutOrderInput[]
    createMany?: LedgerEntryCreateManyOrderInputEnvelope
    connect?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
  }

  export type PreOrderCreateNestedOneWithoutConvertedOrderInput = {
    create?: XOR<PreOrderCreateWithoutConvertedOrderInput, PreOrderUncheckedCreateWithoutConvertedOrderInput>
    connectOrCreate?: PreOrderCreateOrConnectWithoutConvertedOrderInput
    connect?: PreOrderWhereUniqueInput
  }

  export type OrderItemUncheckedCreateNestedManyWithoutOrderInput = {
    create?: XOR<OrderItemCreateWithoutOrderInput, OrderItemUncheckedCreateWithoutOrderInput> | OrderItemCreateWithoutOrderInput[] | OrderItemUncheckedCreateWithoutOrderInput[]
    connectOrCreate?: OrderItemCreateOrConnectWithoutOrderInput | OrderItemCreateOrConnectWithoutOrderInput[]
    createMany?: OrderItemCreateManyOrderInputEnvelope
    connect?: OrderItemWhereUniqueInput | OrderItemWhereUniqueInput[]
  }

  export type OrderStatusEventUncheckedCreateNestedManyWithoutOrderInput = {
    create?: XOR<OrderStatusEventCreateWithoutOrderInput, OrderStatusEventUncheckedCreateWithoutOrderInput> | OrderStatusEventCreateWithoutOrderInput[] | OrderStatusEventUncheckedCreateWithoutOrderInput[]
    connectOrCreate?: OrderStatusEventCreateOrConnectWithoutOrderInput | OrderStatusEventCreateOrConnectWithoutOrderInput[]
    createMany?: OrderStatusEventCreateManyOrderInputEnvelope
    connect?: OrderStatusEventWhereUniqueInput | OrderStatusEventWhereUniqueInput[]
  }

  export type LedgerEntryUncheckedCreateNestedManyWithoutOrderInput = {
    create?: XOR<LedgerEntryCreateWithoutOrderInput, LedgerEntryUncheckedCreateWithoutOrderInput> | LedgerEntryCreateWithoutOrderInput[] | LedgerEntryUncheckedCreateWithoutOrderInput[]
    connectOrCreate?: LedgerEntryCreateOrConnectWithoutOrderInput | LedgerEntryCreateOrConnectWithoutOrderInput[]
    createMany?: LedgerEntryCreateManyOrderInputEnvelope
    connect?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
  }

  export type PreOrderUncheckedCreateNestedOneWithoutConvertedOrderInput = {
    create?: XOR<PreOrderCreateWithoutConvertedOrderInput, PreOrderUncheckedCreateWithoutConvertedOrderInput>
    connectOrCreate?: PreOrderCreateOrConnectWithoutConvertedOrderInput
    connect?: PreOrderWhereUniqueInput
  }

  export type EnumOrderChannelFieldUpdateOperationsInput = {
    set?: $Enums.OrderChannel
  }

  export type EnumOrderStatusFieldUpdateOperationsInput = {
    set?: $Enums.OrderStatus
  }

  export type CustomerUpdateOneRequiredWithoutOrdersNestedInput = {
    create?: XOR<CustomerCreateWithoutOrdersInput, CustomerUncheckedCreateWithoutOrdersInput>
    connectOrCreate?: CustomerCreateOrConnectWithoutOrdersInput
    upsert?: CustomerUpsertWithoutOrdersInput
    connect?: CustomerWhereUniqueInput
    update?: XOR<XOR<CustomerUpdateToOneWithWhereWithoutOrdersInput, CustomerUpdateWithoutOrdersInput>, CustomerUncheckedUpdateWithoutOrdersInput>
  }

  export type BranchUpdateOneWithoutOrdersNestedInput = {
    create?: XOR<BranchCreateWithoutOrdersInput, BranchUncheckedCreateWithoutOrdersInput>
    connectOrCreate?: BranchCreateOrConnectWithoutOrdersInput
    upsert?: BranchUpsertWithoutOrdersInput
    disconnect?: BranchWhereInput | boolean
    delete?: BranchWhereInput | boolean
    connect?: BranchWhereUniqueInput
    update?: XOR<XOR<BranchUpdateToOneWithWhereWithoutOrdersInput, BranchUpdateWithoutOrdersInput>, BranchUncheckedUpdateWithoutOrdersInput>
  }

  export type OrderItemUpdateManyWithoutOrderNestedInput = {
    create?: XOR<OrderItemCreateWithoutOrderInput, OrderItemUncheckedCreateWithoutOrderInput> | OrderItemCreateWithoutOrderInput[] | OrderItemUncheckedCreateWithoutOrderInput[]
    connectOrCreate?: OrderItemCreateOrConnectWithoutOrderInput | OrderItemCreateOrConnectWithoutOrderInput[]
    upsert?: OrderItemUpsertWithWhereUniqueWithoutOrderInput | OrderItemUpsertWithWhereUniqueWithoutOrderInput[]
    createMany?: OrderItemCreateManyOrderInputEnvelope
    set?: OrderItemWhereUniqueInput | OrderItemWhereUniqueInput[]
    disconnect?: OrderItemWhereUniqueInput | OrderItemWhereUniqueInput[]
    delete?: OrderItemWhereUniqueInput | OrderItemWhereUniqueInput[]
    connect?: OrderItemWhereUniqueInput | OrderItemWhereUniqueInput[]
    update?: OrderItemUpdateWithWhereUniqueWithoutOrderInput | OrderItemUpdateWithWhereUniqueWithoutOrderInput[]
    updateMany?: OrderItemUpdateManyWithWhereWithoutOrderInput | OrderItemUpdateManyWithWhereWithoutOrderInput[]
    deleteMany?: OrderItemScalarWhereInput | OrderItemScalarWhereInput[]
  }

  export type OrderStatusEventUpdateManyWithoutOrderNestedInput = {
    create?: XOR<OrderStatusEventCreateWithoutOrderInput, OrderStatusEventUncheckedCreateWithoutOrderInput> | OrderStatusEventCreateWithoutOrderInput[] | OrderStatusEventUncheckedCreateWithoutOrderInput[]
    connectOrCreate?: OrderStatusEventCreateOrConnectWithoutOrderInput | OrderStatusEventCreateOrConnectWithoutOrderInput[]
    upsert?: OrderStatusEventUpsertWithWhereUniqueWithoutOrderInput | OrderStatusEventUpsertWithWhereUniqueWithoutOrderInput[]
    createMany?: OrderStatusEventCreateManyOrderInputEnvelope
    set?: OrderStatusEventWhereUniqueInput | OrderStatusEventWhereUniqueInput[]
    disconnect?: OrderStatusEventWhereUniqueInput | OrderStatusEventWhereUniqueInput[]
    delete?: OrderStatusEventWhereUniqueInput | OrderStatusEventWhereUniqueInput[]
    connect?: OrderStatusEventWhereUniqueInput | OrderStatusEventWhereUniqueInput[]
    update?: OrderStatusEventUpdateWithWhereUniqueWithoutOrderInput | OrderStatusEventUpdateWithWhereUniqueWithoutOrderInput[]
    updateMany?: OrderStatusEventUpdateManyWithWhereWithoutOrderInput | OrderStatusEventUpdateManyWithWhereWithoutOrderInput[]
    deleteMany?: OrderStatusEventScalarWhereInput | OrderStatusEventScalarWhereInput[]
  }

  export type LedgerEntryUpdateManyWithoutOrderNestedInput = {
    create?: XOR<LedgerEntryCreateWithoutOrderInput, LedgerEntryUncheckedCreateWithoutOrderInput> | LedgerEntryCreateWithoutOrderInput[] | LedgerEntryUncheckedCreateWithoutOrderInput[]
    connectOrCreate?: LedgerEntryCreateOrConnectWithoutOrderInput | LedgerEntryCreateOrConnectWithoutOrderInput[]
    upsert?: LedgerEntryUpsertWithWhereUniqueWithoutOrderInput | LedgerEntryUpsertWithWhereUniqueWithoutOrderInput[]
    createMany?: LedgerEntryCreateManyOrderInputEnvelope
    set?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
    disconnect?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
    delete?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
    connect?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
    update?: LedgerEntryUpdateWithWhereUniqueWithoutOrderInput | LedgerEntryUpdateWithWhereUniqueWithoutOrderInput[]
    updateMany?: LedgerEntryUpdateManyWithWhereWithoutOrderInput | LedgerEntryUpdateManyWithWhereWithoutOrderInput[]
    deleteMany?: LedgerEntryScalarWhereInput | LedgerEntryScalarWhereInput[]
  }

  export type PreOrderUpdateOneWithoutConvertedOrderNestedInput = {
    create?: XOR<PreOrderCreateWithoutConvertedOrderInput, PreOrderUncheckedCreateWithoutConvertedOrderInput>
    connectOrCreate?: PreOrderCreateOrConnectWithoutConvertedOrderInput
    upsert?: PreOrderUpsertWithoutConvertedOrderInput
    disconnect?: PreOrderWhereInput | boolean
    delete?: PreOrderWhereInput | boolean
    connect?: PreOrderWhereUniqueInput
    update?: XOR<XOR<PreOrderUpdateToOneWithWhereWithoutConvertedOrderInput, PreOrderUpdateWithoutConvertedOrderInput>, PreOrderUncheckedUpdateWithoutConvertedOrderInput>
  }

  export type OrderItemUncheckedUpdateManyWithoutOrderNestedInput = {
    create?: XOR<OrderItemCreateWithoutOrderInput, OrderItemUncheckedCreateWithoutOrderInput> | OrderItemCreateWithoutOrderInput[] | OrderItemUncheckedCreateWithoutOrderInput[]
    connectOrCreate?: OrderItemCreateOrConnectWithoutOrderInput | OrderItemCreateOrConnectWithoutOrderInput[]
    upsert?: OrderItemUpsertWithWhereUniqueWithoutOrderInput | OrderItemUpsertWithWhereUniqueWithoutOrderInput[]
    createMany?: OrderItemCreateManyOrderInputEnvelope
    set?: OrderItemWhereUniqueInput | OrderItemWhereUniqueInput[]
    disconnect?: OrderItemWhereUniqueInput | OrderItemWhereUniqueInput[]
    delete?: OrderItemWhereUniqueInput | OrderItemWhereUniqueInput[]
    connect?: OrderItemWhereUniqueInput | OrderItemWhereUniqueInput[]
    update?: OrderItemUpdateWithWhereUniqueWithoutOrderInput | OrderItemUpdateWithWhereUniqueWithoutOrderInput[]
    updateMany?: OrderItemUpdateManyWithWhereWithoutOrderInput | OrderItemUpdateManyWithWhereWithoutOrderInput[]
    deleteMany?: OrderItemScalarWhereInput | OrderItemScalarWhereInput[]
  }

  export type OrderStatusEventUncheckedUpdateManyWithoutOrderNestedInput = {
    create?: XOR<OrderStatusEventCreateWithoutOrderInput, OrderStatusEventUncheckedCreateWithoutOrderInput> | OrderStatusEventCreateWithoutOrderInput[] | OrderStatusEventUncheckedCreateWithoutOrderInput[]
    connectOrCreate?: OrderStatusEventCreateOrConnectWithoutOrderInput | OrderStatusEventCreateOrConnectWithoutOrderInput[]
    upsert?: OrderStatusEventUpsertWithWhereUniqueWithoutOrderInput | OrderStatusEventUpsertWithWhereUniqueWithoutOrderInput[]
    createMany?: OrderStatusEventCreateManyOrderInputEnvelope
    set?: OrderStatusEventWhereUniqueInput | OrderStatusEventWhereUniqueInput[]
    disconnect?: OrderStatusEventWhereUniqueInput | OrderStatusEventWhereUniqueInput[]
    delete?: OrderStatusEventWhereUniqueInput | OrderStatusEventWhereUniqueInput[]
    connect?: OrderStatusEventWhereUniqueInput | OrderStatusEventWhereUniqueInput[]
    update?: OrderStatusEventUpdateWithWhereUniqueWithoutOrderInput | OrderStatusEventUpdateWithWhereUniqueWithoutOrderInput[]
    updateMany?: OrderStatusEventUpdateManyWithWhereWithoutOrderInput | OrderStatusEventUpdateManyWithWhereWithoutOrderInput[]
    deleteMany?: OrderStatusEventScalarWhereInput | OrderStatusEventScalarWhereInput[]
  }

  export type LedgerEntryUncheckedUpdateManyWithoutOrderNestedInput = {
    create?: XOR<LedgerEntryCreateWithoutOrderInput, LedgerEntryUncheckedCreateWithoutOrderInput> | LedgerEntryCreateWithoutOrderInput[] | LedgerEntryUncheckedCreateWithoutOrderInput[]
    connectOrCreate?: LedgerEntryCreateOrConnectWithoutOrderInput | LedgerEntryCreateOrConnectWithoutOrderInput[]
    upsert?: LedgerEntryUpsertWithWhereUniqueWithoutOrderInput | LedgerEntryUpsertWithWhereUniqueWithoutOrderInput[]
    createMany?: LedgerEntryCreateManyOrderInputEnvelope
    set?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
    disconnect?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
    delete?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
    connect?: LedgerEntryWhereUniqueInput | LedgerEntryWhereUniqueInput[]
    update?: LedgerEntryUpdateWithWhereUniqueWithoutOrderInput | LedgerEntryUpdateWithWhereUniqueWithoutOrderInput[]
    updateMany?: LedgerEntryUpdateManyWithWhereWithoutOrderInput | LedgerEntryUpdateManyWithWhereWithoutOrderInput[]
    deleteMany?: LedgerEntryScalarWhereInput | LedgerEntryScalarWhereInput[]
  }

  export type PreOrderUncheckedUpdateOneWithoutConvertedOrderNestedInput = {
    create?: XOR<PreOrderCreateWithoutConvertedOrderInput, PreOrderUncheckedCreateWithoutConvertedOrderInput>
    connectOrCreate?: PreOrderCreateOrConnectWithoutConvertedOrderInput
    upsert?: PreOrderUpsertWithoutConvertedOrderInput
    disconnect?: PreOrderWhereInput | boolean
    delete?: PreOrderWhereInput | boolean
    connect?: PreOrderWhereUniqueInput
    update?: XOR<XOR<PreOrderUpdateToOneWithWhereWithoutConvertedOrderInput, PreOrderUpdateWithoutConvertedOrderInput>, PreOrderUncheckedUpdateWithoutConvertedOrderInput>
  }

  export type OrderCreateNestedOneWithoutItemsInput = {
    create?: XOR<OrderCreateWithoutItemsInput, OrderUncheckedCreateWithoutItemsInput>
    connectOrCreate?: OrderCreateOrConnectWithoutItemsInput
    connect?: OrderWhereUniqueInput
  }

  export type ProductVariantCreateNestedOneWithoutOrderItemsInput = {
    create?: XOR<ProductVariantCreateWithoutOrderItemsInput, ProductVariantUncheckedCreateWithoutOrderItemsInput>
    connectOrCreate?: ProductVariantCreateOrConnectWithoutOrderItemsInput
    connect?: ProductVariantWhereUniqueInput
  }

  export type OrderUpdateOneRequiredWithoutItemsNestedInput = {
    create?: XOR<OrderCreateWithoutItemsInput, OrderUncheckedCreateWithoutItemsInput>
    connectOrCreate?: OrderCreateOrConnectWithoutItemsInput
    upsert?: OrderUpsertWithoutItemsInput
    connect?: OrderWhereUniqueInput
    update?: XOR<XOR<OrderUpdateToOneWithWhereWithoutItemsInput, OrderUpdateWithoutItemsInput>, OrderUncheckedUpdateWithoutItemsInput>
  }

  export type ProductVariantUpdateOneRequiredWithoutOrderItemsNestedInput = {
    create?: XOR<ProductVariantCreateWithoutOrderItemsInput, ProductVariantUncheckedCreateWithoutOrderItemsInput>
    connectOrCreate?: ProductVariantCreateOrConnectWithoutOrderItemsInput
    upsert?: ProductVariantUpsertWithoutOrderItemsInput
    connect?: ProductVariantWhereUniqueInput
    update?: XOR<XOR<ProductVariantUpdateToOneWithWhereWithoutOrderItemsInput, ProductVariantUpdateWithoutOrderItemsInput>, ProductVariantUncheckedUpdateWithoutOrderItemsInput>
  }

  export type OrderCreateNestedOneWithoutStatusEventsInput = {
    create?: XOR<OrderCreateWithoutStatusEventsInput, OrderUncheckedCreateWithoutStatusEventsInput>
    connectOrCreate?: OrderCreateOrConnectWithoutStatusEventsInput
    connect?: OrderWhereUniqueInput
  }

  export type AdminUserCreateNestedOneWithoutOrderStatusEventsInput = {
    create?: XOR<AdminUserCreateWithoutOrderStatusEventsInput, AdminUserUncheckedCreateWithoutOrderStatusEventsInput>
    connectOrCreate?: AdminUserCreateOrConnectWithoutOrderStatusEventsInput
    connect?: AdminUserWhereUniqueInput
  }

  export type NullableEnumOrderStatusFieldUpdateOperationsInput = {
    set?: $Enums.OrderStatus | null
  }

  export type OrderUpdateOneRequiredWithoutStatusEventsNestedInput = {
    create?: XOR<OrderCreateWithoutStatusEventsInput, OrderUncheckedCreateWithoutStatusEventsInput>
    connectOrCreate?: OrderCreateOrConnectWithoutStatusEventsInput
    upsert?: OrderUpsertWithoutStatusEventsInput
    connect?: OrderWhereUniqueInput
    update?: XOR<XOR<OrderUpdateToOneWithWhereWithoutStatusEventsInput, OrderUpdateWithoutStatusEventsInput>, OrderUncheckedUpdateWithoutStatusEventsInput>
  }

  export type AdminUserUpdateOneWithoutOrderStatusEventsNestedInput = {
    create?: XOR<AdminUserCreateWithoutOrderStatusEventsInput, AdminUserUncheckedCreateWithoutOrderStatusEventsInput>
    connectOrCreate?: AdminUserCreateOrConnectWithoutOrderStatusEventsInput
    upsert?: AdminUserUpsertWithoutOrderStatusEventsInput
    disconnect?: AdminUserWhereInput | boolean
    delete?: AdminUserWhereInput | boolean
    connect?: AdminUserWhereUniqueInput
    update?: XOR<XOR<AdminUserUpdateToOneWithWhereWithoutOrderStatusEventsInput, AdminUserUpdateWithoutOrderStatusEventsInput>, AdminUserUncheckedUpdateWithoutOrderStatusEventsInput>
  }

  export type CustomerCreateNestedOneWithoutPreOrdersInput = {
    create?: XOR<CustomerCreateWithoutPreOrdersInput, CustomerUncheckedCreateWithoutPreOrdersInput>
    connectOrCreate?: CustomerCreateOrConnectWithoutPreOrdersInput
    connect?: CustomerWhereUniqueInput
  }

  export type CityCreateNestedOneWithoutPreOrdersInput = {
    create?: XOR<CityCreateWithoutPreOrdersInput, CityUncheckedCreateWithoutPreOrdersInput>
    connectOrCreate?: CityCreateOrConnectWithoutPreOrdersInput
    connect?: CityWhereUniqueInput
  }

  export type WorkshopCreateNestedOneWithoutPreOrdersInput = {
    create?: XOR<WorkshopCreateWithoutPreOrdersInput, WorkshopUncheckedCreateWithoutPreOrdersInput>
    connectOrCreate?: WorkshopCreateOrConnectWithoutPreOrdersInput
    connect?: WorkshopWhereUniqueInput
  }

  export type OrderCreateNestedOneWithoutConvertedFromPreOrderInput = {
    create?: XOR<OrderCreateWithoutConvertedFromPreOrderInput, OrderUncheckedCreateWithoutConvertedFromPreOrderInput>
    connectOrCreate?: OrderCreateOrConnectWithoutConvertedFromPreOrderInput
    connect?: OrderWhereUniqueInput
  }

  export type PreOrderStatusEventCreateNestedManyWithoutPreOrderInput = {
    create?: XOR<PreOrderStatusEventCreateWithoutPreOrderInput, PreOrderStatusEventUncheckedCreateWithoutPreOrderInput> | PreOrderStatusEventCreateWithoutPreOrderInput[] | PreOrderStatusEventUncheckedCreateWithoutPreOrderInput[]
    connectOrCreate?: PreOrderStatusEventCreateOrConnectWithoutPreOrderInput | PreOrderStatusEventCreateOrConnectWithoutPreOrderInput[]
    createMany?: PreOrderStatusEventCreateManyPreOrderInputEnvelope
    connect?: PreOrderStatusEventWhereUniqueInput | PreOrderStatusEventWhereUniqueInput[]
  }

  export type PreOrderStatusEventUncheckedCreateNestedManyWithoutPreOrderInput = {
    create?: XOR<PreOrderStatusEventCreateWithoutPreOrderInput, PreOrderStatusEventUncheckedCreateWithoutPreOrderInput> | PreOrderStatusEventCreateWithoutPreOrderInput[] | PreOrderStatusEventUncheckedCreateWithoutPreOrderInput[]
    connectOrCreate?: PreOrderStatusEventCreateOrConnectWithoutPreOrderInput | PreOrderStatusEventCreateOrConnectWithoutPreOrderInput[]
    createMany?: PreOrderStatusEventCreateManyPreOrderInputEnvelope
    connect?: PreOrderStatusEventWhereUniqueInput | PreOrderStatusEventWhereUniqueInput[]
  }

  export type EnumPreOrderStatusFieldUpdateOperationsInput = {
    set?: $Enums.PreOrderStatus
  }

  export type CustomerUpdateOneRequiredWithoutPreOrdersNestedInput = {
    create?: XOR<CustomerCreateWithoutPreOrdersInput, CustomerUncheckedCreateWithoutPreOrdersInput>
    connectOrCreate?: CustomerCreateOrConnectWithoutPreOrdersInput
    upsert?: CustomerUpsertWithoutPreOrdersInput
    connect?: CustomerWhereUniqueInput
    update?: XOR<XOR<CustomerUpdateToOneWithWhereWithoutPreOrdersInput, CustomerUpdateWithoutPreOrdersInput>, CustomerUncheckedUpdateWithoutPreOrdersInput>
  }

  export type CityUpdateOneWithoutPreOrdersNestedInput = {
    create?: XOR<CityCreateWithoutPreOrdersInput, CityUncheckedCreateWithoutPreOrdersInput>
    connectOrCreate?: CityCreateOrConnectWithoutPreOrdersInput
    upsert?: CityUpsertWithoutPreOrdersInput
    disconnect?: CityWhereInput | boolean
    delete?: CityWhereInput | boolean
    connect?: CityWhereUniqueInput
    update?: XOR<XOR<CityUpdateToOneWithWhereWithoutPreOrdersInput, CityUpdateWithoutPreOrdersInput>, CityUncheckedUpdateWithoutPreOrdersInput>
  }

  export type WorkshopUpdateOneWithoutPreOrdersNestedInput = {
    create?: XOR<WorkshopCreateWithoutPreOrdersInput, WorkshopUncheckedCreateWithoutPreOrdersInput>
    connectOrCreate?: WorkshopCreateOrConnectWithoutPreOrdersInput
    upsert?: WorkshopUpsertWithoutPreOrdersInput
    disconnect?: WorkshopWhereInput | boolean
    delete?: WorkshopWhereInput | boolean
    connect?: WorkshopWhereUniqueInput
    update?: XOR<XOR<WorkshopUpdateToOneWithWhereWithoutPreOrdersInput, WorkshopUpdateWithoutPreOrdersInput>, WorkshopUncheckedUpdateWithoutPreOrdersInput>
  }

  export type OrderUpdateOneWithoutConvertedFromPreOrderNestedInput = {
    create?: XOR<OrderCreateWithoutConvertedFromPreOrderInput, OrderUncheckedCreateWithoutConvertedFromPreOrderInput>
    connectOrCreate?: OrderCreateOrConnectWithoutConvertedFromPreOrderInput
    upsert?: OrderUpsertWithoutConvertedFromPreOrderInput
    disconnect?: OrderWhereInput | boolean
    delete?: OrderWhereInput | boolean
    connect?: OrderWhereUniqueInput
    update?: XOR<XOR<OrderUpdateToOneWithWhereWithoutConvertedFromPreOrderInput, OrderUpdateWithoutConvertedFromPreOrderInput>, OrderUncheckedUpdateWithoutConvertedFromPreOrderInput>
  }

  export type PreOrderStatusEventUpdateManyWithoutPreOrderNestedInput = {
    create?: XOR<PreOrderStatusEventCreateWithoutPreOrderInput, PreOrderStatusEventUncheckedCreateWithoutPreOrderInput> | PreOrderStatusEventCreateWithoutPreOrderInput[] | PreOrderStatusEventUncheckedCreateWithoutPreOrderInput[]
    connectOrCreate?: PreOrderStatusEventCreateOrConnectWithoutPreOrderInput | PreOrderStatusEventCreateOrConnectWithoutPreOrderInput[]
    upsert?: PreOrderStatusEventUpsertWithWhereUniqueWithoutPreOrderInput | PreOrderStatusEventUpsertWithWhereUniqueWithoutPreOrderInput[]
    createMany?: PreOrderStatusEventCreateManyPreOrderInputEnvelope
    set?: PreOrderStatusEventWhereUniqueInput | PreOrderStatusEventWhereUniqueInput[]
    disconnect?: PreOrderStatusEventWhereUniqueInput | PreOrderStatusEventWhereUniqueInput[]
    delete?: PreOrderStatusEventWhereUniqueInput | PreOrderStatusEventWhereUniqueInput[]
    connect?: PreOrderStatusEventWhereUniqueInput | PreOrderStatusEventWhereUniqueInput[]
    update?: PreOrderStatusEventUpdateWithWhereUniqueWithoutPreOrderInput | PreOrderStatusEventUpdateWithWhereUniqueWithoutPreOrderInput[]
    updateMany?: PreOrderStatusEventUpdateManyWithWhereWithoutPreOrderInput | PreOrderStatusEventUpdateManyWithWhereWithoutPreOrderInput[]
    deleteMany?: PreOrderStatusEventScalarWhereInput | PreOrderStatusEventScalarWhereInput[]
  }

  export type PreOrderStatusEventUncheckedUpdateManyWithoutPreOrderNestedInput = {
    create?: XOR<PreOrderStatusEventCreateWithoutPreOrderInput, PreOrderStatusEventUncheckedCreateWithoutPreOrderInput> | PreOrderStatusEventCreateWithoutPreOrderInput[] | PreOrderStatusEventUncheckedCreateWithoutPreOrderInput[]
    connectOrCreate?: PreOrderStatusEventCreateOrConnectWithoutPreOrderInput | PreOrderStatusEventCreateOrConnectWithoutPreOrderInput[]
    upsert?: PreOrderStatusEventUpsertWithWhereUniqueWithoutPreOrderInput | PreOrderStatusEventUpsertWithWhereUniqueWithoutPreOrderInput[]
    createMany?: PreOrderStatusEventCreateManyPreOrderInputEnvelope
    set?: PreOrderStatusEventWhereUniqueInput | PreOrderStatusEventWhereUniqueInput[]
    disconnect?: PreOrderStatusEventWhereUniqueInput | PreOrderStatusEventWhereUniqueInput[]
    delete?: PreOrderStatusEventWhereUniqueInput | PreOrderStatusEventWhereUniqueInput[]
    connect?: PreOrderStatusEventWhereUniqueInput | PreOrderStatusEventWhereUniqueInput[]
    update?: PreOrderStatusEventUpdateWithWhereUniqueWithoutPreOrderInput | PreOrderStatusEventUpdateWithWhereUniqueWithoutPreOrderInput[]
    updateMany?: PreOrderStatusEventUpdateManyWithWhereWithoutPreOrderInput | PreOrderStatusEventUpdateManyWithWhereWithoutPreOrderInput[]
    deleteMany?: PreOrderStatusEventScalarWhereInput | PreOrderStatusEventScalarWhereInput[]
  }

  export type PreOrderCreateNestedOneWithoutStatusEventsInput = {
    create?: XOR<PreOrderCreateWithoutStatusEventsInput, PreOrderUncheckedCreateWithoutStatusEventsInput>
    connectOrCreate?: PreOrderCreateOrConnectWithoutStatusEventsInput
    connect?: PreOrderWhereUniqueInput
  }

  export type AdminUserCreateNestedOneWithoutPreOrderStatusEventsInput = {
    create?: XOR<AdminUserCreateWithoutPreOrderStatusEventsInput, AdminUserUncheckedCreateWithoutPreOrderStatusEventsInput>
    connectOrCreate?: AdminUserCreateOrConnectWithoutPreOrderStatusEventsInput
    connect?: AdminUserWhereUniqueInput
  }

  export type PreOrderUpdateOneRequiredWithoutStatusEventsNestedInput = {
    create?: XOR<PreOrderCreateWithoutStatusEventsInput, PreOrderUncheckedCreateWithoutStatusEventsInput>
    connectOrCreate?: PreOrderCreateOrConnectWithoutStatusEventsInput
    upsert?: PreOrderUpsertWithoutStatusEventsInput
    connect?: PreOrderWhereUniqueInput
    update?: XOR<XOR<PreOrderUpdateToOneWithWhereWithoutStatusEventsInput, PreOrderUpdateWithoutStatusEventsInput>, PreOrderUncheckedUpdateWithoutStatusEventsInput>
  }

  export type AdminUserUpdateOneWithoutPreOrderStatusEventsNestedInput = {
    create?: XOR<AdminUserCreateWithoutPreOrderStatusEventsInput, AdminUserUncheckedCreateWithoutPreOrderStatusEventsInput>
    connectOrCreate?: AdminUserCreateOrConnectWithoutPreOrderStatusEventsInput
    upsert?: AdminUserUpsertWithoutPreOrderStatusEventsInput
    disconnect?: AdminUserWhereInput | boolean
    delete?: AdminUserWhereInput | boolean
    connect?: AdminUserWhereUniqueInput
    update?: XOR<XOR<AdminUserUpdateToOneWithWhereWithoutPreOrderStatusEventsInput, AdminUserUpdateWithoutPreOrderStatusEventsInput>, AdminUserUncheckedUpdateWithoutPreOrderStatusEventsInput>
  }

  export type CustomerCreateNestedOneWithoutLedgerEntriesInput = {
    create?: XOR<CustomerCreateWithoutLedgerEntriesInput, CustomerUncheckedCreateWithoutLedgerEntriesInput>
    connectOrCreate?: CustomerCreateOrConnectWithoutLedgerEntriesInput
    connect?: CustomerWhereUniqueInput
  }

  export type OrderCreateNestedOneWithoutLedgerEntriesInput = {
    create?: XOR<OrderCreateWithoutLedgerEntriesInput, OrderUncheckedCreateWithoutLedgerEntriesInput>
    connectOrCreate?: OrderCreateOrConnectWithoutLedgerEntriesInput
    connect?: OrderWhereUniqueInput
  }

  export type AdminUserCreateNestedOneWithoutPostedLedgerEntriesInput = {
    create?: XOR<AdminUserCreateWithoutPostedLedgerEntriesInput, AdminUserUncheckedCreateWithoutPostedLedgerEntriesInput>
    connectOrCreate?: AdminUserCreateOrConnectWithoutPostedLedgerEntriesInput
    connect?: AdminUserWhereUniqueInput
  }

  export type EnumLedgerCurrencyFieldUpdateOperationsInput = {
    set?: $Enums.LedgerCurrency
  }

  export type EnumLedgerDirectionFieldUpdateOperationsInput = {
    set?: $Enums.LedgerDirection
  }

  export type EnumLedgerSourceTypeFieldUpdateOperationsInput = {
    set?: $Enums.LedgerSourceType
  }

  export type CustomerUpdateOneRequiredWithoutLedgerEntriesNestedInput = {
    create?: XOR<CustomerCreateWithoutLedgerEntriesInput, CustomerUncheckedCreateWithoutLedgerEntriesInput>
    connectOrCreate?: CustomerCreateOrConnectWithoutLedgerEntriesInput
    upsert?: CustomerUpsertWithoutLedgerEntriesInput
    connect?: CustomerWhereUniqueInput
    update?: XOR<XOR<CustomerUpdateToOneWithWhereWithoutLedgerEntriesInput, CustomerUpdateWithoutLedgerEntriesInput>, CustomerUncheckedUpdateWithoutLedgerEntriesInput>
  }

  export type OrderUpdateOneWithoutLedgerEntriesNestedInput = {
    create?: XOR<OrderCreateWithoutLedgerEntriesInput, OrderUncheckedCreateWithoutLedgerEntriesInput>
    connectOrCreate?: OrderCreateOrConnectWithoutLedgerEntriesInput
    upsert?: OrderUpsertWithoutLedgerEntriesInput
    disconnect?: OrderWhereInput | boolean
    delete?: OrderWhereInput | boolean
    connect?: OrderWhereUniqueInput
    update?: XOR<XOR<OrderUpdateToOneWithWhereWithoutLedgerEntriesInput, OrderUpdateWithoutLedgerEntriesInput>, OrderUncheckedUpdateWithoutLedgerEntriesInput>
  }

  export type AdminUserUpdateOneWithoutPostedLedgerEntriesNestedInput = {
    create?: XOR<AdminUserCreateWithoutPostedLedgerEntriesInput, AdminUserUncheckedCreateWithoutPostedLedgerEntriesInput>
    connectOrCreate?: AdminUserCreateOrConnectWithoutPostedLedgerEntriesInput
    upsert?: AdminUserUpsertWithoutPostedLedgerEntriesInput
    disconnect?: AdminUserWhereInput | boolean
    delete?: AdminUserWhereInput | boolean
    connect?: AdminUserWhereUniqueInput
    update?: XOR<XOR<AdminUserUpdateToOneWithWhereWithoutPostedLedgerEntriesInput, AdminUserUpdateWithoutPostedLedgerEntriesInput>, AdminUserUncheckedUpdateWithoutPostedLedgerEntriesInput>
  }

  export type CustomerCreateNestedOneWithoutWalletBonusesInput = {
    create?: XOR<CustomerCreateWithoutWalletBonusesInput, CustomerUncheckedCreateWithoutWalletBonusesInput>
    connectOrCreate?: CustomerCreateOrConnectWithoutWalletBonusesInput
    connect?: CustomerWhereUniqueInput
  }

  export type CustomerUpdateOneRequiredWithoutWalletBonusesNestedInput = {
    create?: XOR<CustomerCreateWithoutWalletBonusesInput, CustomerUncheckedCreateWithoutWalletBonusesInput>
    connectOrCreate?: CustomerCreateOrConnectWithoutWalletBonusesInput
    upsert?: CustomerUpsertWithoutWalletBonusesInput
    connect?: CustomerWhereUniqueInput
    update?: XOR<XOR<CustomerUpdateToOneWithWhereWithoutWalletBonusesInput, CustomerUpdateWithoutWalletBonusesInput>, CustomerUncheckedUpdateWithoutWalletBonusesInput>
  }

  export type PermissionCreateNestedManyWithoutUserTypeInput = {
    create?: XOR<PermissionCreateWithoutUserTypeInput, PermissionUncheckedCreateWithoutUserTypeInput> | PermissionCreateWithoutUserTypeInput[] | PermissionUncheckedCreateWithoutUserTypeInput[]
    connectOrCreate?: PermissionCreateOrConnectWithoutUserTypeInput | PermissionCreateOrConnectWithoutUserTypeInput[]
    createMany?: PermissionCreateManyUserTypeInputEnvelope
    connect?: PermissionWhereUniqueInput | PermissionWhereUniqueInput[]
  }

  export type AdminUserCreateNestedManyWithoutUserTypeInput = {
    create?: XOR<AdminUserCreateWithoutUserTypeInput, AdminUserUncheckedCreateWithoutUserTypeInput> | AdminUserCreateWithoutUserTypeInput[] | AdminUserUncheckedCreateWithoutUserTypeInput[]
    connectOrCreate?: AdminUserCreateOrConnectWithoutUserTypeInput | AdminUserCreateOrConnectWithoutUserTypeInput[]
    createMany?: AdminUserCreateManyUserTypeInputEnvelope
    connect?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
  }

  export type PermissionUncheckedCreateNestedManyWithoutUserTypeInput = {
    create?: XOR<PermissionCreateWithoutUserTypeInput, PermissionUncheckedCreateWithoutUserTypeInput> | PermissionCreateWithoutUserTypeInput[] | PermissionUncheckedCreateWithoutUserTypeInput[]
    connectOrCreate?: PermissionCreateOrConnectWithoutUserTypeInput | PermissionCreateOrConnectWithoutUserTypeInput[]
    createMany?: PermissionCreateManyUserTypeInputEnvelope
    connect?: PermissionWhereUniqueInput | PermissionWhereUniqueInput[]
  }

  export type AdminUserUncheckedCreateNestedManyWithoutUserTypeInput = {
    create?: XOR<AdminUserCreateWithoutUserTypeInput, AdminUserUncheckedCreateWithoutUserTypeInput> | AdminUserCreateWithoutUserTypeInput[] | AdminUserUncheckedCreateWithoutUserTypeInput[]
    connectOrCreate?: AdminUserCreateOrConnectWithoutUserTypeInput | AdminUserCreateOrConnectWithoutUserTypeInput[]
    createMany?: AdminUserCreateManyUserTypeInputEnvelope
    connect?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
  }

  export type PermissionUpdateManyWithoutUserTypeNestedInput = {
    create?: XOR<PermissionCreateWithoutUserTypeInput, PermissionUncheckedCreateWithoutUserTypeInput> | PermissionCreateWithoutUserTypeInput[] | PermissionUncheckedCreateWithoutUserTypeInput[]
    connectOrCreate?: PermissionCreateOrConnectWithoutUserTypeInput | PermissionCreateOrConnectWithoutUserTypeInput[]
    upsert?: PermissionUpsertWithWhereUniqueWithoutUserTypeInput | PermissionUpsertWithWhereUniqueWithoutUserTypeInput[]
    createMany?: PermissionCreateManyUserTypeInputEnvelope
    set?: PermissionWhereUniqueInput | PermissionWhereUniqueInput[]
    disconnect?: PermissionWhereUniqueInput | PermissionWhereUniqueInput[]
    delete?: PermissionWhereUniqueInput | PermissionWhereUniqueInput[]
    connect?: PermissionWhereUniqueInput | PermissionWhereUniqueInput[]
    update?: PermissionUpdateWithWhereUniqueWithoutUserTypeInput | PermissionUpdateWithWhereUniqueWithoutUserTypeInput[]
    updateMany?: PermissionUpdateManyWithWhereWithoutUserTypeInput | PermissionUpdateManyWithWhereWithoutUserTypeInput[]
    deleteMany?: PermissionScalarWhereInput | PermissionScalarWhereInput[]
  }

  export type AdminUserUpdateManyWithoutUserTypeNestedInput = {
    create?: XOR<AdminUserCreateWithoutUserTypeInput, AdminUserUncheckedCreateWithoutUserTypeInput> | AdminUserCreateWithoutUserTypeInput[] | AdminUserUncheckedCreateWithoutUserTypeInput[]
    connectOrCreate?: AdminUserCreateOrConnectWithoutUserTypeInput | AdminUserCreateOrConnectWithoutUserTypeInput[]
    upsert?: AdminUserUpsertWithWhereUniqueWithoutUserTypeInput | AdminUserUpsertWithWhereUniqueWithoutUserTypeInput[]
    createMany?: AdminUserCreateManyUserTypeInputEnvelope
    set?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
    disconnect?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
    delete?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
    connect?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
    update?: AdminUserUpdateWithWhereUniqueWithoutUserTypeInput | AdminUserUpdateWithWhereUniqueWithoutUserTypeInput[]
    updateMany?: AdminUserUpdateManyWithWhereWithoutUserTypeInput | AdminUserUpdateManyWithWhereWithoutUserTypeInput[]
    deleteMany?: AdminUserScalarWhereInput | AdminUserScalarWhereInput[]
  }

  export type PermissionUncheckedUpdateManyWithoutUserTypeNestedInput = {
    create?: XOR<PermissionCreateWithoutUserTypeInput, PermissionUncheckedCreateWithoutUserTypeInput> | PermissionCreateWithoutUserTypeInput[] | PermissionUncheckedCreateWithoutUserTypeInput[]
    connectOrCreate?: PermissionCreateOrConnectWithoutUserTypeInput | PermissionCreateOrConnectWithoutUserTypeInput[]
    upsert?: PermissionUpsertWithWhereUniqueWithoutUserTypeInput | PermissionUpsertWithWhereUniqueWithoutUserTypeInput[]
    createMany?: PermissionCreateManyUserTypeInputEnvelope
    set?: PermissionWhereUniqueInput | PermissionWhereUniqueInput[]
    disconnect?: PermissionWhereUniqueInput | PermissionWhereUniqueInput[]
    delete?: PermissionWhereUniqueInput | PermissionWhereUniqueInput[]
    connect?: PermissionWhereUniqueInput | PermissionWhereUniqueInput[]
    update?: PermissionUpdateWithWhereUniqueWithoutUserTypeInput | PermissionUpdateWithWhereUniqueWithoutUserTypeInput[]
    updateMany?: PermissionUpdateManyWithWhereWithoutUserTypeInput | PermissionUpdateManyWithWhereWithoutUserTypeInput[]
    deleteMany?: PermissionScalarWhereInput | PermissionScalarWhereInput[]
  }

  export type AdminUserUncheckedUpdateManyWithoutUserTypeNestedInput = {
    create?: XOR<AdminUserCreateWithoutUserTypeInput, AdminUserUncheckedCreateWithoutUserTypeInput> | AdminUserCreateWithoutUserTypeInput[] | AdminUserUncheckedCreateWithoutUserTypeInput[]
    connectOrCreate?: AdminUserCreateOrConnectWithoutUserTypeInput | AdminUserCreateOrConnectWithoutUserTypeInput[]
    upsert?: AdminUserUpsertWithWhereUniqueWithoutUserTypeInput | AdminUserUpsertWithWhereUniqueWithoutUserTypeInput[]
    createMany?: AdminUserCreateManyUserTypeInputEnvelope
    set?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
    disconnect?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
    delete?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
    connect?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
    update?: AdminUserUpdateWithWhereUniqueWithoutUserTypeInput | AdminUserUpdateWithWhereUniqueWithoutUserTypeInput[]
    updateMany?: AdminUserUpdateManyWithWhereWithoutUserTypeInput | AdminUserUpdateManyWithWhereWithoutUserTypeInput[]
    deleteMany?: AdminUserScalarWhereInput | AdminUserScalarWhereInput[]
  }

  export type UserTypeCreateNestedOneWithoutPermissionsInput = {
    create?: XOR<UserTypeCreateWithoutPermissionsInput, UserTypeUncheckedCreateWithoutPermissionsInput>
    connectOrCreate?: UserTypeCreateOrConnectWithoutPermissionsInput
    connect?: UserTypeWhereUniqueInput
  }

  export type UserTypeUpdateOneRequiredWithoutPermissionsNestedInput = {
    create?: XOR<UserTypeCreateWithoutPermissionsInput, UserTypeUncheckedCreateWithoutPermissionsInput>
    connectOrCreate?: UserTypeCreateOrConnectWithoutPermissionsInput
    upsert?: UserTypeUpsertWithoutPermissionsInput
    connect?: UserTypeWhereUniqueInput
    update?: XOR<XOR<UserTypeUpdateToOneWithWhereWithoutPermissionsInput, UserTypeUpdateWithoutPermissionsInput>, UserTypeUncheckedUpdateWithoutPermissionsInput>
  }

  export type ProductCreateNestedOneWithoutCommentsInput = {
    create?: XOR<ProductCreateWithoutCommentsInput, ProductUncheckedCreateWithoutCommentsInput>
    connectOrCreate?: ProductCreateOrConnectWithoutCommentsInput
    connect?: ProductWhereUniqueInput
  }

  export type CustomerCreateNestedOneWithoutCommentsInput = {
    create?: XOR<CustomerCreateWithoutCommentsInput, CustomerUncheckedCreateWithoutCommentsInput>
    connectOrCreate?: CustomerCreateOrConnectWithoutCommentsInput
    connect?: CustomerWhereUniqueInput
  }

  export type CommentCreateNestedOneWithoutRepliesInput = {
    create?: XOR<CommentCreateWithoutRepliesInput, CommentUncheckedCreateWithoutRepliesInput>
    connectOrCreate?: CommentCreateOrConnectWithoutRepliesInput
    connect?: CommentWhereUniqueInput
  }

  export type CommentCreateNestedManyWithoutReplyToInput = {
    create?: XOR<CommentCreateWithoutReplyToInput, CommentUncheckedCreateWithoutReplyToInput> | CommentCreateWithoutReplyToInput[] | CommentUncheckedCreateWithoutReplyToInput[]
    connectOrCreate?: CommentCreateOrConnectWithoutReplyToInput | CommentCreateOrConnectWithoutReplyToInput[]
    createMany?: CommentCreateManyReplyToInputEnvelope
    connect?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
  }

  export type CommentUncheckedCreateNestedManyWithoutReplyToInput = {
    create?: XOR<CommentCreateWithoutReplyToInput, CommentUncheckedCreateWithoutReplyToInput> | CommentCreateWithoutReplyToInput[] | CommentUncheckedCreateWithoutReplyToInput[]
    connectOrCreate?: CommentCreateOrConnectWithoutReplyToInput | CommentCreateOrConnectWithoutReplyToInput[]
    createMany?: CommentCreateManyReplyToInputEnvelope
    connect?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
  }

  export type EnumCommentStatusFieldUpdateOperationsInput = {
    set?: $Enums.CommentStatus
  }

  export type ProductUpdateOneRequiredWithoutCommentsNestedInput = {
    create?: XOR<ProductCreateWithoutCommentsInput, ProductUncheckedCreateWithoutCommentsInput>
    connectOrCreate?: ProductCreateOrConnectWithoutCommentsInput
    upsert?: ProductUpsertWithoutCommentsInput
    connect?: ProductWhereUniqueInput
    update?: XOR<XOR<ProductUpdateToOneWithWhereWithoutCommentsInput, ProductUpdateWithoutCommentsInput>, ProductUncheckedUpdateWithoutCommentsInput>
  }

  export type CustomerUpdateOneRequiredWithoutCommentsNestedInput = {
    create?: XOR<CustomerCreateWithoutCommentsInput, CustomerUncheckedCreateWithoutCommentsInput>
    connectOrCreate?: CustomerCreateOrConnectWithoutCommentsInput
    upsert?: CustomerUpsertWithoutCommentsInput
    connect?: CustomerWhereUniqueInput
    update?: XOR<XOR<CustomerUpdateToOneWithWhereWithoutCommentsInput, CustomerUpdateWithoutCommentsInput>, CustomerUncheckedUpdateWithoutCommentsInput>
  }

  export type CommentUpdateOneWithoutRepliesNestedInput = {
    create?: XOR<CommentCreateWithoutRepliesInput, CommentUncheckedCreateWithoutRepliesInput>
    connectOrCreate?: CommentCreateOrConnectWithoutRepliesInput
    upsert?: CommentUpsertWithoutRepliesInput
    disconnect?: CommentWhereInput | boolean
    delete?: CommentWhereInput | boolean
    connect?: CommentWhereUniqueInput
    update?: XOR<XOR<CommentUpdateToOneWithWhereWithoutRepliesInput, CommentUpdateWithoutRepliesInput>, CommentUncheckedUpdateWithoutRepliesInput>
  }

  export type CommentUpdateManyWithoutReplyToNestedInput = {
    create?: XOR<CommentCreateWithoutReplyToInput, CommentUncheckedCreateWithoutReplyToInput> | CommentCreateWithoutReplyToInput[] | CommentUncheckedCreateWithoutReplyToInput[]
    connectOrCreate?: CommentCreateOrConnectWithoutReplyToInput | CommentCreateOrConnectWithoutReplyToInput[]
    upsert?: CommentUpsertWithWhereUniqueWithoutReplyToInput | CommentUpsertWithWhereUniqueWithoutReplyToInput[]
    createMany?: CommentCreateManyReplyToInputEnvelope
    set?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
    disconnect?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
    delete?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
    connect?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
    update?: CommentUpdateWithWhereUniqueWithoutReplyToInput | CommentUpdateWithWhereUniqueWithoutReplyToInput[]
    updateMany?: CommentUpdateManyWithWhereWithoutReplyToInput | CommentUpdateManyWithWhereWithoutReplyToInput[]
    deleteMany?: CommentScalarWhereInput | CommentScalarWhereInput[]
  }

  export type CommentUncheckedUpdateManyWithoutReplyToNestedInput = {
    create?: XOR<CommentCreateWithoutReplyToInput, CommentUncheckedCreateWithoutReplyToInput> | CommentCreateWithoutReplyToInput[] | CommentUncheckedCreateWithoutReplyToInput[]
    connectOrCreate?: CommentCreateOrConnectWithoutReplyToInput | CommentCreateOrConnectWithoutReplyToInput[]
    upsert?: CommentUpsertWithWhereUniqueWithoutReplyToInput | CommentUpsertWithWhereUniqueWithoutReplyToInput[]
    createMany?: CommentCreateManyReplyToInputEnvelope
    set?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
    disconnect?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
    delete?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
    connect?: CommentWhereUniqueInput | CommentWhereUniqueInput[]
    update?: CommentUpdateWithWhereUniqueWithoutReplyToInput | CommentUpdateWithWhereUniqueWithoutReplyToInput[]
    updateMany?: CommentUpdateManyWithWhereWithoutReplyToInput | CommentUpdateManyWithWhereWithoutReplyToInput[]
    deleteMany?: CommentScalarWhereInput | CommentScalarWhereInput[]
  }

  export type ProductCreateNestedOneWithoutPromotionsInput = {
    create?: XOR<ProductCreateWithoutPromotionsInput, ProductUncheckedCreateWithoutPromotionsInput>
    connectOrCreate?: ProductCreateOrConnectWithoutPromotionsInput
    connect?: ProductWhereUniqueInput
  }

  export type CategoryCreateNestedOneWithoutPromotionsInput = {
    create?: XOR<CategoryCreateWithoutPromotionsInput, CategoryUncheckedCreateWithoutPromotionsInput>
    connectOrCreate?: CategoryCreateOrConnectWithoutPromotionsInput
    connect?: CategoryWhereUniqueInput
  }

  export type CustomerCreateNestedOneWithoutPromotionsInput = {
    create?: XOR<CustomerCreateWithoutPromotionsInput, CustomerUncheckedCreateWithoutPromotionsInput>
    connectOrCreate?: CustomerCreateOrConnectWithoutPromotionsInput
    connect?: CustomerWhereUniqueInput
  }

  export type BrandCreateNestedOneWithoutPromotionsInput = {
    create?: XOR<BrandCreateWithoutPromotionsInput, BrandUncheckedCreateWithoutPromotionsInput>
    connectOrCreate?: BrandCreateOrConnectWithoutPromotionsInput
    connect?: BrandWhereUniqueInput
  }

  export type EnumPromotionScopeFieldUpdateOperationsInput = {
    set?: $Enums.PromotionScope
  }

  export type EnumPromotionUsageFieldUpdateOperationsInput = {
    set?: $Enums.PromotionUsage
  }

  export type ProductUpdateOneWithoutPromotionsNestedInput = {
    create?: XOR<ProductCreateWithoutPromotionsInput, ProductUncheckedCreateWithoutPromotionsInput>
    connectOrCreate?: ProductCreateOrConnectWithoutPromotionsInput
    upsert?: ProductUpsertWithoutPromotionsInput
    disconnect?: ProductWhereInput | boolean
    delete?: ProductWhereInput | boolean
    connect?: ProductWhereUniqueInput
    update?: XOR<XOR<ProductUpdateToOneWithWhereWithoutPromotionsInput, ProductUpdateWithoutPromotionsInput>, ProductUncheckedUpdateWithoutPromotionsInput>
  }

  export type CategoryUpdateOneWithoutPromotionsNestedInput = {
    create?: XOR<CategoryCreateWithoutPromotionsInput, CategoryUncheckedCreateWithoutPromotionsInput>
    connectOrCreate?: CategoryCreateOrConnectWithoutPromotionsInput
    upsert?: CategoryUpsertWithoutPromotionsInput
    disconnect?: CategoryWhereInput | boolean
    delete?: CategoryWhereInput | boolean
    connect?: CategoryWhereUniqueInput
    update?: XOR<XOR<CategoryUpdateToOneWithWhereWithoutPromotionsInput, CategoryUpdateWithoutPromotionsInput>, CategoryUncheckedUpdateWithoutPromotionsInput>
  }

  export type CustomerUpdateOneWithoutPromotionsNestedInput = {
    create?: XOR<CustomerCreateWithoutPromotionsInput, CustomerUncheckedCreateWithoutPromotionsInput>
    connectOrCreate?: CustomerCreateOrConnectWithoutPromotionsInput
    upsert?: CustomerUpsertWithoutPromotionsInput
    disconnect?: CustomerWhereInput | boolean
    delete?: CustomerWhereInput | boolean
    connect?: CustomerWhereUniqueInput
    update?: XOR<XOR<CustomerUpdateToOneWithWhereWithoutPromotionsInput, CustomerUpdateWithoutPromotionsInput>, CustomerUncheckedUpdateWithoutPromotionsInput>
  }

  export type BrandUpdateOneWithoutPromotionsNestedInput = {
    create?: XOR<BrandCreateWithoutPromotionsInput, BrandUncheckedCreateWithoutPromotionsInput>
    connectOrCreate?: BrandCreateOrConnectWithoutPromotionsInput
    upsert?: BrandUpsertWithoutPromotionsInput
    disconnect?: BrandWhereInput | boolean
    delete?: BrandWhereInput | boolean
    connect?: BrandWhereUniqueInput
    update?: XOR<XOR<BrandUpdateToOneWithWhereWithoutPromotionsInput, BrandUpdateWithoutPromotionsInput>, BrandUncheckedUpdateWithoutPromotionsInput>
  }

  export type BranchCreateNestedOneWithoutAllocationsInput = {
    create?: XOR<BranchCreateWithoutAllocationsInput, BranchUncheckedCreateWithoutAllocationsInput>
    connectOrCreate?: BranchCreateOrConnectWithoutAllocationsInput
    connect?: BranchWhereUniqueInput
  }

  export type AdminUserCreateNestedOneWithoutBranchAllocationsInput = {
    create?: XOR<AdminUserCreateWithoutBranchAllocationsInput, AdminUserUncheckedCreateWithoutBranchAllocationsInput>
    connectOrCreate?: AdminUserCreateOrConnectWithoutBranchAllocationsInput
    connect?: AdminUserWhereUniqueInput
  }

  export type BranchAllocationItemCreateNestedManyWithoutAllocationInput = {
    create?: XOR<BranchAllocationItemCreateWithoutAllocationInput, BranchAllocationItemUncheckedCreateWithoutAllocationInput> | BranchAllocationItemCreateWithoutAllocationInput[] | BranchAllocationItemUncheckedCreateWithoutAllocationInput[]
    connectOrCreate?: BranchAllocationItemCreateOrConnectWithoutAllocationInput | BranchAllocationItemCreateOrConnectWithoutAllocationInput[]
    createMany?: BranchAllocationItemCreateManyAllocationInputEnvelope
    connect?: BranchAllocationItemWhereUniqueInput | BranchAllocationItemWhereUniqueInput[]
  }

  export type BranchAllocationItemUncheckedCreateNestedManyWithoutAllocationInput = {
    create?: XOR<BranchAllocationItemCreateWithoutAllocationInput, BranchAllocationItemUncheckedCreateWithoutAllocationInput> | BranchAllocationItemCreateWithoutAllocationInput[] | BranchAllocationItemUncheckedCreateWithoutAllocationInput[]
    connectOrCreate?: BranchAllocationItemCreateOrConnectWithoutAllocationInput | BranchAllocationItemCreateOrConnectWithoutAllocationInput[]
    createMany?: BranchAllocationItemCreateManyAllocationInputEnvelope
    connect?: BranchAllocationItemWhereUniqueInput | BranchAllocationItemWhereUniqueInput[]
  }

  export type BranchUpdateOneRequiredWithoutAllocationsNestedInput = {
    create?: XOR<BranchCreateWithoutAllocationsInput, BranchUncheckedCreateWithoutAllocationsInput>
    connectOrCreate?: BranchCreateOrConnectWithoutAllocationsInput
    upsert?: BranchUpsertWithoutAllocationsInput
    connect?: BranchWhereUniqueInput
    update?: XOR<XOR<BranchUpdateToOneWithWhereWithoutAllocationsInput, BranchUpdateWithoutAllocationsInput>, BranchUncheckedUpdateWithoutAllocationsInput>
  }

  export type AdminUserUpdateOneWithoutBranchAllocationsNestedInput = {
    create?: XOR<AdminUserCreateWithoutBranchAllocationsInput, AdminUserUncheckedCreateWithoutBranchAllocationsInput>
    connectOrCreate?: AdminUserCreateOrConnectWithoutBranchAllocationsInput
    upsert?: AdminUserUpsertWithoutBranchAllocationsInput
    disconnect?: AdminUserWhereInput | boolean
    delete?: AdminUserWhereInput | boolean
    connect?: AdminUserWhereUniqueInput
    update?: XOR<XOR<AdminUserUpdateToOneWithWhereWithoutBranchAllocationsInput, AdminUserUpdateWithoutBranchAllocationsInput>, AdminUserUncheckedUpdateWithoutBranchAllocationsInput>
  }

  export type BranchAllocationItemUpdateManyWithoutAllocationNestedInput = {
    create?: XOR<BranchAllocationItemCreateWithoutAllocationInput, BranchAllocationItemUncheckedCreateWithoutAllocationInput> | BranchAllocationItemCreateWithoutAllocationInput[] | BranchAllocationItemUncheckedCreateWithoutAllocationInput[]
    connectOrCreate?: BranchAllocationItemCreateOrConnectWithoutAllocationInput | BranchAllocationItemCreateOrConnectWithoutAllocationInput[]
    upsert?: BranchAllocationItemUpsertWithWhereUniqueWithoutAllocationInput | BranchAllocationItemUpsertWithWhereUniqueWithoutAllocationInput[]
    createMany?: BranchAllocationItemCreateManyAllocationInputEnvelope
    set?: BranchAllocationItemWhereUniqueInput | BranchAllocationItemWhereUniqueInput[]
    disconnect?: BranchAllocationItemWhereUniqueInput | BranchAllocationItemWhereUniqueInput[]
    delete?: BranchAllocationItemWhereUniqueInput | BranchAllocationItemWhereUniqueInput[]
    connect?: BranchAllocationItemWhereUniqueInput | BranchAllocationItemWhereUniqueInput[]
    update?: BranchAllocationItemUpdateWithWhereUniqueWithoutAllocationInput | BranchAllocationItemUpdateWithWhereUniqueWithoutAllocationInput[]
    updateMany?: BranchAllocationItemUpdateManyWithWhereWithoutAllocationInput | BranchAllocationItemUpdateManyWithWhereWithoutAllocationInput[]
    deleteMany?: BranchAllocationItemScalarWhereInput | BranchAllocationItemScalarWhereInput[]
  }

  export type BranchAllocationItemUncheckedUpdateManyWithoutAllocationNestedInput = {
    create?: XOR<BranchAllocationItemCreateWithoutAllocationInput, BranchAllocationItemUncheckedCreateWithoutAllocationInput> | BranchAllocationItemCreateWithoutAllocationInput[] | BranchAllocationItemUncheckedCreateWithoutAllocationInput[]
    connectOrCreate?: BranchAllocationItemCreateOrConnectWithoutAllocationInput | BranchAllocationItemCreateOrConnectWithoutAllocationInput[]
    upsert?: BranchAllocationItemUpsertWithWhereUniqueWithoutAllocationInput | BranchAllocationItemUpsertWithWhereUniqueWithoutAllocationInput[]
    createMany?: BranchAllocationItemCreateManyAllocationInputEnvelope
    set?: BranchAllocationItemWhereUniqueInput | BranchAllocationItemWhereUniqueInput[]
    disconnect?: BranchAllocationItemWhereUniqueInput | BranchAllocationItemWhereUniqueInput[]
    delete?: BranchAllocationItemWhereUniqueInput | BranchAllocationItemWhereUniqueInput[]
    connect?: BranchAllocationItemWhereUniqueInput | BranchAllocationItemWhereUniqueInput[]
    update?: BranchAllocationItemUpdateWithWhereUniqueWithoutAllocationInput | BranchAllocationItemUpdateWithWhereUniqueWithoutAllocationInput[]
    updateMany?: BranchAllocationItemUpdateManyWithWhereWithoutAllocationInput | BranchAllocationItemUpdateManyWithWhereWithoutAllocationInput[]
    deleteMany?: BranchAllocationItemScalarWhereInput | BranchAllocationItemScalarWhereInput[]
  }

  export type BranchAllocationCreateNestedOneWithoutItemsInput = {
    create?: XOR<BranchAllocationCreateWithoutItemsInput, BranchAllocationUncheckedCreateWithoutItemsInput>
    connectOrCreate?: BranchAllocationCreateOrConnectWithoutItemsInput
    connect?: BranchAllocationWhereUniqueInput
  }

  export type ProductCreateNestedOneWithoutAllocationItemsInput = {
    create?: XOR<ProductCreateWithoutAllocationItemsInput, ProductUncheckedCreateWithoutAllocationItemsInput>
    connectOrCreate?: ProductCreateOrConnectWithoutAllocationItemsInput
    connect?: ProductWhereUniqueInput
  }

  export type BranchAllocationUpdateOneRequiredWithoutItemsNestedInput = {
    create?: XOR<BranchAllocationCreateWithoutItemsInput, BranchAllocationUncheckedCreateWithoutItemsInput>
    connectOrCreate?: BranchAllocationCreateOrConnectWithoutItemsInput
    upsert?: BranchAllocationUpsertWithoutItemsInput
    connect?: BranchAllocationWhereUniqueInput
    update?: XOR<XOR<BranchAllocationUpdateToOneWithWhereWithoutItemsInput, BranchAllocationUpdateWithoutItemsInput>, BranchAllocationUncheckedUpdateWithoutItemsInput>
  }

  export type ProductUpdateOneRequiredWithoutAllocationItemsNestedInput = {
    create?: XOR<ProductCreateWithoutAllocationItemsInput, ProductUncheckedCreateWithoutAllocationItemsInput>
    connectOrCreate?: ProductCreateOrConnectWithoutAllocationItemsInput
    upsert?: ProductUpsertWithoutAllocationItemsInput
    connect?: ProductWhereUniqueInput
    update?: XOR<XOR<ProductUpdateToOneWithWhereWithoutAllocationItemsInput, ProductUpdateWithoutAllocationItemsInput>, ProductUncheckedUpdateWithoutAllocationItemsInput>
  }

  export type AdminUserCreateNestedOneWithoutSentSmsMessagesInput = {
    create?: XOR<AdminUserCreateWithoutSentSmsMessagesInput, AdminUserUncheckedCreateWithoutSentSmsMessagesInput>
    connectOrCreate?: AdminUserCreateOrConnectWithoutSentSmsMessagesInput
    connect?: AdminUserWhereUniqueInput
  }

  export type EnumMessageAudienceFieldUpdateOperationsInput = {
    set?: $Enums.MessageAudience
  }

  export type AdminUserUpdateOneWithoutSentSmsMessagesNestedInput = {
    create?: XOR<AdminUserCreateWithoutSentSmsMessagesInput, AdminUserUncheckedCreateWithoutSentSmsMessagesInput>
    connectOrCreate?: AdminUserCreateOrConnectWithoutSentSmsMessagesInput
    upsert?: AdminUserUpsertWithoutSentSmsMessagesInput
    disconnect?: AdminUserWhereInput | boolean
    delete?: AdminUserWhereInput | boolean
    connect?: AdminUserWhereUniqueInput
    update?: XOR<XOR<AdminUserUpdateToOneWithWhereWithoutSentSmsMessagesInput, AdminUserUpdateWithoutSentSmsMessagesInput>, AdminUserUncheckedUpdateWithoutSentSmsMessagesInput>
  }

  export type AdminUserCreateNestedOneWithoutSentNotificationsInput = {
    create?: XOR<AdminUserCreateWithoutSentNotificationsInput, AdminUserUncheckedCreateWithoutSentNotificationsInput>
    connectOrCreate?: AdminUserCreateOrConnectWithoutSentNotificationsInput
    connect?: AdminUserWhereUniqueInput
  }

  export type NotificationRecipientCreateNestedManyWithoutNotificationInput = {
    create?: XOR<NotificationRecipientCreateWithoutNotificationInput, NotificationRecipientUncheckedCreateWithoutNotificationInput> | NotificationRecipientCreateWithoutNotificationInput[] | NotificationRecipientUncheckedCreateWithoutNotificationInput[]
    connectOrCreate?: NotificationRecipientCreateOrConnectWithoutNotificationInput | NotificationRecipientCreateOrConnectWithoutNotificationInput[]
    createMany?: NotificationRecipientCreateManyNotificationInputEnvelope
    connect?: NotificationRecipientWhereUniqueInput | NotificationRecipientWhereUniqueInput[]
  }

  export type NotificationRecipientUncheckedCreateNestedManyWithoutNotificationInput = {
    create?: XOR<NotificationRecipientCreateWithoutNotificationInput, NotificationRecipientUncheckedCreateWithoutNotificationInput> | NotificationRecipientCreateWithoutNotificationInput[] | NotificationRecipientUncheckedCreateWithoutNotificationInput[]
    connectOrCreate?: NotificationRecipientCreateOrConnectWithoutNotificationInput | NotificationRecipientCreateOrConnectWithoutNotificationInput[]
    createMany?: NotificationRecipientCreateManyNotificationInputEnvelope
    connect?: NotificationRecipientWhereUniqueInput | NotificationRecipientWhereUniqueInput[]
  }

  export type AdminUserUpdateOneWithoutSentNotificationsNestedInput = {
    create?: XOR<AdminUserCreateWithoutSentNotificationsInput, AdminUserUncheckedCreateWithoutSentNotificationsInput>
    connectOrCreate?: AdminUserCreateOrConnectWithoutSentNotificationsInput
    upsert?: AdminUserUpsertWithoutSentNotificationsInput
    disconnect?: AdminUserWhereInput | boolean
    delete?: AdminUserWhereInput | boolean
    connect?: AdminUserWhereUniqueInput
    update?: XOR<XOR<AdminUserUpdateToOneWithWhereWithoutSentNotificationsInput, AdminUserUpdateWithoutSentNotificationsInput>, AdminUserUncheckedUpdateWithoutSentNotificationsInput>
  }

  export type NotificationRecipientUpdateManyWithoutNotificationNestedInput = {
    create?: XOR<NotificationRecipientCreateWithoutNotificationInput, NotificationRecipientUncheckedCreateWithoutNotificationInput> | NotificationRecipientCreateWithoutNotificationInput[] | NotificationRecipientUncheckedCreateWithoutNotificationInput[]
    connectOrCreate?: NotificationRecipientCreateOrConnectWithoutNotificationInput | NotificationRecipientCreateOrConnectWithoutNotificationInput[]
    upsert?: NotificationRecipientUpsertWithWhereUniqueWithoutNotificationInput | NotificationRecipientUpsertWithWhereUniqueWithoutNotificationInput[]
    createMany?: NotificationRecipientCreateManyNotificationInputEnvelope
    set?: NotificationRecipientWhereUniqueInput | NotificationRecipientWhereUniqueInput[]
    disconnect?: NotificationRecipientWhereUniqueInput | NotificationRecipientWhereUniqueInput[]
    delete?: NotificationRecipientWhereUniqueInput | NotificationRecipientWhereUniqueInput[]
    connect?: NotificationRecipientWhereUniqueInput | NotificationRecipientWhereUniqueInput[]
    update?: NotificationRecipientUpdateWithWhereUniqueWithoutNotificationInput | NotificationRecipientUpdateWithWhereUniqueWithoutNotificationInput[]
    updateMany?: NotificationRecipientUpdateManyWithWhereWithoutNotificationInput | NotificationRecipientUpdateManyWithWhereWithoutNotificationInput[]
    deleteMany?: NotificationRecipientScalarWhereInput | NotificationRecipientScalarWhereInput[]
  }

  export type NotificationRecipientUncheckedUpdateManyWithoutNotificationNestedInput = {
    create?: XOR<NotificationRecipientCreateWithoutNotificationInput, NotificationRecipientUncheckedCreateWithoutNotificationInput> | NotificationRecipientCreateWithoutNotificationInput[] | NotificationRecipientUncheckedCreateWithoutNotificationInput[]
    connectOrCreate?: NotificationRecipientCreateOrConnectWithoutNotificationInput | NotificationRecipientCreateOrConnectWithoutNotificationInput[]
    upsert?: NotificationRecipientUpsertWithWhereUniqueWithoutNotificationInput | NotificationRecipientUpsertWithWhereUniqueWithoutNotificationInput[]
    createMany?: NotificationRecipientCreateManyNotificationInputEnvelope
    set?: NotificationRecipientWhereUniqueInput | NotificationRecipientWhereUniqueInput[]
    disconnect?: NotificationRecipientWhereUniqueInput | NotificationRecipientWhereUniqueInput[]
    delete?: NotificationRecipientWhereUniqueInput | NotificationRecipientWhereUniqueInput[]
    connect?: NotificationRecipientWhereUniqueInput | NotificationRecipientWhereUniqueInput[]
    update?: NotificationRecipientUpdateWithWhereUniqueWithoutNotificationInput | NotificationRecipientUpdateWithWhereUniqueWithoutNotificationInput[]
    updateMany?: NotificationRecipientUpdateManyWithWhereWithoutNotificationInput | NotificationRecipientUpdateManyWithWhereWithoutNotificationInput[]
    deleteMany?: NotificationRecipientScalarWhereInput | NotificationRecipientScalarWhereInput[]
  }

  export type NotificationCreateNestedOneWithoutRecipientsInput = {
    create?: XOR<NotificationCreateWithoutRecipientsInput, NotificationUncheckedCreateWithoutRecipientsInput>
    connectOrCreate?: NotificationCreateOrConnectWithoutRecipientsInput
    connect?: NotificationWhereUniqueInput
  }

  export type CustomerCreateNestedOneWithoutNotificationsInput = {
    create?: XOR<CustomerCreateWithoutNotificationsInput, CustomerUncheckedCreateWithoutNotificationsInput>
    connectOrCreate?: CustomerCreateOrConnectWithoutNotificationsInput
    connect?: CustomerWhereUniqueInput
  }

  export type NotificationUpdateOneRequiredWithoutRecipientsNestedInput = {
    create?: XOR<NotificationCreateWithoutRecipientsInput, NotificationUncheckedCreateWithoutRecipientsInput>
    connectOrCreate?: NotificationCreateOrConnectWithoutRecipientsInput
    upsert?: NotificationUpsertWithoutRecipientsInput
    connect?: NotificationWhereUniqueInput
    update?: XOR<XOR<NotificationUpdateToOneWithWhereWithoutRecipientsInput, NotificationUpdateWithoutRecipientsInput>, NotificationUncheckedUpdateWithoutRecipientsInput>
  }

  export type CustomerUpdateOneRequiredWithoutNotificationsNestedInput = {
    create?: XOR<CustomerCreateWithoutNotificationsInput, CustomerUncheckedCreateWithoutNotificationsInput>
    connectOrCreate?: CustomerCreateOrConnectWithoutNotificationsInput
    upsert?: CustomerUpsertWithoutNotificationsInput
    connect?: CustomerWhereUniqueInput
    update?: XOR<XOR<CustomerUpdateToOneWithWhereWithoutNotificationsInput, CustomerUpdateWithoutNotificationsInput>, CustomerUncheckedUpdateWithoutNotificationsInput>
  }

  export type CustomerCreateNestedOneWithoutActivityLogsInput = {
    create?: XOR<CustomerCreateWithoutActivityLogsInput, CustomerUncheckedCreateWithoutActivityLogsInput>
    connectOrCreate?: CustomerCreateOrConnectWithoutActivityLogsInput
    connect?: CustomerWhereUniqueInput
  }

  export type CustomerUpdateOneRequiredWithoutActivityLogsNestedInput = {
    create?: XOR<CustomerCreateWithoutActivityLogsInput, CustomerUncheckedCreateWithoutActivityLogsInput>
    connectOrCreate?: CustomerCreateOrConnectWithoutActivityLogsInput
    upsert?: CustomerUpsertWithoutActivityLogsInput
    connect?: CustomerWhereUniqueInput
    update?: XOR<XOR<CustomerUpdateToOneWithWhereWithoutActivityLogsInput, CustomerUpdateWithoutActivityLogsInput>, CustomerUncheckedUpdateWithoutActivityLogsInput>
  }

  export type AdminUserCreateNestedOneWithoutUploadedFilesInput = {
    create?: XOR<AdminUserCreateWithoutUploadedFilesInput, AdminUserUncheckedCreateWithoutUploadedFilesInput>
    connectOrCreate?: AdminUserCreateOrConnectWithoutUploadedFilesInput
    connect?: AdminUserWhereUniqueInput
  }

  export type CustomerCreateNestedManyWithoutAvatarFileInput = {
    create?: XOR<CustomerCreateWithoutAvatarFileInput, CustomerUncheckedCreateWithoutAvatarFileInput> | CustomerCreateWithoutAvatarFileInput[] | CustomerUncheckedCreateWithoutAvatarFileInput[]
    connectOrCreate?: CustomerCreateOrConnectWithoutAvatarFileInput | CustomerCreateOrConnectWithoutAvatarFileInput[]
    createMany?: CustomerCreateManyAvatarFileInputEnvelope
    connect?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
  }

  export type AdminUserCreateNestedManyWithoutAvatarFileInput = {
    create?: XOR<AdminUserCreateWithoutAvatarFileInput, AdminUserUncheckedCreateWithoutAvatarFileInput> | AdminUserCreateWithoutAvatarFileInput[] | AdminUserUncheckedCreateWithoutAvatarFileInput[]
    connectOrCreate?: AdminUserCreateOrConnectWithoutAvatarFileInput | AdminUserCreateOrConnectWithoutAvatarFileInput[]
    createMany?: AdminUserCreateManyAvatarFileInputEnvelope
    connect?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
  }

  export type CustomerUncheckedCreateNestedManyWithoutAvatarFileInput = {
    create?: XOR<CustomerCreateWithoutAvatarFileInput, CustomerUncheckedCreateWithoutAvatarFileInput> | CustomerCreateWithoutAvatarFileInput[] | CustomerUncheckedCreateWithoutAvatarFileInput[]
    connectOrCreate?: CustomerCreateOrConnectWithoutAvatarFileInput | CustomerCreateOrConnectWithoutAvatarFileInput[]
    createMany?: CustomerCreateManyAvatarFileInputEnvelope
    connect?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
  }

  export type AdminUserUncheckedCreateNestedManyWithoutAvatarFileInput = {
    create?: XOR<AdminUserCreateWithoutAvatarFileInput, AdminUserUncheckedCreateWithoutAvatarFileInput> | AdminUserCreateWithoutAvatarFileInput[] | AdminUserUncheckedCreateWithoutAvatarFileInput[]
    connectOrCreate?: AdminUserCreateOrConnectWithoutAvatarFileInput | AdminUserCreateOrConnectWithoutAvatarFileInput[]
    createMany?: AdminUserCreateManyAvatarFileInputEnvelope
    connect?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
  }

  export type AdminUserUpdateOneWithoutUploadedFilesNestedInput = {
    create?: XOR<AdminUserCreateWithoutUploadedFilesInput, AdminUserUncheckedCreateWithoutUploadedFilesInput>
    connectOrCreate?: AdminUserCreateOrConnectWithoutUploadedFilesInput
    upsert?: AdminUserUpsertWithoutUploadedFilesInput
    disconnect?: AdminUserWhereInput | boolean
    delete?: AdminUserWhereInput | boolean
    connect?: AdminUserWhereUniqueInput
    update?: XOR<XOR<AdminUserUpdateToOneWithWhereWithoutUploadedFilesInput, AdminUserUpdateWithoutUploadedFilesInput>, AdminUserUncheckedUpdateWithoutUploadedFilesInput>
  }

  export type CustomerUpdateManyWithoutAvatarFileNestedInput = {
    create?: XOR<CustomerCreateWithoutAvatarFileInput, CustomerUncheckedCreateWithoutAvatarFileInput> | CustomerCreateWithoutAvatarFileInput[] | CustomerUncheckedCreateWithoutAvatarFileInput[]
    connectOrCreate?: CustomerCreateOrConnectWithoutAvatarFileInput | CustomerCreateOrConnectWithoutAvatarFileInput[]
    upsert?: CustomerUpsertWithWhereUniqueWithoutAvatarFileInput | CustomerUpsertWithWhereUniqueWithoutAvatarFileInput[]
    createMany?: CustomerCreateManyAvatarFileInputEnvelope
    set?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
    disconnect?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
    delete?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
    connect?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
    update?: CustomerUpdateWithWhereUniqueWithoutAvatarFileInput | CustomerUpdateWithWhereUniqueWithoutAvatarFileInput[]
    updateMany?: CustomerUpdateManyWithWhereWithoutAvatarFileInput | CustomerUpdateManyWithWhereWithoutAvatarFileInput[]
    deleteMany?: CustomerScalarWhereInput | CustomerScalarWhereInput[]
  }

  export type AdminUserUpdateManyWithoutAvatarFileNestedInput = {
    create?: XOR<AdminUserCreateWithoutAvatarFileInput, AdminUserUncheckedCreateWithoutAvatarFileInput> | AdminUserCreateWithoutAvatarFileInput[] | AdminUserUncheckedCreateWithoutAvatarFileInput[]
    connectOrCreate?: AdminUserCreateOrConnectWithoutAvatarFileInput | AdminUserCreateOrConnectWithoutAvatarFileInput[]
    upsert?: AdminUserUpsertWithWhereUniqueWithoutAvatarFileInput | AdminUserUpsertWithWhereUniqueWithoutAvatarFileInput[]
    createMany?: AdminUserCreateManyAvatarFileInputEnvelope
    set?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
    disconnect?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
    delete?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
    connect?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
    update?: AdminUserUpdateWithWhereUniqueWithoutAvatarFileInput | AdminUserUpdateWithWhereUniqueWithoutAvatarFileInput[]
    updateMany?: AdminUserUpdateManyWithWhereWithoutAvatarFileInput | AdminUserUpdateManyWithWhereWithoutAvatarFileInput[]
    deleteMany?: AdminUserScalarWhereInput | AdminUserScalarWhereInput[]
  }

  export type CustomerUncheckedUpdateManyWithoutAvatarFileNestedInput = {
    create?: XOR<CustomerCreateWithoutAvatarFileInput, CustomerUncheckedCreateWithoutAvatarFileInput> | CustomerCreateWithoutAvatarFileInput[] | CustomerUncheckedCreateWithoutAvatarFileInput[]
    connectOrCreate?: CustomerCreateOrConnectWithoutAvatarFileInput | CustomerCreateOrConnectWithoutAvatarFileInput[]
    upsert?: CustomerUpsertWithWhereUniqueWithoutAvatarFileInput | CustomerUpsertWithWhereUniqueWithoutAvatarFileInput[]
    createMany?: CustomerCreateManyAvatarFileInputEnvelope
    set?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
    disconnect?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
    delete?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
    connect?: CustomerWhereUniqueInput | CustomerWhereUniqueInput[]
    update?: CustomerUpdateWithWhereUniqueWithoutAvatarFileInput | CustomerUpdateWithWhereUniqueWithoutAvatarFileInput[]
    updateMany?: CustomerUpdateManyWithWhereWithoutAvatarFileInput | CustomerUpdateManyWithWhereWithoutAvatarFileInput[]
    deleteMany?: CustomerScalarWhereInput | CustomerScalarWhereInput[]
  }

  export type AdminUserUncheckedUpdateManyWithoutAvatarFileNestedInput = {
    create?: XOR<AdminUserCreateWithoutAvatarFileInput, AdminUserUncheckedCreateWithoutAvatarFileInput> | AdminUserCreateWithoutAvatarFileInput[] | AdminUserUncheckedCreateWithoutAvatarFileInput[]
    connectOrCreate?: AdminUserCreateOrConnectWithoutAvatarFileInput | AdminUserCreateOrConnectWithoutAvatarFileInput[]
    upsert?: AdminUserUpsertWithWhereUniqueWithoutAvatarFileInput | AdminUserUpsertWithWhereUniqueWithoutAvatarFileInput[]
    createMany?: AdminUserCreateManyAvatarFileInputEnvelope
    set?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
    disconnect?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
    delete?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
    connect?: AdminUserWhereUniqueInput | AdminUserWhereUniqueInput[]
    update?: AdminUserUpdateWithWhereUniqueWithoutAvatarFileInput | AdminUserUpdateWithWhereUniqueWithoutAvatarFileInput[]
    updateMany?: AdminUserUpdateManyWithWhereWithoutAvatarFileInput | AdminUserUpdateManyWithWhereWithoutAvatarFileInput[]
    deleteMany?: AdminUserScalarWhereInput | AdminUserScalarWhereInput[]
  }

  export type CustomerCreateNestedOneWithoutOtpChallengesInput = {
    create?: XOR<CustomerCreateWithoutOtpChallengesInput, CustomerUncheckedCreateWithoutOtpChallengesInput>
    connectOrCreate?: CustomerCreateOrConnectWithoutOtpChallengesInput
    connect?: CustomerWhereUniqueInput
  }

  export type CustomerUpdateOneRequiredWithoutOtpChallengesNestedInput = {
    create?: XOR<CustomerCreateWithoutOtpChallengesInput, CustomerUncheckedCreateWithoutOtpChallengesInput>
    connectOrCreate?: CustomerCreateOrConnectWithoutOtpChallengesInput
    upsert?: CustomerUpsertWithoutOtpChallengesInput
    connect?: CustomerWhereUniqueInput
    update?: XOR<XOR<CustomerUpdateToOneWithWhereWithoutOtpChallengesInput, CustomerUpdateWithoutOtpChallengesInput>, CustomerUncheckedUpdateWithoutOtpChallengesInput>
  }

  export type NestedStringFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[] | ListStringFieldRefInput<$PrismaModel>
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringFilter<$PrismaModel> | string
  }

  export type NestedStringNullableFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringNullableFilter<$PrismaModel> | string | null
  }

  export type NestedDecimalNullableFilter<$PrismaModel = never> = {
    equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel> | null
    in?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel> | null
    notIn?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel> | null
    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?: NestedDecimalNullableFilter<$PrismaModel> | Decimal | DecimalJsLike | number | string | null
  }

  export type NestedStringWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel>
    in?: string[] | ListStringFieldRefInput<$PrismaModel>
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel>
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringWithAggregatesFilter<$PrismaModel> | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedStringFilter<$PrismaModel>
    _max?: NestedStringFilter<$PrismaModel>
  }

  export type NestedIntFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[] | ListIntFieldRefInput<$PrismaModel>
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel>
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntFilter<$PrismaModel> | number
  }

  export type NestedStringNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: string | StringFieldRefInput<$PrismaModel> | null
    in?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    notIn?: string[] | ListStringFieldRefInput<$PrismaModel> | null
    lt?: string | StringFieldRefInput<$PrismaModel>
    lte?: string | StringFieldRefInput<$PrismaModel>
    gt?: string | StringFieldRefInput<$PrismaModel>
    gte?: string | StringFieldRefInput<$PrismaModel>
    contains?: string | StringFieldRefInput<$PrismaModel>
    startsWith?: string | StringFieldRefInput<$PrismaModel>
    endsWith?: string | StringFieldRefInput<$PrismaModel>
    not?: NestedStringNullableWithAggregatesFilter<$PrismaModel> | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedStringNullableFilter<$PrismaModel>
    _max?: NestedStringNullableFilter<$PrismaModel>
  }

  export type NestedIntNullableFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableFilter<$PrismaModel> | number | null
  }

  export type NestedDecimalNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel> | null
    in?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel> | null
    notIn?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel> | null
    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?: NestedDecimalNullableWithAggregatesFilter<$PrismaModel> | Decimal | DecimalJsLike | number | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedDecimalNullableFilter<$PrismaModel>
    _sum?: NestedDecimalNullableFilter<$PrismaModel>
    _min?: NestedDecimalNullableFilter<$PrismaModel>
    _max?: NestedDecimalNullableFilter<$PrismaModel>
  }

  export type NestedEnumAdminRoleFilter<$PrismaModel = never> = {
    equals?: $Enums.AdminRole | EnumAdminRoleFieldRefInput<$PrismaModel>
    in?: $Enums.AdminRole[] | ListEnumAdminRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.AdminRole[] | ListEnumAdminRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumAdminRoleFilter<$PrismaModel> | $Enums.AdminRole
  }

  export type NestedBoolFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolFilter<$PrismaModel> | boolean
  }

  export type NestedDateTimeFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeFilter<$PrismaModel> | Date | string
  }

  export type NestedEnumAdminRoleWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.AdminRole | EnumAdminRoleFieldRefInput<$PrismaModel>
    in?: $Enums.AdminRole[] | ListEnumAdminRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.AdminRole[] | ListEnumAdminRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumAdminRoleWithAggregatesFilter<$PrismaModel> | $Enums.AdminRole
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumAdminRoleFilter<$PrismaModel>
    _max?: NestedEnumAdminRoleFilter<$PrismaModel>
  }

  export type NestedIntNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel> | null
    in?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel> | null
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntNullableWithAggregatesFilter<$PrismaModel> | number | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _avg?: NestedFloatNullableFilter<$PrismaModel>
    _sum?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedIntNullableFilter<$PrismaModel>
    _max?: NestedIntNullableFilter<$PrismaModel>
  }

  export type NestedFloatNullableFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel> | null
    in?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel> | null
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatNullableFilter<$PrismaModel> | number | null
  }

  export type NestedBoolWithAggregatesFilter<$PrismaModel = never> = {
    equals?: boolean | BooleanFieldRefInput<$PrismaModel>
    not?: NestedBoolWithAggregatesFilter<$PrismaModel> | boolean
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedBoolFilter<$PrismaModel>
    _max?: NestedBoolFilter<$PrismaModel>
  }

  export type NestedDateTimeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel>
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedDateTimeFilter<$PrismaModel>
    _max?: NestedDateTimeFilter<$PrismaModel>
  }

  export type NestedDateTimeNullableFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeNullableFilter<$PrismaModel> | Date | string | null
  }

  export type NestedDateTimeNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> | null
    in?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    notIn?: Date[] | string[] | ListDateTimeFieldRefInput<$PrismaModel> | null
    lt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    lte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gt?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    gte?: Date | string | DateTimeFieldRefInput<$PrismaModel>
    not?: NestedDateTimeNullableWithAggregatesFilter<$PrismaModel> | Date | string | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedDateTimeNullableFilter<$PrismaModel>
    _max?: NestedDateTimeNullableFilter<$PrismaModel>
  }

  export type NestedDecimalFilter<$PrismaModel = never> = {
    equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    in?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel>
    notIn?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel>
    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 NestedDecimalWithAggregatesFilter<$PrismaModel = never> = {
    equals?: Decimal | DecimalJsLike | number | string | DecimalFieldRefInput<$PrismaModel>
    in?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel>
    notIn?: Decimal[] | DecimalJsLike[] | number[] | string[] | ListDecimalFieldRefInput<$PrismaModel>
    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 NestedEnumCustomerKindFilter<$PrismaModel = never> = {
    equals?: $Enums.CustomerKind | EnumCustomerKindFieldRefInput<$PrismaModel>
    in?: $Enums.CustomerKind[] | ListEnumCustomerKindFieldRefInput<$PrismaModel>
    notIn?: $Enums.CustomerKind[] | ListEnumCustomerKindFieldRefInput<$PrismaModel>
    not?: NestedEnumCustomerKindFilter<$PrismaModel> | $Enums.CustomerKind
  }

  export type NestedEnumVerificationStepFilter<$PrismaModel = never> = {
    equals?: $Enums.VerificationStep | EnumVerificationStepFieldRefInput<$PrismaModel>
    in?: $Enums.VerificationStep[] | ListEnumVerificationStepFieldRefInput<$PrismaModel>
    notIn?: $Enums.VerificationStep[] | ListEnumVerificationStepFieldRefInput<$PrismaModel>
    not?: NestedEnumVerificationStepFilter<$PrismaModel> | $Enums.VerificationStep
  }

  export type NestedEnumCustomerKindWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.CustomerKind | EnumCustomerKindFieldRefInput<$PrismaModel>
    in?: $Enums.CustomerKind[] | ListEnumCustomerKindFieldRefInput<$PrismaModel>
    notIn?: $Enums.CustomerKind[] | ListEnumCustomerKindFieldRefInput<$PrismaModel>
    not?: NestedEnumCustomerKindWithAggregatesFilter<$PrismaModel> | $Enums.CustomerKind
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumCustomerKindFilter<$PrismaModel>
    _max?: NestedEnumCustomerKindFilter<$PrismaModel>
  }

  export type NestedEnumVerificationStepWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.VerificationStep | EnumVerificationStepFieldRefInput<$PrismaModel>
    in?: $Enums.VerificationStep[] | ListEnumVerificationStepFieldRefInput<$PrismaModel>
    notIn?: $Enums.VerificationStep[] | ListEnumVerificationStepFieldRefInput<$PrismaModel>
    not?: NestedEnumVerificationStepWithAggregatesFilter<$PrismaModel> | $Enums.VerificationStep
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumVerificationStepFilter<$PrismaModel>
    _max?: NestedEnumVerificationStepFilter<$PrismaModel>
  }

  export type NestedIntWithAggregatesFilter<$PrismaModel = never> = {
    equals?: number | IntFieldRefInput<$PrismaModel>
    in?: number[] | ListIntFieldRefInput<$PrismaModel>
    notIn?: number[] | ListIntFieldRefInput<$PrismaModel>
    lt?: number | IntFieldRefInput<$PrismaModel>
    lte?: number | IntFieldRefInput<$PrismaModel>
    gt?: number | IntFieldRefInput<$PrismaModel>
    gte?: number | IntFieldRefInput<$PrismaModel>
    not?: NestedIntWithAggregatesFilter<$PrismaModel> | number
    _count?: NestedIntFilter<$PrismaModel>
    _avg?: NestedFloatFilter<$PrismaModel>
    _sum?: NestedIntFilter<$PrismaModel>
    _min?: NestedIntFilter<$PrismaModel>
    _max?: NestedIntFilter<$PrismaModel>
  }

  export type NestedFloatFilter<$PrismaModel = never> = {
    equals?: number | FloatFieldRefInput<$PrismaModel>
    in?: number[] | ListFloatFieldRefInput<$PrismaModel>
    notIn?: number[] | ListFloatFieldRefInput<$PrismaModel>
    lt?: number | FloatFieldRefInput<$PrismaModel>
    lte?: number | FloatFieldRefInput<$PrismaModel>
    gt?: number | FloatFieldRefInput<$PrismaModel>
    gte?: number | FloatFieldRefInput<$PrismaModel>
    not?: NestedFloatFilter<$PrismaModel> | number
  }

  export type NestedEnumProductImageRoleFilter<$PrismaModel = never> = {
    equals?: $Enums.ProductImageRole | EnumProductImageRoleFieldRefInput<$PrismaModel>
    in?: $Enums.ProductImageRole[] | ListEnumProductImageRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.ProductImageRole[] | ListEnumProductImageRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumProductImageRoleFilter<$PrismaModel> | $Enums.ProductImageRole
  }

  export type NestedEnumProductImageRoleWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.ProductImageRole | EnumProductImageRoleFieldRefInput<$PrismaModel>
    in?: $Enums.ProductImageRole[] | ListEnumProductImageRoleFieldRefInput<$PrismaModel>
    notIn?: $Enums.ProductImageRole[] | ListEnumProductImageRoleFieldRefInput<$PrismaModel>
    not?: NestedEnumProductImageRoleWithAggregatesFilter<$PrismaModel> | $Enums.ProductImageRole
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumProductImageRoleFilter<$PrismaModel>
    _max?: NestedEnumProductImageRoleFilter<$PrismaModel>
  }

  export type NestedEnumOrderChannelFilter<$PrismaModel = never> = {
    equals?: $Enums.OrderChannel | EnumOrderChannelFieldRefInput<$PrismaModel>
    in?: $Enums.OrderChannel[] | ListEnumOrderChannelFieldRefInput<$PrismaModel>
    notIn?: $Enums.OrderChannel[] | ListEnumOrderChannelFieldRefInput<$PrismaModel>
    not?: NestedEnumOrderChannelFilter<$PrismaModel> | $Enums.OrderChannel
  }

  export type NestedEnumOrderStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.OrderStatus | EnumOrderStatusFieldRefInput<$PrismaModel>
    in?: $Enums.OrderStatus[] | ListEnumOrderStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.OrderStatus[] | ListEnumOrderStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumOrderStatusFilter<$PrismaModel> | $Enums.OrderStatus
  }

  export type NestedEnumOrderChannelWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.OrderChannel | EnumOrderChannelFieldRefInput<$PrismaModel>
    in?: $Enums.OrderChannel[] | ListEnumOrderChannelFieldRefInput<$PrismaModel>
    notIn?: $Enums.OrderChannel[] | ListEnumOrderChannelFieldRefInput<$PrismaModel>
    not?: NestedEnumOrderChannelWithAggregatesFilter<$PrismaModel> | $Enums.OrderChannel
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumOrderChannelFilter<$PrismaModel>
    _max?: NestedEnumOrderChannelFilter<$PrismaModel>
  }

  export type NestedEnumOrderStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.OrderStatus | EnumOrderStatusFieldRefInput<$PrismaModel>
    in?: $Enums.OrderStatus[] | ListEnumOrderStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.OrderStatus[] | ListEnumOrderStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumOrderStatusWithAggregatesFilter<$PrismaModel> | $Enums.OrderStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumOrderStatusFilter<$PrismaModel>
    _max?: NestedEnumOrderStatusFilter<$PrismaModel>
  }

  export type NestedEnumOrderStatusNullableFilter<$PrismaModel = never> = {
    equals?: $Enums.OrderStatus | EnumOrderStatusFieldRefInput<$PrismaModel> | null
    in?: $Enums.OrderStatus[] | ListEnumOrderStatusFieldRefInput<$PrismaModel> | null
    notIn?: $Enums.OrderStatus[] | ListEnumOrderStatusFieldRefInput<$PrismaModel> | null
    not?: NestedEnumOrderStatusNullableFilter<$PrismaModel> | $Enums.OrderStatus | null
  }

  export type NestedEnumOrderStatusNullableWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.OrderStatus | EnumOrderStatusFieldRefInput<$PrismaModel> | null
    in?: $Enums.OrderStatus[] | ListEnumOrderStatusFieldRefInput<$PrismaModel> | null
    notIn?: $Enums.OrderStatus[] | ListEnumOrderStatusFieldRefInput<$PrismaModel> | null
    not?: NestedEnumOrderStatusNullableWithAggregatesFilter<$PrismaModel> | $Enums.OrderStatus | null
    _count?: NestedIntNullableFilter<$PrismaModel>
    _min?: NestedEnumOrderStatusNullableFilter<$PrismaModel>
    _max?: NestedEnumOrderStatusNullableFilter<$PrismaModel>
  }

  export type NestedEnumPreOrderStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.PreOrderStatus | EnumPreOrderStatusFieldRefInput<$PrismaModel>
    in?: $Enums.PreOrderStatus[] | ListEnumPreOrderStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.PreOrderStatus[] | ListEnumPreOrderStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumPreOrderStatusFilter<$PrismaModel> | $Enums.PreOrderStatus
  }

  export type NestedEnumPreOrderStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.PreOrderStatus | EnumPreOrderStatusFieldRefInput<$PrismaModel>
    in?: $Enums.PreOrderStatus[] | ListEnumPreOrderStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.PreOrderStatus[] | ListEnumPreOrderStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumPreOrderStatusWithAggregatesFilter<$PrismaModel> | $Enums.PreOrderStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumPreOrderStatusFilter<$PrismaModel>
    _max?: NestedEnumPreOrderStatusFilter<$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 | JsonFieldRefInput<$PrismaModel>
    lte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gt?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    gte?: InputJsonValue | JsonFieldRefInput<$PrismaModel>
    not?: InputJsonValue | JsonFieldRefInput<$PrismaModel> | JsonNullValueFilter
  }

  export type NestedEnumLedgerCurrencyFilter<$PrismaModel = never> = {
    equals?: $Enums.LedgerCurrency | EnumLedgerCurrencyFieldRefInput<$PrismaModel>
    in?: $Enums.LedgerCurrency[] | ListEnumLedgerCurrencyFieldRefInput<$PrismaModel>
    notIn?: $Enums.LedgerCurrency[] | ListEnumLedgerCurrencyFieldRefInput<$PrismaModel>
    not?: NestedEnumLedgerCurrencyFilter<$PrismaModel> | $Enums.LedgerCurrency
  }

  export type NestedEnumLedgerDirectionFilter<$PrismaModel = never> = {
    equals?: $Enums.LedgerDirection | EnumLedgerDirectionFieldRefInput<$PrismaModel>
    in?: $Enums.LedgerDirection[] | ListEnumLedgerDirectionFieldRefInput<$PrismaModel>
    notIn?: $Enums.LedgerDirection[] | ListEnumLedgerDirectionFieldRefInput<$PrismaModel>
    not?: NestedEnumLedgerDirectionFilter<$PrismaModel> | $Enums.LedgerDirection
  }

  export type NestedEnumLedgerSourceTypeFilter<$PrismaModel = never> = {
    equals?: $Enums.LedgerSourceType | EnumLedgerSourceTypeFieldRefInput<$PrismaModel>
    in?: $Enums.LedgerSourceType[] | ListEnumLedgerSourceTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.LedgerSourceType[] | ListEnumLedgerSourceTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumLedgerSourceTypeFilter<$PrismaModel> | $Enums.LedgerSourceType
  }

  export type NestedEnumLedgerCurrencyWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.LedgerCurrency | EnumLedgerCurrencyFieldRefInput<$PrismaModel>
    in?: $Enums.LedgerCurrency[] | ListEnumLedgerCurrencyFieldRefInput<$PrismaModel>
    notIn?: $Enums.LedgerCurrency[] | ListEnumLedgerCurrencyFieldRefInput<$PrismaModel>
    not?: NestedEnumLedgerCurrencyWithAggregatesFilter<$PrismaModel> | $Enums.LedgerCurrency
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumLedgerCurrencyFilter<$PrismaModel>
    _max?: NestedEnumLedgerCurrencyFilter<$PrismaModel>
  }

  export type NestedEnumLedgerDirectionWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.LedgerDirection | EnumLedgerDirectionFieldRefInput<$PrismaModel>
    in?: $Enums.LedgerDirection[] | ListEnumLedgerDirectionFieldRefInput<$PrismaModel>
    notIn?: $Enums.LedgerDirection[] | ListEnumLedgerDirectionFieldRefInput<$PrismaModel>
    not?: NestedEnumLedgerDirectionWithAggregatesFilter<$PrismaModel> | $Enums.LedgerDirection
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumLedgerDirectionFilter<$PrismaModel>
    _max?: NestedEnumLedgerDirectionFilter<$PrismaModel>
  }

  export type NestedEnumLedgerSourceTypeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.LedgerSourceType | EnumLedgerSourceTypeFieldRefInput<$PrismaModel>
    in?: $Enums.LedgerSourceType[] | ListEnumLedgerSourceTypeFieldRefInput<$PrismaModel>
    notIn?: $Enums.LedgerSourceType[] | ListEnumLedgerSourceTypeFieldRefInput<$PrismaModel>
    not?: NestedEnumLedgerSourceTypeWithAggregatesFilter<$PrismaModel> | $Enums.LedgerSourceType
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumLedgerSourceTypeFilter<$PrismaModel>
    _max?: NestedEnumLedgerSourceTypeFilter<$PrismaModel>
  }

  export type NestedEnumCommentStatusFilter<$PrismaModel = never> = {
    equals?: $Enums.CommentStatus | EnumCommentStatusFieldRefInput<$PrismaModel>
    in?: $Enums.CommentStatus[] | ListEnumCommentStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.CommentStatus[] | ListEnumCommentStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumCommentStatusFilter<$PrismaModel> | $Enums.CommentStatus
  }

  export type NestedEnumCommentStatusWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.CommentStatus | EnumCommentStatusFieldRefInput<$PrismaModel>
    in?: $Enums.CommentStatus[] | ListEnumCommentStatusFieldRefInput<$PrismaModel>
    notIn?: $Enums.CommentStatus[] | ListEnumCommentStatusFieldRefInput<$PrismaModel>
    not?: NestedEnumCommentStatusWithAggregatesFilter<$PrismaModel> | $Enums.CommentStatus
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumCommentStatusFilter<$PrismaModel>
    _max?: NestedEnumCommentStatusFilter<$PrismaModel>
  }

  export type NestedEnumPromotionScopeFilter<$PrismaModel = never> = {
    equals?: $Enums.PromotionScope | EnumPromotionScopeFieldRefInput<$PrismaModel>
    in?: $Enums.PromotionScope[] | ListEnumPromotionScopeFieldRefInput<$PrismaModel>
    notIn?: $Enums.PromotionScope[] | ListEnumPromotionScopeFieldRefInput<$PrismaModel>
    not?: NestedEnumPromotionScopeFilter<$PrismaModel> | $Enums.PromotionScope
  }

  export type NestedEnumPromotionUsageFilter<$PrismaModel = never> = {
    equals?: $Enums.PromotionUsage | EnumPromotionUsageFieldRefInput<$PrismaModel>
    in?: $Enums.PromotionUsage[] | ListEnumPromotionUsageFieldRefInput<$PrismaModel>
    notIn?: $Enums.PromotionUsage[] | ListEnumPromotionUsageFieldRefInput<$PrismaModel>
    not?: NestedEnumPromotionUsageFilter<$PrismaModel> | $Enums.PromotionUsage
  }

  export type NestedEnumPromotionScopeWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.PromotionScope | EnumPromotionScopeFieldRefInput<$PrismaModel>
    in?: $Enums.PromotionScope[] | ListEnumPromotionScopeFieldRefInput<$PrismaModel>
    notIn?: $Enums.PromotionScope[] | ListEnumPromotionScopeFieldRefInput<$PrismaModel>
    not?: NestedEnumPromotionScopeWithAggregatesFilter<$PrismaModel> | $Enums.PromotionScope
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumPromotionScopeFilter<$PrismaModel>
    _max?: NestedEnumPromotionScopeFilter<$PrismaModel>
  }

  export type NestedEnumPromotionUsageWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.PromotionUsage | EnumPromotionUsageFieldRefInput<$PrismaModel>
    in?: $Enums.PromotionUsage[] | ListEnumPromotionUsageFieldRefInput<$PrismaModel>
    notIn?: $Enums.PromotionUsage[] | ListEnumPromotionUsageFieldRefInput<$PrismaModel>
    not?: NestedEnumPromotionUsageWithAggregatesFilter<$PrismaModel> | $Enums.PromotionUsage
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumPromotionUsageFilter<$PrismaModel>
    _max?: NestedEnumPromotionUsageFilter<$PrismaModel>
  }

  export type NestedEnumMessageAudienceFilter<$PrismaModel = never> = {
    equals?: $Enums.MessageAudience | EnumMessageAudienceFieldRefInput<$PrismaModel>
    in?: $Enums.MessageAudience[] | ListEnumMessageAudienceFieldRefInput<$PrismaModel>
    notIn?: $Enums.MessageAudience[] | ListEnumMessageAudienceFieldRefInput<$PrismaModel>
    not?: NestedEnumMessageAudienceFilter<$PrismaModel> | $Enums.MessageAudience
  }

  export type NestedEnumMessageAudienceWithAggregatesFilter<$PrismaModel = never> = {
    equals?: $Enums.MessageAudience | EnumMessageAudienceFieldRefInput<$PrismaModel>
    in?: $Enums.MessageAudience[] | ListEnumMessageAudienceFieldRefInput<$PrismaModel>
    notIn?: $Enums.MessageAudience[] | ListEnumMessageAudienceFieldRefInput<$PrismaModel>
    not?: NestedEnumMessageAudienceWithAggregatesFilter<$PrismaModel> | $Enums.MessageAudience
    _count?: NestedIntFilter<$PrismaModel>
    _min?: NestedEnumMessageAudienceFilter<$PrismaModel>
    _max?: NestedEnumMessageAudienceFilter<$PrismaModel>
  }

  export type CustomerCreateWithoutCityInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    referredByAgent?: AdminUserCreateNestedOneWithoutReferredCustomersInput
    salesExpertTradingFor?: SalesExpertProfileCreateNestedOneWithoutTradingCustomerInput
    avatarFile?: UploadedFileCreateNestedOneWithoutCustomerAvatarsInput
    addresses?: CustomerAddressCreateNestedManyWithoutCustomerInput
    orders?: OrderCreateNestedManyWithoutCustomerInput
    preOrders?: PreOrderCreateNestedManyWithoutCustomerInput
    ledgerEntries?: LedgerEntryCreateNestedManyWithoutCustomerInput
    walletBonuses?: WalletBonusCreateNestedManyWithoutCustomerInput
    comments?: CommentCreateNestedManyWithoutCustomerInput
    promotions?: PromotionCreateNestedManyWithoutCustomerInput
    notifications?: NotificationRecipientCreateNestedManyWithoutCustomerInput
    activityLogs?: CustomerActivityLogCreateNestedManyWithoutCustomerInput
    otpChallenges?: CustomerOtpCreateNestedManyWithoutCustomerInput
  }

  export type CustomerUncheckedCreateWithoutCityInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    referredByAgentId?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    avatarFileId?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    salesExpertTradingFor?: SalesExpertProfileUncheckedCreateNestedOneWithoutTradingCustomerInput
    addresses?: CustomerAddressUncheckedCreateNestedManyWithoutCustomerInput
    orders?: OrderUncheckedCreateNestedManyWithoutCustomerInput
    preOrders?: PreOrderUncheckedCreateNestedManyWithoutCustomerInput
    ledgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutCustomerInput
    walletBonuses?: WalletBonusUncheckedCreateNestedManyWithoutCustomerInput
    comments?: CommentUncheckedCreateNestedManyWithoutCustomerInput
    promotions?: PromotionUncheckedCreateNestedManyWithoutCustomerInput
    notifications?: NotificationRecipientUncheckedCreateNestedManyWithoutCustomerInput
    activityLogs?: CustomerActivityLogUncheckedCreateNestedManyWithoutCustomerInput
    otpChallenges?: CustomerOtpUncheckedCreateNestedManyWithoutCustomerInput
  }

  export type CustomerCreateOrConnectWithoutCityInput = {
    where: CustomerWhereUniqueInput
    create: XOR<CustomerCreateWithoutCityInput, CustomerUncheckedCreateWithoutCityInput>
  }

  export type CustomerCreateManyCityInputEnvelope = {
    data: CustomerCreateManyCityInput | CustomerCreateManyCityInput[]
    skipDuplicates?: boolean
  }

  export type CustomerAddressCreateWithoutCityInput = {
    id?: string
    addressLine: string
    isDefault?: boolean
    customer: CustomerCreateNestedOneWithoutAddressesInput
  }

  export type CustomerAddressUncheckedCreateWithoutCityInput = {
    id?: string
    customerId: string
    addressLine: string
    isDefault?: boolean
  }

  export type CustomerAddressCreateOrConnectWithoutCityInput = {
    where: CustomerAddressWhereUniqueInput
    create: XOR<CustomerAddressCreateWithoutCityInput, CustomerAddressUncheckedCreateWithoutCityInput>
  }

  export type CustomerAddressCreateManyCityInputEnvelope = {
    data: CustomerAddressCreateManyCityInput | CustomerAddressCreateManyCityInput[]
    skipDuplicates?: boolean
  }

  export type BranchCreateWithoutCityInput = {
    id?: string
    name: string
    address?: string | null
    phone?: string | null
    isActive?: boolean
    adminUsers?: AdminUserCreateNestedManyWithoutBranchInput
    orders?: OrderCreateNestedManyWithoutBranchInput
    allocations?: BranchAllocationCreateNestedManyWithoutBranchInput
  }

  export type BranchUncheckedCreateWithoutCityInput = {
    id?: string
    name: string
    address?: string | null
    phone?: string | null
    isActive?: boolean
    adminUsers?: AdminUserUncheckedCreateNestedManyWithoutBranchInput
    orders?: OrderUncheckedCreateNestedManyWithoutBranchInput
    allocations?: BranchAllocationUncheckedCreateNestedManyWithoutBranchInput
  }

  export type BranchCreateOrConnectWithoutCityInput = {
    where: BranchWhereUniqueInput
    create: XOR<BranchCreateWithoutCityInput, BranchUncheckedCreateWithoutCityInput>
  }

  export type BranchCreateManyCityInputEnvelope = {
    data: BranchCreateManyCityInput | BranchCreateManyCityInput[]
    skipDuplicates?: boolean
  }

  export type PreOrderCreateWithoutCityInput = {
    id?: string
    status?: $Enums.PreOrderStatus
    designImageUrl?: string | null
    colorName?: string | null
    sizeSpec?: string | null
    stoneColor?: string | null
    minaColor?: string | null
    estimatedWeightGrams?: Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: Decimal | DecimalJsLike | number | string | null
    description?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    customer: CustomerCreateNestedOneWithoutPreOrdersInput
    workshop?: WorkshopCreateNestedOneWithoutPreOrdersInput
    convertedOrder?: OrderCreateNestedOneWithoutConvertedFromPreOrderInput
    statusEvents?: PreOrderStatusEventCreateNestedManyWithoutPreOrderInput
  }

  export type PreOrderUncheckedCreateWithoutCityInput = {
    id?: string
    customerId: string
    workshopId?: string | null
    status?: $Enums.PreOrderStatus
    designImageUrl?: string | null
    colorName?: string | null
    sizeSpec?: string | null
    stoneColor?: string | null
    minaColor?: string | null
    estimatedWeightGrams?: Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: Decimal | DecimalJsLike | number | string | null
    description?: string | null
    convertedOrderId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    statusEvents?: PreOrderStatusEventUncheckedCreateNestedManyWithoutPreOrderInput
  }

  export type PreOrderCreateOrConnectWithoutCityInput = {
    where: PreOrderWhereUniqueInput
    create: XOR<PreOrderCreateWithoutCityInput, PreOrderUncheckedCreateWithoutCityInput>
  }

  export type PreOrderCreateManyCityInputEnvelope = {
    data: PreOrderCreateManyCityInput | PreOrderCreateManyCityInput[]
    skipDuplicates?: boolean
  }

  export type SalesExpertProfileCreateWithoutCityInput = {
    id?: string
    gramLevel?: Decimal | DecimalJsLike | number | string
    phone?: string | null
    nationalCode?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    adminUser: AdminUserCreateNestedOneWithoutSalesExpertProfileInput
    tradingCustomer?: CustomerCreateNestedOneWithoutSalesExpertTradingForInput
  }

  export type SalesExpertProfileUncheckedCreateWithoutCityInput = {
    id?: string
    adminUserId: string
    gramLevel?: Decimal | DecimalJsLike | number | string
    phone?: string | null
    nationalCode?: string | null
    tradingCustomerId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SalesExpertProfileCreateOrConnectWithoutCityInput = {
    where: SalesExpertProfileWhereUniqueInput
    create: XOR<SalesExpertProfileCreateWithoutCityInput, SalesExpertProfileUncheckedCreateWithoutCityInput>
  }

  export type SalesExpertProfileCreateManyCityInputEnvelope = {
    data: SalesExpertProfileCreateManyCityInput | SalesExpertProfileCreateManyCityInput[]
    skipDuplicates?: boolean
  }

  export type CustomerUpsertWithWhereUniqueWithoutCityInput = {
    where: CustomerWhereUniqueInput
    update: XOR<CustomerUpdateWithoutCityInput, CustomerUncheckedUpdateWithoutCityInput>
    create: XOR<CustomerCreateWithoutCityInput, CustomerUncheckedCreateWithoutCityInput>
  }

  export type CustomerUpdateWithWhereUniqueWithoutCityInput = {
    where: CustomerWhereUniqueInput
    data: XOR<CustomerUpdateWithoutCityInput, CustomerUncheckedUpdateWithoutCityInput>
  }

  export type CustomerUpdateManyWithWhereWithoutCityInput = {
    where: CustomerScalarWhereInput
    data: XOR<CustomerUpdateManyMutationInput, CustomerUncheckedUpdateManyWithoutCityInput>
  }

  export type CustomerScalarWhereInput = {
    AND?: CustomerScalarWhereInput | CustomerScalarWhereInput[]
    OR?: CustomerScalarWhereInput[]
    NOT?: CustomerScalarWhereInput | CustomerScalarWhereInput[]
    id?: StringFilter<"Customer"> | string
    fullName?: StringFilter<"Customer"> | string
    firstName?: StringNullableFilter<"Customer"> | string | null
    lastName?: StringNullableFilter<"Customer"> | string | null
    mobile?: StringFilter<"Customer"> | string
    nationalCode?: StringFilter<"Customer"> | string
    passwordHash?: StringFilter<"Customer"> | string
    cityId?: StringNullableFilter<"Customer"> | string | null
    kind?: EnumCustomerKindFilter<"Customer"> | $Enums.CustomerKind
    phone?: StringNullableFilter<"Customer"> | string | null
    address?: StringNullableFilter<"Customer"> | string | null
    storeName?: StringNullableFilter<"Customer"> | string | null
    pasazhName?: StringNullableFilter<"Customer"> | string | null
    zone?: StringNullableFilter<"Customer"> | string | null
    memberCode?: StringNullableFilter<"Customer"> | string | null
    referredByAgentId?: StringNullableFilter<"Customer"> | string | null
    goldCreditLimitGrams?: DecimalFilter<"Customer"> | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFilter<"Customer"> | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFilter<"Customer"> | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFilter<"Customer"> | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFilter<"Customer"> | $Enums.VerificationStep
    nationalIdImageUrl?: StringNullableFilter<"Customer"> | string | null
    businessLicenseUrl?: StringNullableFilter<"Customer"> | string | null
    shopImageUrl?: StringNullableFilter<"Customer"> | string | null
    avatarFileId?: StringNullableFilter<"Customer"> | string | null
    canPlaceOrders?: BoolFilter<"Customer"> | boolean
    isActive?: BoolFilter<"Customer"> | boolean
    isArchived?: BoolFilter<"Customer"> | boolean
    createdAt?: DateTimeFilter<"Customer"> | Date | string
    updatedAt?: DateTimeFilter<"Customer"> | Date | string
  }

  export type CustomerAddressUpsertWithWhereUniqueWithoutCityInput = {
    where: CustomerAddressWhereUniqueInput
    update: XOR<CustomerAddressUpdateWithoutCityInput, CustomerAddressUncheckedUpdateWithoutCityInput>
    create: XOR<CustomerAddressCreateWithoutCityInput, CustomerAddressUncheckedCreateWithoutCityInput>
  }

  export type CustomerAddressUpdateWithWhereUniqueWithoutCityInput = {
    where: CustomerAddressWhereUniqueInput
    data: XOR<CustomerAddressUpdateWithoutCityInput, CustomerAddressUncheckedUpdateWithoutCityInput>
  }

  export type CustomerAddressUpdateManyWithWhereWithoutCityInput = {
    where: CustomerAddressScalarWhereInput
    data: XOR<CustomerAddressUpdateManyMutationInput, CustomerAddressUncheckedUpdateManyWithoutCityInput>
  }

  export type CustomerAddressScalarWhereInput = {
    AND?: CustomerAddressScalarWhereInput | CustomerAddressScalarWhereInput[]
    OR?: CustomerAddressScalarWhereInput[]
    NOT?: CustomerAddressScalarWhereInput | CustomerAddressScalarWhereInput[]
    id?: StringFilter<"CustomerAddress"> | string
    customerId?: StringFilter<"CustomerAddress"> | string
    cityId?: StringNullableFilter<"CustomerAddress"> | string | null
    addressLine?: StringFilter<"CustomerAddress"> | string
    isDefault?: BoolFilter<"CustomerAddress"> | boolean
  }

  export type BranchUpsertWithWhereUniqueWithoutCityInput = {
    where: BranchWhereUniqueInput
    update: XOR<BranchUpdateWithoutCityInput, BranchUncheckedUpdateWithoutCityInput>
    create: XOR<BranchCreateWithoutCityInput, BranchUncheckedCreateWithoutCityInput>
  }

  export type BranchUpdateWithWhereUniqueWithoutCityInput = {
    where: BranchWhereUniqueInput
    data: XOR<BranchUpdateWithoutCityInput, BranchUncheckedUpdateWithoutCityInput>
  }

  export type BranchUpdateManyWithWhereWithoutCityInput = {
    where: BranchScalarWhereInput
    data: XOR<BranchUpdateManyMutationInput, BranchUncheckedUpdateManyWithoutCityInput>
  }

  export type BranchScalarWhereInput = {
    AND?: BranchScalarWhereInput | BranchScalarWhereInput[]
    OR?: BranchScalarWhereInput[]
    NOT?: BranchScalarWhereInput | BranchScalarWhereInput[]
    id?: StringFilter<"Branch"> | string
    name?: StringFilter<"Branch"> | string
    address?: StringNullableFilter<"Branch"> | string | null
    phone?: StringNullableFilter<"Branch"> | string | null
    isActive?: BoolFilter<"Branch"> | boolean
    cityId?: StringNullableFilter<"Branch"> | string | null
  }

  export type PreOrderUpsertWithWhereUniqueWithoutCityInput = {
    where: PreOrderWhereUniqueInput
    update: XOR<PreOrderUpdateWithoutCityInput, PreOrderUncheckedUpdateWithoutCityInput>
    create: XOR<PreOrderCreateWithoutCityInput, PreOrderUncheckedCreateWithoutCityInput>
  }

  export type PreOrderUpdateWithWhereUniqueWithoutCityInput = {
    where: PreOrderWhereUniqueInput
    data: XOR<PreOrderUpdateWithoutCityInput, PreOrderUncheckedUpdateWithoutCityInput>
  }

  export type PreOrderUpdateManyWithWhereWithoutCityInput = {
    where: PreOrderScalarWhereInput
    data: XOR<PreOrderUpdateManyMutationInput, PreOrderUncheckedUpdateManyWithoutCityInput>
  }

  export type PreOrderScalarWhereInput = {
    AND?: PreOrderScalarWhereInput | PreOrderScalarWhereInput[]
    OR?: PreOrderScalarWhereInput[]
    NOT?: PreOrderScalarWhereInput | PreOrderScalarWhereInput[]
    id?: StringFilter<"PreOrder"> | string
    customerId?: StringFilter<"PreOrder"> | string
    cityId?: StringNullableFilter<"PreOrder"> | string | null
    workshopId?: StringNullableFilter<"PreOrder"> | string | null
    status?: EnumPreOrderStatusFilter<"PreOrder"> | $Enums.PreOrderStatus
    designImageUrl?: StringNullableFilter<"PreOrder"> | string | null
    colorName?: StringNullableFilter<"PreOrder"> | string | null
    sizeSpec?: StringNullableFilter<"PreOrder"> | string | null
    stoneColor?: StringNullableFilter<"PreOrder"> | string | null
    minaColor?: StringNullableFilter<"PreOrder"> | string | null
    estimatedWeightGrams?: DecimalNullableFilter<"PreOrder"> | Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: DecimalNullableFilter<"PreOrder"> | Decimal | DecimalJsLike | number | string | null
    description?: StringNullableFilter<"PreOrder"> | string | null
    convertedOrderId?: StringNullableFilter<"PreOrder"> | string | null
    createdAt?: DateTimeFilter<"PreOrder"> | Date | string
    updatedAt?: DateTimeFilter<"PreOrder"> | Date | string
  }

  export type SalesExpertProfileUpsertWithWhereUniqueWithoutCityInput = {
    where: SalesExpertProfileWhereUniqueInput
    update: XOR<SalesExpertProfileUpdateWithoutCityInput, SalesExpertProfileUncheckedUpdateWithoutCityInput>
    create: XOR<SalesExpertProfileCreateWithoutCityInput, SalesExpertProfileUncheckedCreateWithoutCityInput>
  }

  export type SalesExpertProfileUpdateWithWhereUniqueWithoutCityInput = {
    where: SalesExpertProfileWhereUniqueInput
    data: XOR<SalesExpertProfileUpdateWithoutCityInput, SalesExpertProfileUncheckedUpdateWithoutCityInput>
  }

  export type SalesExpertProfileUpdateManyWithWhereWithoutCityInput = {
    where: SalesExpertProfileScalarWhereInput
    data: XOR<SalesExpertProfileUpdateManyMutationInput, SalesExpertProfileUncheckedUpdateManyWithoutCityInput>
  }

  export type SalesExpertProfileScalarWhereInput = {
    AND?: SalesExpertProfileScalarWhereInput | SalesExpertProfileScalarWhereInput[]
    OR?: SalesExpertProfileScalarWhereInput[]
    NOT?: SalesExpertProfileScalarWhereInput | SalesExpertProfileScalarWhereInput[]
    id?: StringFilter<"SalesExpertProfile"> | string
    adminUserId?: StringFilter<"SalesExpertProfile"> | string
    cityId?: StringNullableFilter<"SalesExpertProfile"> | string | null
    gramLevel?: DecimalFilter<"SalesExpertProfile"> | Decimal | DecimalJsLike | number | string
    phone?: StringNullableFilter<"SalesExpertProfile"> | string | null
    nationalCode?: StringNullableFilter<"SalesExpertProfile"> | string | null
    tradingCustomerId?: StringNullableFilter<"SalesExpertProfile"> | string | null
    createdAt?: DateTimeFilter<"SalesExpertProfile"> | Date | string
    updatedAt?: DateTimeFilter<"SalesExpertProfile"> | Date | string
  }

  export type UserTypeCreateWithoutAdminUsersInput = {
    id: number
    title: string
    isActive?: boolean
    createdAt?: Date | string
    permissions?: PermissionCreateNestedManyWithoutUserTypeInput
  }

  export type UserTypeUncheckedCreateWithoutAdminUsersInput = {
    id: number
    title: string
    isActive?: boolean
    createdAt?: Date | string
    permissions?: PermissionUncheckedCreateNestedManyWithoutUserTypeInput
  }

  export type UserTypeCreateOrConnectWithoutAdminUsersInput = {
    where: UserTypeWhereUniqueInput
    create: XOR<UserTypeCreateWithoutAdminUsersInput, UserTypeUncheckedCreateWithoutAdminUsersInput>
  }

  export type BranchCreateWithoutAdminUsersInput = {
    id?: string
    name: string
    address?: string | null
    phone?: string | null
    isActive?: boolean
    city?: CityCreateNestedOneWithoutBranchesInput
    orders?: OrderCreateNestedManyWithoutBranchInput
    allocations?: BranchAllocationCreateNestedManyWithoutBranchInput
  }

  export type BranchUncheckedCreateWithoutAdminUsersInput = {
    id?: string
    name: string
    address?: string | null
    phone?: string | null
    isActive?: boolean
    cityId?: string | null
    orders?: OrderUncheckedCreateNestedManyWithoutBranchInput
    allocations?: BranchAllocationUncheckedCreateNestedManyWithoutBranchInput
  }

  export type BranchCreateOrConnectWithoutAdminUsersInput = {
    where: BranchWhereUniqueInput
    create: XOR<BranchCreateWithoutAdminUsersInput, BranchUncheckedCreateWithoutAdminUsersInput>
  }

  export type UploadedFileCreateWithoutAdminUserAvatarsInput = {
    id?: string
    url: string
    originalName: string
    mimeType: string
    sizeBytes: number
    purpose?: string | null
    createdAt?: Date | string
    uploadedByAdminUser?: AdminUserCreateNestedOneWithoutUploadedFilesInput
    customerAvatars?: CustomerCreateNestedManyWithoutAvatarFileInput
  }

  export type UploadedFileUncheckedCreateWithoutAdminUserAvatarsInput = {
    id?: string
    url: string
    originalName: string
    mimeType: string
    sizeBytes: number
    purpose?: string | null
    uploadedByAdminUserId?: string | null
    createdAt?: Date | string
    customerAvatars?: CustomerUncheckedCreateNestedManyWithoutAvatarFileInput
  }

  export type UploadedFileCreateOrConnectWithoutAdminUserAvatarsInput = {
    where: UploadedFileWhereUniqueInput
    create: XOR<UploadedFileCreateWithoutAdminUserAvatarsInput, UploadedFileUncheckedCreateWithoutAdminUserAvatarsInput>
  }

  export type CustomerCreateWithoutReferredByAgentInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    city?: CityCreateNestedOneWithoutCustomersInput
    salesExpertTradingFor?: SalesExpertProfileCreateNestedOneWithoutTradingCustomerInput
    avatarFile?: UploadedFileCreateNestedOneWithoutCustomerAvatarsInput
    addresses?: CustomerAddressCreateNestedManyWithoutCustomerInput
    orders?: OrderCreateNestedManyWithoutCustomerInput
    preOrders?: PreOrderCreateNestedManyWithoutCustomerInput
    ledgerEntries?: LedgerEntryCreateNestedManyWithoutCustomerInput
    walletBonuses?: WalletBonusCreateNestedManyWithoutCustomerInput
    comments?: CommentCreateNestedManyWithoutCustomerInput
    promotions?: PromotionCreateNestedManyWithoutCustomerInput
    notifications?: NotificationRecipientCreateNestedManyWithoutCustomerInput
    activityLogs?: CustomerActivityLogCreateNestedManyWithoutCustomerInput
    otpChallenges?: CustomerOtpCreateNestedManyWithoutCustomerInput
  }

  export type CustomerUncheckedCreateWithoutReferredByAgentInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    cityId?: string | null
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    avatarFileId?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    salesExpertTradingFor?: SalesExpertProfileUncheckedCreateNestedOneWithoutTradingCustomerInput
    addresses?: CustomerAddressUncheckedCreateNestedManyWithoutCustomerInput
    orders?: OrderUncheckedCreateNestedManyWithoutCustomerInput
    preOrders?: PreOrderUncheckedCreateNestedManyWithoutCustomerInput
    ledgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutCustomerInput
    walletBonuses?: WalletBonusUncheckedCreateNestedManyWithoutCustomerInput
    comments?: CommentUncheckedCreateNestedManyWithoutCustomerInput
    promotions?: PromotionUncheckedCreateNestedManyWithoutCustomerInput
    notifications?: NotificationRecipientUncheckedCreateNestedManyWithoutCustomerInput
    activityLogs?: CustomerActivityLogUncheckedCreateNestedManyWithoutCustomerInput
    otpChallenges?: CustomerOtpUncheckedCreateNestedManyWithoutCustomerInput
  }

  export type CustomerCreateOrConnectWithoutReferredByAgentInput = {
    where: CustomerWhereUniqueInput
    create: XOR<CustomerCreateWithoutReferredByAgentInput, CustomerUncheckedCreateWithoutReferredByAgentInput>
  }

  export type CustomerCreateManyReferredByAgentInputEnvelope = {
    data: CustomerCreateManyReferredByAgentInput | CustomerCreateManyReferredByAgentInput[]
    skipDuplicates?: boolean
  }

  export type WorkshopCreateWithoutSupervisorInput = {
    id?: string
    name: string
    address?: string | null
    phone?: string | null
    isActive?: boolean
    preOrders?: PreOrderCreateNestedManyWithoutWorkshopInput
  }

  export type WorkshopUncheckedCreateWithoutSupervisorInput = {
    id?: string
    name: string
    address?: string | null
    phone?: string | null
    isActive?: boolean
    preOrders?: PreOrderUncheckedCreateNestedManyWithoutWorkshopInput
  }

  export type WorkshopCreateOrConnectWithoutSupervisorInput = {
    where: WorkshopWhereUniqueInput
    create: XOR<WorkshopCreateWithoutSupervisorInput, WorkshopUncheckedCreateWithoutSupervisorInput>
  }

  export type WorkshopCreateManySupervisorInputEnvelope = {
    data: WorkshopCreateManySupervisorInput | WorkshopCreateManySupervisorInput[]
    skipDuplicates?: boolean
  }

  export type BranchAllocationCreateWithoutAllocatorAdminUserInput = {
    id?: string
    note?: string | null
    createdAt?: Date | string
    branch: BranchCreateNestedOneWithoutAllocationsInput
    items?: BranchAllocationItemCreateNestedManyWithoutAllocationInput
  }

  export type BranchAllocationUncheckedCreateWithoutAllocatorAdminUserInput = {
    id?: string
    branchId: string
    note?: string | null
    createdAt?: Date | string
    items?: BranchAllocationItemUncheckedCreateNestedManyWithoutAllocationInput
  }

  export type BranchAllocationCreateOrConnectWithoutAllocatorAdminUserInput = {
    where: BranchAllocationWhereUniqueInput
    create: XOR<BranchAllocationCreateWithoutAllocatorAdminUserInput, BranchAllocationUncheckedCreateWithoutAllocatorAdminUserInput>
  }

  export type BranchAllocationCreateManyAllocatorAdminUserInputEnvelope = {
    data: BranchAllocationCreateManyAllocatorAdminUserInput | BranchAllocationCreateManyAllocatorAdminUserInput[]
    skipDuplicates?: boolean
  }

  export type LedgerEntryCreateWithoutPostedByAdminUserInput = {
    id?: string
    currency: $Enums.LedgerCurrency
    direction: $Enums.LedgerDirection
    sourceType: $Enums.LedgerSourceType
    amount: Decimal | DecimalJsLike | number | string
    karatPerMille?: number | null
    pricePerGramRialAtEntry?: Decimal | DecimalJsLike | number | string | null
    confirmed?: boolean
    confirmedAt?: Date | string | null
    labName?: string | null
    hallmark?: string | null
    accountName?: string | null
    bankName?: string | null
    transferTo?: string | null
    originalValue?: Decimal | DecimalJsLike | number | string | null
    priceRial?: Decimal | DecimalJsLike | number | string | null
    receivedAt?: Date | string | null
    note?: string | null
    createdAt?: Date | string
    customer: CustomerCreateNestedOneWithoutLedgerEntriesInput
    order?: OrderCreateNestedOneWithoutLedgerEntriesInput
  }

  export type LedgerEntryUncheckedCreateWithoutPostedByAdminUserInput = {
    id?: string
    customerId: string
    currency: $Enums.LedgerCurrency
    direction: $Enums.LedgerDirection
    sourceType: $Enums.LedgerSourceType
    amount: Decimal | DecimalJsLike | number | string
    karatPerMille?: number | null
    pricePerGramRialAtEntry?: Decimal | DecimalJsLike | number | string | null
    orderId?: string | null
    confirmed?: boolean
    confirmedAt?: Date | string | null
    labName?: string | null
    hallmark?: string | null
    accountName?: string | null
    bankName?: string | null
    transferTo?: string | null
    originalValue?: Decimal | DecimalJsLike | number | string | null
    priceRial?: Decimal | DecimalJsLike | number | string | null
    receivedAt?: Date | string | null
    note?: string | null
    createdAt?: Date | string
  }

  export type LedgerEntryCreateOrConnectWithoutPostedByAdminUserInput = {
    where: LedgerEntryWhereUniqueInput
    create: XOR<LedgerEntryCreateWithoutPostedByAdminUserInput, LedgerEntryUncheckedCreateWithoutPostedByAdminUserInput>
  }

  export type LedgerEntryCreateManyPostedByAdminUserInputEnvelope = {
    data: LedgerEntryCreateManyPostedByAdminUserInput | LedgerEntryCreateManyPostedByAdminUserInput[]
    skipDuplicates?: boolean
  }

  export type OrderStatusEventCreateWithoutActorAdminUserInput = {
    id?: string
    fromStatus?: $Enums.OrderStatus | null
    toStatus: $Enums.OrderStatus
    note?: string | null
    createdAt?: Date | string
    order: OrderCreateNestedOneWithoutStatusEventsInput
  }

  export type OrderStatusEventUncheckedCreateWithoutActorAdminUserInput = {
    id?: string
    orderId: string
    fromStatus?: $Enums.OrderStatus | null
    toStatus: $Enums.OrderStatus
    note?: string | null
    createdAt?: Date | string
  }

  export type OrderStatusEventCreateOrConnectWithoutActorAdminUserInput = {
    where: OrderStatusEventWhereUniqueInput
    create: XOR<OrderStatusEventCreateWithoutActorAdminUserInput, OrderStatusEventUncheckedCreateWithoutActorAdminUserInput>
  }

  export type OrderStatusEventCreateManyActorAdminUserInputEnvelope = {
    data: OrderStatusEventCreateManyActorAdminUserInput | OrderStatusEventCreateManyActorAdminUserInput[]
    skipDuplicates?: boolean
  }

  export type PreOrderStatusEventCreateWithoutActorAdminUserInput = {
    id?: string
    changes: JsonNullValueInput | InputJsonValue
    ipAddress?: string | null
    createdAt?: Date | string
    preOrder: PreOrderCreateNestedOneWithoutStatusEventsInput
  }

  export type PreOrderStatusEventUncheckedCreateWithoutActorAdminUserInput = {
    id?: string
    preOrderId: string
    changes: JsonNullValueInput | InputJsonValue
    ipAddress?: string | null
    createdAt?: Date | string
  }

  export type PreOrderStatusEventCreateOrConnectWithoutActorAdminUserInput = {
    where: PreOrderStatusEventWhereUniqueInput
    create: XOR<PreOrderStatusEventCreateWithoutActorAdminUserInput, PreOrderStatusEventUncheckedCreateWithoutActorAdminUserInput>
  }

  export type PreOrderStatusEventCreateManyActorAdminUserInputEnvelope = {
    data: PreOrderStatusEventCreateManyActorAdminUserInput | PreOrderStatusEventCreateManyActorAdminUserInput[]
    skipDuplicates?: boolean
  }

  export type SmsMessageCreateWithoutSentByAdminUserInput = {
    id?: string
    audience: $Enums.MessageAudience
    recipients?: string | null
    body: string
    sentCount?: number
    createdAt?: Date | string
  }

  export type SmsMessageUncheckedCreateWithoutSentByAdminUserInput = {
    id?: string
    audience: $Enums.MessageAudience
    recipients?: string | null
    body: string
    sentCount?: number
    createdAt?: Date | string
  }

  export type SmsMessageCreateOrConnectWithoutSentByAdminUserInput = {
    where: SmsMessageWhereUniqueInput
    create: XOR<SmsMessageCreateWithoutSentByAdminUserInput, SmsMessageUncheckedCreateWithoutSentByAdminUserInput>
  }

  export type SmsMessageCreateManySentByAdminUserInputEnvelope = {
    data: SmsMessageCreateManySentByAdminUserInput | SmsMessageCreateManySentByAdminUserInput[]
    skipDuplicates?: boolean
  }

  export type NotificationCreateWithoutSentByAdminUserInput = {
    id?: string
    title: string
    body: string
    audience?: $Enums.MessageAudience
    createdAt?: Date | string
    recipients?: NotificationRecipientCreateNestedManyWithoutNotificationInput
  }

  export type NotificationUncheckedCreateWithoutSentByAdminUserInput = {
    id?: string
    title: string
    body: string
    audience?: $Enums.MessageAudience
    createdAt?: Date | string
    recipients?: NotificationRecipientUncheckedCreateNestedManyWithoutNotificationInput
  }

  export type NotificationCreateOrConnectWithoutSentByAdminUserInput = {
    where: NotificationWhereUniqueInput
    create: XOR<NotificationCreateWithoutSentByAdminUserInput, NotificationUncheckedCreateWithoutSentByAdminUserInput>
  }

  export type NotificationCreateManySentByAdminUserInputEnvelope = {
    data: NotificationCreateManySentByAdminUserInput | NotificationCreateManySentByAdminUserInput[]
    skipDuplicates?: boolean
  }

  export type UploadedFileCreateWithoutUploadedByAdminUserInput = {
    id?: string
    url: string
    originalName: string
    mimeType: string
    sizeBytes: number
    purpose?: string | null
    createdAt?: Date | string
    customerAvatars?: CustomerCreateNestedManyWithoutAvatarFileInput
    adminUserAvatars?: AdminUserCreateNestedManyWithoutAvatarFileInput
  }

  export type UploadedFileUncheckedCreateWithoutUploadedByAdminUserInput = {
    id?: string
    url: string
    originalName: string
    mimeType: string
    sizeBytes: number
    purpose?: string | null
    createdAt?: Date | string
    customerAvatars?: CustomerUncheckedCreateNestedManyWithoutAvatarFileInput
    adminUserAvatars?: AdminUserUncheckedCreateNestedManyWithoutAvatarFileInput
  }

  export type UploadedFileCreateOrConnectWithoutUploadedByAdminUserInput = {
    where: UploadedFileWhereUniqueInput
    create: XOR<UploadedFileCreateWithoutUploadedByAdminUserInput, UploadedFileUncheckedCreateWithoutUploadedByAdminUserInput>
  }

  export type UploadedFileCreateManyUploadedByAdminUserInputEnvelope = {
    data: UploadedFileCreateManyUploadedByAdminUserInput | UploadedFileCreateManyUploadedByAdminUserInput[]
    skipDuplicates?: boolean
  }

  export type SalesExpertProfileCreateWithoutAdminUserInput = {
    id?: string
    gramLevel?: Decimal | DecimalJsLike | number | string
    phone?: string | null
    nationalCode?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    city?: CityCreateNestedOneWithoutSalesExpertProfilesInput
    tradingCustomer?: CustomerCreateNestedOneWithoutSalesExpertTradingForInput
  }

  export type SalesExpertProfileUncheckedCreateWithoutAdminUserInput = {
    id?: string
    cityId?: string | null
    gramLevel?: Decimal | DecimalJsLike | number | string
    phone?: string | null
    nationalCode?: string | null
    tradingCustomerId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SalesExpertProfileCreateOrConnectWithoutAdminUserInput = {
    where: SalesExpertProfileWhereUniqueInput
    create: XOR<SalesExpertProfileCreateWithoutAdminUserInput, SalesExpertProfileUncheckedCreateWithoutAdminUserInput>
  }

  export type AdminSessionCreateWithoutAdminUserInput = {
    id?: string
    jti: string
    iamSessionId?: string | null
    iamSub?: string | null
    ipAddress?: string | null
    userAgent?: string | null
    createdAt?: Date | string
    expiresAt?: Date | string | null
    lastSeenAt?: Date | string | null
    revokedAt?: Date | string | null
    revokedReason?: string | null
  }

  export type AdminSessionUncheckedCreateWithoutAdminUserInput = {
    id?: string
    jti: string
    iamSessionId?: string | null
    iamSub?: string | null
    ipAddress?: string | null
    userAgent?: string | null
    createdAt?: Date | string
    expiresAt?: Date | string | null
    lastSeenAt?: Date | string | null
    revokedAt?: Date | string | null
    revokedReason?: string | null
  }

  export type AdminSessionCreateOrConnectWithoutAdminUserInput = {
    where: AdminSessionWhereUniqueInput
    create: XOR<AdminSessionCreateWithoutAdminUserInput, AdminSessionUncheckedCreateWithoutAdminUserInput>
  }

  export type AdminSessionCreateManyAdminUserInputEnvelope = {
    data: AdminSessionCreateManyAdminUserInput | AdminSessionCreateManyAdminUserInput[]
    skipDuplicates?: boolean
  }

  export type UserTypeUpsertWithoutAdminUsersInput = {
    update: XOR<UserTypeUpdateWithoutAdminUsersInput, UserTypeUncheckedUpdateWithoutAdminUsersInput>
    create: XOR<UserTypeCreateWithoutAdminUsersInput, UserTypeUncheckedCreateWithoutAdminUsersInput>
    where?: UserTypeWhereInput
  }

  export type UserTypeUpdateToOneWithWhereWithoutAdminUsersInput = {
    where?: UserTypeWhereInput
    data: XOR<UserTypeUpdateWithoutAdminUsersInput, UserTypeUncheckedUpdateWithoutAdminUsersInput>
  }

  export type UserTypeUpdateWithoutAdminUsersInput = {
    id?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    permissions?: PermissionUpdateManyWithoutUserTypeNestedInput
  }

  export type UserTypeUncheckedUpdateWithoutAdminUsersInput = {
    id?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    permissions?: PermissionUncheckedUpdateManyWithoutUserTypeNestedInput
  }

  export type BranchUpsertWithoutAdminUsersInput = {
    update: XOR<BranchUpdateWithoutAdminUsersInput, BranchUncheckedUpdateWithoutAdminUsersInput>
    create: XOR<BranchCreateWithoutAdminUsersInput, BranchUncheckedCreateWithoutAdminUsersInput>
    where?: BranchWhereInput
  }

  export type BranchUpdateToOneWithWhereWithoutAdminUsersInput = {
    where?: BranchWhereInput
    data: XOR<BranchUpdateWithoutAdminUsersInput, BranchUncheckedUpdateWithoutAdminUsersInput>
  }

  export type BranchUpdateWithoutAdminUsersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    city?: CityUpdateOneWithoutBranchesNestedInput
    orders?: OrderUpdateManyWithoutBranchNestedInput
    allocations?: BranchAllocationUpdateManyWithoutBranchNestedInput
  }

  export type BranchUncheckedUpdateWithoutAdminUsersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    orders?: OrderUncheckedUpdateManyWithoutBranchNestedInput
    allocations?: BranchAllocationUncheckedUpdateManyWithoutBranchNestedInput
  }

  export type UploadedFileUpsertWithoutAdminUserAvatarsInput = {
    update: XOR<UploadedFileUpdateWithoutAdminUserAvatarsInput, UploadedFileUncheckedUpdateWithoutAdminUserAvatarsInput>
    create: XOR<UploadedFileCreateWithoutAdminUserAvatarsInput, UploadedFileUncheckedCreateWithoutAdminUserAvatarsInput>
    where?: UploadedFileWhereInput
  }

  export type UploadedFileUpdateToOneWithWhereWithoutAdminUserAvatarsInput = {
    where?: UploadedFileWhereInput
    data: XOR<UploadedFileUpdateWithoutAdminUserAvatarsInput, UploadedFileUncheckedUpdateWithoutAdminUserAvatarsInput>
  }

  export type UploadedFileUpdateWithoutAdminUserAvatarsInput = {
    id?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    originalName?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
    sizeBytes?: IntFieldUpdateOperationsInput | number
    purpose?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    uploadedByAdminUser?: AdminUserUpdateOneWithoutUploadedFilesNestedInput
    customerAvatars?: CustomerUpdateManyWithoutAvatarFileNestedInput
  }

  export type UploadedFileUncheckedUpdateWithoutAdminUserAvatarsInput = {
    id?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    originalName?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
    sizeBytes?: IntFieldUpdateOperationsInput | number
    purpose?: NullableStringFieldUpdateOperationsInput | string | null
    uploadedByAdminUserId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    customerAvatars?: CustomerUncheckedUpdateManyWithoutAvatarFileNestedInput
  }

  export type CustomerUpsertWithWhereUniqueWithoutReferredByAgentInput = {
    where: CustomerWhereUniqueInput
    update: XOR<CustomerUpdateWithoutReferredByAgentInput, CustomerUncheckedUpdateWithoutReferredByAgentInput>
    create: XOR<CustomerCreateWithoutReferredByAgentInput, CustomerUncheckedCreateWithoutReferredByAgentInput>
  }

  export type CustomerUpdateWithWhereUniqueWithoutReferredByAgentInput = {
    where: CustomerWhereUniqueInput
    data: XOR<CustomerUpdateWithoutReferredByAgentInput, CustomerUncheckedUpdateWithoutReferredByAgentInput>
  }

  export type CustomerUpdateManyWithWhereWithoutReferredByAgentInput = {
    where: CustomerScalarWhereInput
    data: XOR<CustomerUpdateManyMutationInput, CustomerUncheckedUpdateManyWithoutReferredByAgentInput>
  }

  export type WorkshopUpsertWithWhereUniqueWithoutSupervisorInput = {
    where: WorkshopWhereUniqueInput
    update: XOR<WorkshopUpdateWithoutSupervisorInput, WorkshopUncheckedUpdateWithoutSupervisorInput>
    create: XOR<WorkshopCreateWithoutSupervisorInput, WorkshopUncheckedCreateWithoutSupervisorInput>
  }

  export type WorkshopUpdateWithWhereUniqueWithoutSupervisorInput = {
    where: WorkshopWhereUniqueInput
    data: XOR<WorkshopUpdateWithoutSupervisorInput, WorkshopUncheckedUpdateWithoutSupervisorInput>
  }

  export type WorkshopUpdateManyWithWhereWithoutSupervisorInput = {
    where: WorkshopScalarWhereInput
    data: XOR<WorkshopUpdateManyMutationInput, WorkshopUncheckedUpdateManyWithoutSupervisorInput>
  }

  export type WorkshopScalarWhereInput = {
    AND?: WorkshopScalarWhereInput | WorkshopScalarWhereInput[]
    OR?: WorkshopScalarWhereInput[]
    NOT?: WorkshopScalarWhereInput | WorkshopScalarWhereInput[]
    id?: StringFilter<"Workshop"> | string
    name?: StringFilter<"Workshop"> | string
    address?: StringNullableFilter<"Workshop"> | string | null
    phone?: StringNullableFilter<"Workshop"> | string | null
    supervisorId?: StringNullableFilter<"Workshop"> | string | null
    isActive?: BoolFilter<"Workshop"> | boolean
  }

  export type BranchAllocationUpsertWithWhereUniqueWithoutAllocatorAdminUserInput = {
    where: BranchAllocationWhereUniqueInput
    update: XOR<BranchAllocationUpdateWithoutAllocatorAdminUserInput, BranchAllocationUncheckedUpdateWithoutAllocatorAdminUserInput>
    create: XOR<BranchAllocationCreateWithoutAllocatorAdminUserInput, BranchAllocationUncheckedCreateWithoutAllocatorAdminUserInput>
  }

  export type BranchAllocationUpdateWithWhereUniqueWithoutAllocatorAdminUserInput = {
    where: BranchAllocationWhereUniqueInput
    data: XOR<BranchAllocationUpdateWithoutAllocatorAdminUserInput, BranchAllocationUncheckedUpdateWithoutAllocatorAdminUserInput>
  }

  export type BranchAllocationUpdateManyWithWhereWithoutAllocatorAdminUserInput = {
    where: BranchAllocationScalarWhereInput
    data: XOR<BranchAllocationUpdateManyMutationInput, BranchAllocationUncheckedUpdateManyWithoutAllocatorAdminUserInput>
  }

  export type BranchAllocationScalarWhereInput = {
    AND?: BranchAllocationScalarWhereInput | BranchAllocationScalarWhereInput[]
    OR?: BranchAllocationScalarWhereInput[]
    NOT?: BranchAllocationScalarWhereInput | BranchAllocationScalarWhereInput[]
    id?: StringFilter<"BranchAllocation"> | string
    branchId?: StringFilter<"BranchAllocation"> | string
    allocatorAdminUserId?: StringNullableFilter<"BranchAllocation"> | string | null
    note?: StringNullableFilter<"BranchAllocation"> | string | null
    createdAt?: DateTimeFilter<"BranchAllocation"> | Date | string
  }

  export type LedgerEntryUpsertWithWhereUniqueWithoutPostedByAdminUserInput = {
    where: LedgerEntryWhereUniqueInput
    update: XOR<LedgerEntryUpdateWithoutPostedByAdminUserInput, LedgerEntryUncheckedUpdateWithoutPostedByAdminUserInput>
    create: XOR<LedgerEntryCreateWithoutPostedByAdminUserInput, LedgerEntryUncheckedCreateWithoutPostedByAdminUserInput>
  }

  export type LedgerEntryUpdateWithWhereUniqueWithoutPostedByAdminUserInput = {
    where: LedgerEntryWhereUniqueInput
    data: XOR<LedgerEntryUpdateWithoutPostedByAdminUserInput, LedgerEntryUncheckedUpdateWithoutPostedByAdminUserInput>
  }

  export type LedgerEntryUpdateManyWithWhereWithoutPostedByAdminUserInput = {
    where: LedgerEntryScalarWhereInput
    data: XOR<LedgerEntryUpdateManyMutationInput, LedgerEntryUncheckedUpdateManyWithoutPostedByAdminUserInput>
  }

  export type LedgerEntryScalarWhereInput = {
    AND?: LedgerEntryScalarWhereInput | LedgerEntryScalarWhereInput[]
    OR?: LedgerEntryScalarWhereInput[]
    NOT?: LedgerEntryScalarWhereInput | LedgerEntryScalarWhereInput[]
    id?: StringFilter<"LedgerEntry"> | string
    customerId?: StringFilter<"LedgerEntry"> | string
    currency?: EnumLedgerCurrencyFilter<"LedgerEntry"> | $Enums.LedgerCurrency
    direction?: EnumLedgerDirectionFilter<"LedgerEntry"> | $Enums.LedgerDirection
    sourceType?: EnumLedgerSourceTypeFilter<"LedgerEntry"> | $Enums.LedgerSourceType
    amount?: DecimalFilter<"LedgerEntry"> | Decimal | DecimalJsLike | number | string
    karatPerMille?: IntNullableFilter<"LedgerEntry"> | number | null
    pricePerGramRialAtEntry?: DecimalNullableFilter<"LedgerEntry"> | Decimal | DecimalJsLike | number | string | null
    orderId?: StringNullableFilter<"LedgerEntry"> | string | null
    confirmed?: BoolFilter<"LedgerEntry"> | boolean
    confirmedAt?: DateTimeNullableFilter<"LedgerEntry"> | Date | string | null
    postedByAdminUserId?: StringNullableFilter<"LedgerEntry"> | string | null
    labName?: StringNullableFilter<"LedgerEntry"> | string | null
    hallmark?: StringNullableFilter<"LedgerEntry"> | string | null
    accountName?: StringNullableFilter<"LedgerEntry"> | string | null
    bankName?: StringNullableFilter<"LedgerEntry"> | string | null
    transferTo?: StringNullableFilter<"LedgerEntry"> | string | null
    originalValue?: DecimalNullableFilter<"LedgerEntry"> | Decimal | DecimalJsLike | number | string | null
    priceRial?: DecimalNullableFilter<"LedgerEntry"> | Decimal | DecimalJsLike | number | string | null
    receivedAt?: DateTimeNullableFilter<"LedgerEntry"> | Date | string | null
    note?: StringNullableFilter<"LedgerEntry"> | string | null
    createdAt?: DateTimeFilter<"LedgerEntry"> | Date | string
  }

  export type OrderStatusEventUpsertWithWhereUniqueWithoutActorAdminUserInput = {
    where: OrderStatusEventWhereUniqueInput
    update: XOR<OrderStatusEventUpdateWithoutActorAdminUserInput, OrderStatusEventUncheckedUpdateWithoutActorAdminUserInput>
    create: XOR<OrderStatusEventCreateWithoutActorAdminUserInput, OrderStatusEventUncheckedCreateWithoutActorAdminUserInput>
  }

  export type OrderStatusEventUpdateWithWhereUniqueWithoutActorAdminUserInput = {
    where: OrderStatusEventWhereUniqueInput
    data: XOR<OrderStatusEventUpdateWithoutActorAdminUserInput, OrderStatusEventUncheckedUpdateWithoutActorAdminUserInput>
  }

  export type OrderStatusEventUpdateManyWithWhereWithoutActorAdminUserInput = {
    where: OrderStatusEventScalarWhereInput
    data: XOR<OrderStatusEventUpdateManyMutationInput, OrderStatusEventUncheckedUpdateManyWithoutActorAdminUserInput>
  }

  export type OrderStatusEventScalarWhereInput = {
    AND?: OrderStatusEventScalarWhereInput | OrderStatusEventScalarWhereInput[]
    OR?: OrderStatusEventScalarWhereInput[]
    NOT?: OrderStatusEventScalarWhereInput | OrderStatusEventScalarWhereInput[]
    id?: StringFilter<"OrderStatusEvent"> | string
    orderId?: StringFilter<"OrderStatusEvent"> | string
    fromStatus?: EnumOrderStatusNullableFilter<"OrderStatusEvent"> | $Enums.OrderStatus | null
    toStatus?: EnumOrderStatusFilter<"OrderStatusEvent"> | $Enums.OrderStatus
    note?: StringNullableFilter<"OrderStatusEvent"> | string | null
    actorAdminUserId?: StringNullableFilter<"OrderStatusEvent"> | string | null
    createdAt?: DateTimeFilter<"OrderStatusEvent"> | Date | string
  }

  export type PreOrderStatusEventUpsertWithWhereUniqueWithoutActorAdminUserInput = {
    where: PreOrderStatusEventWhereUniqueInput
    update: XOR<PreOrderStatusEventUpdateWithoutActorAdminUserInput, PreOrderStatusEventUncheckedUpdateWithoutActorAdminUserInput>
    create: XOR<PreOrderStatusEventCreateWithoutActorAdminUserInput, PreOrderStatusEventUncheckedCreateWithoutActorAdminUserInput>
  }

  export type PreOrderStatusEventUpdateWithWhereUniqueWithoutActorAdminUserInput = {
    where: PreOrderStatusEventWhereUniqueInput
    data: XOR<PreOrderStatusEventUpdateWithoutActorAdminUserInput, PreOrderStatusEventUncheckedUpdateWithoutActorAdminUserInput>
  }

  export type PreOrderStatusEventUpdateManyWithWhereWithoutActorAdminUserInput = {
    where: PreOrderStatusEventScalarWhereInput
    data: XOR<PreOrderStatusEventUpdateManyMutationInput, PreOrderStatusEventUncheckedUpdateManyWithoutActorAdminUserInput>
  }

  export type PreOrderStatusEventScalarWhereInput = {
    AND?: PreOrderStatusEventScalarWhereInput | PreOrderStatusEventScalarWhereInput[]
    OR?: PreOrderStatusEventScalarWhereInput[]
    NOT?: PreOrderStatusEventScalarWhereInput | PreOrderStatusEventScalarWhereInput[]
    id?: StringFilter<"PreOrderStatusEvent"> | string
    preOrderId?: StringFilter<"PreOrderStatusEvent"> | string
    changes?: JsonFilter<"PreOrderStatusEvent">
    actorAdminUserId?: StringNullableFilter<"PreOrderStatusEvent"> | string | null
    ipAddress?: StringNullableFilter<"PreOrderStatusEvent"> | string | null
    createdAt?: DateTimeFilter<"PreOrderStatusEvent"> | Date | string
  }

  export type SmsMessageUpsertWithWhereUniqueWithoutSentByAdminUserInput = {
    where: SmsMessageWhereUniqueInput
    update: XOR<SmsMessageUpdateWithoutSentByAdminUserInput, SmsMessageUncheckedUpdateWithoutSentByAdminUserInput>
    create: XOR<SmsMessageCreateWithoutSentByAdminUserInput, SmsMessageUncheckedCreateWithoutSentByAdminUserInput>
  }

  export type SmsMessageUpdateWithWhereUniqueWithoutSentByAdminUserInput = {
    where: SmsMessageWhereUniqueInput
    data: XOR<SmsMessageUpdateWithoutSentByAdminUserInput, SmsMessageUncheckedUpdateWithoutSentByAdminUserInput>
  }

  export type SmsMessageUpdateManyWithWhereWithoutSentByAdminUserInput = {
    where: SmsMessageScalarWhereInput
    data: XOR<SmsMessageUpdateManyMutationInput, SmsMessageUncheckedUpdateManyWithoutSentByAdminUserInput>
  }

  export type SmsMessageScalarWhereInput = {
    AND?: SmsMessageScalarWhereInput | SmsMessageScalarWhereInput[]
    OR?: SmsMessageScalarWhereInput[]
    NOT?: SmsMessageScalarWhereInput | SmsMessageScalarWhereInput[]
    id?: StringFilter<"SmsMessage"> | string
    audience?: EnumMessageAudienceFilter<"SmsMessage"> | $Enums.MessageAudience
    recipients?: StringNullableFilter<"SmsMessage"> | string | null
    body?: StringFilter<"SmsMessage"> | string
    sentCount?: IntFilter<"SmsMessage"> | number
    sentByAdminUserId?: StringNullableFilter<"SmsMessage"> | string | null
    createdAt?: DateTimeFilter<"SmsMessage"> | Date | string
  }

  export type NotificationUpsertWithWhereUniqueWithoutSentByAdminUserInput = {
    where: NotificationWhereUniqueInput
    update: XOR<NotificationUpdateWithoutSentByAdminUserInput, NotificationUncheckedUpdateWithoutSentByAdminUserInput>
    create: XOR<NotificationCreateWithoutSentByAdminUserInput, NotificationUncheckedCreateWithoutSentByAdminUserInput>
  }

  export type NotificationUpdateWithWhereUniqueWithoutSentByAdminUserInput = {
    where: NotificationWhereUniqueInput
    data: XOR<NotificationUpdateWithoutSentByAdminUserInput, NotificationUncheckedUpdateWithoutSentByAdminUserInput>
  }

  export type NotificationUpdateManyWithWhereWithoutSentByAdminUserInput = {
    where: NotificationScalarWhereInput
    data: XOR<NotificationUpdateManyMutationInput, NotificationUncheckedUpdateManyWithoutSentByAdminUserInput>
  }

  export type NotificationScalarWhereInput = {
    AND?: NotificationScalarWhereInput | NotificationScalarWhereInput[]
    OR?: NotificationScalarWhereInput[]
    NOT?: NotificationScalarWhereInput | NotificationScalarWhereInput[]
    id?: StringFilter<"Notification"> | string
    title?: StringFilter<"Notification"> | string
    body?: StringFilter<"Notification"> | string
    audience?: EnumMessageAudienceFilter<"Notification"> | $Enums.MessageAudience
    sentByAdminUserId?: StringNullableFilter<"Notification"> | string | null
    createdAt?: DateTimeFilter<"Notification"> | Date | string
  }

  export type UploadedFileUpsertWithWhereUniqueWithoutUploadedByAdminUserInput = {
    where: UploadedFileWhereUniqueInput
    update: XOR<UploadedFileUpdateWithoutUploadedByAdminUserInput, UploadedFileUncheckedUpdateWithoutUploadedByAdminUserInput>
    create: XOR<UploadedFileCreateWithoutUploadedByAdminUserInput, UploadedFileUncheckedCreateWithoutUploadedByAdminUserInput>
  }

  export type UploadedFileUpdateWithWhereUniqueWithoutUploadedByAdminUserInput = {
    where: UploadedFileWhereUniqueInput
    data: XOR<UploadedFileUpdateWithoutUploadedByAdminUserInput, UploadedFileUncheckedUpdateWithoutUploadedByAdminUserInput>
  }

  export type UploadedFileUpdateManyWithWhereWithoutUploadedByAdminUserInput = {
    where: UploadedFileScalarWhereInput
    data: XOR<UploadedFileUpdateManyMutationInput, UploadedFileUncheckedUpdateManyWithoutUploadedByAdminUserInput>
  }

  export type UploadedFileScalarWhereInput = {
    AND?: UploadedFileScalarWhereInput | UploadedFileScalarWhereInput[]
    OR?: UploadedFileScalarWhereInput[]
    NOT?: UploadedFileScalarWhereInput | UploadedFileScalarWhereInput[]
    id?: StringFilter<"UploadedFile"> | string
    url?: StringFilter<"UploadedFile"> | string
    originalName?: StringFilter<"UploadedFile"> | string
    mimeType?: StringFilter<"UploadedFile"> | string
    sizeBytes?: IntFilter<"UploadedFile"> | number
    purpose?: StringNullableFilter<"UploadedFile"> | string | null
    uploadedByAdminUserId?: StringNullableFilter<"UploadedFile"> | string | null
    createdAt?: DateTimeFilter<"UploadedFile"> | Date | string
  }

  export type SalesExpertProfileUpsertWithoutAdminUserInput = {
    update: XOR<SalesExpertProfileUpdateWithoutAdminUserInput, SalesExpertProfileUncheckedUpdateWithoutAdminUserInput>
    create: XOR<SalesExpertProfileCreateWithoutAdminUserInput, SalesExpertProfileUncheckedCreateWithoutAdminUserInput>
    where?: SalesExpertProfileWhereInput
  }

  export type SalesExpertProfileUpdateToOneWithWhereWithoutAdminUserInput = {
    where?: SalesExpertProfileWhereInput
    data: XOR<SalesExpertProfileUpdateWithoutAdminUserInput, SalesExpertProfileUncheckedUpdateWithoutAdminUserInput>
  }

  export type SalesExpertProfileUpdateWithoutAdminUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    gramLevel?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    nationalCode?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutSalesExpertProfilesNestedInput
    tradingCustomer?: CustomerUpdateOneWithoutSalesExpertTradingForNestedInput
  }

  export type SalesExpertProfileUncheckedUpdateWithoutAdminUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    gramLevel?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    nationalCode?: NullableStringFieldUpdateOperationsInput | string | null
    tradingCustomerId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AdminSessionUpsertWithWhereUniqueWithoutAdminUserInput = {
    where: AdminSessionWhereUniqueInput
    update: XOR<AdminSessionUpdateWithoutAdminUserInput, AdminSessionUncheckedUpdateWithoutAdminUserInput>
    create: XOR<AdminSessionCreateWithoutAdminUserInput, AdminSessionUncheckedCreateWithoutAdminUserInput>
  }

  export type AdminSessionUpdateWithWhereUniqueWithoutAdminUserInput = {
    where: AdminSessionWhereUniqueInput
    data: XOR<AdminSessionUpdateWithoutAdminUserInput, AdminSessionUncheckedUpdateWithoutAdminUserInput>
  }

  export type AdminSessionUpdateManyWithWhereWithoutAdminUserInput = {
    where: AdminSessionScalarWhereInput
    data: XOR<AdminSessionUpdateManyMutationInput, AdminSessionUncheckedUpdateManyWithoutAdminUserInput>
  }

  export type AdminSessionScalarWhereInput = {
    AND?: AdminSessionScalarWhereInput | AdminSessionScalarWhereInput[]
    OR?: AdminSessionScalarWhereInput[]
    NOT?: AdminSessionScalarWhereInput | AdminSessionScalarWhereInput[]
    id?: StringFilter<"AdminSession"> | string
    jti?: StringFilter<"AdminSession"> | string
    adminUserId?: StringFilter<"AdminSession"> | string
    iamSessionId?: StringNullableFilter<"AdminSession"> | string | null
    iamSub?: StringNullableFilter<"AdminSession"> | string | null
    ipAddress?: StringNullableFilter<"AdminSession"> | string | null
    userAgent?: StringNullableFilter<"AdminSession"> | string | null
    createdAt?: DateTimeFilter<"AdminSession"> | Date | string
    expiresAt?: DateTimeNullableFilter<"AdminSession"> | Date | string | null
    lastSeenAt?: DateTimeNullableFilter<"AdminSession"> | Date | string | null
    revokedAt?: DateTimeNullableFilter<"AdminSession"> | Date | string | null
    revokedReason?: StringNullableFilter<"AdminSession"> | string | null
  }

  export type AdminUserCreateWithoutSessionsInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    userType?: UserTypeCreateNestedOneWithoutAdminUsersInput
    branch?: BranchCreateNestedOneWithoutAdminUsersInput
    avatarFile?: UploadedFileCreateNestedOneWithoutAdminUserAvatarsInput
    referredCustomers?: CustomerCreateNestedManyWithoutReferredByAgentInput
    supervisedWorkshops?: WorkshopCreateNestedManyWithoutSupervisorInput
    branchAllocations?: BranchAllocationCreateNestedManyWithoutAllocatorAdminUserInput
    postedLedgerEntries?: LedgerEntryCreateNestedManyWithoutPostedByAdminUserInput
    orderStatusEvents?: OrderStatusEventCreateNestedManyWithoutActorAdminUserInput
    preOrderStatusEvents?: PreOrderStatusEventCreateNestedManyWithoutActorAdminUserInput
    sentSmsMessages?: SmsMessageCreateNestedManyWithoutSentByAdminUserInput
    sentNotifications?: NotificationCreateNestedManyWithoutSentByAdminUserInput
    uploadedFiles?: UploadedFileCreateNestedManyWithoutUploadedByAdminUserInput
    salesExpertProfile?: SalesExpertProfileCreateNestedOneWithoutAdminUserInput
  }

  export type AdminUserUncheckedCreateWithoutSessionsInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    userTypeId?: number | null
    branchId?: string | null
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    avatarFileId?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    referredCustomers?: CustomerUncheckedCreateNestedManyWithoutReferredByAgentInput
    supervisedWorkshops?: WorkshopUncheckedCreateNestedManyWithoutSupervisorInput
    branchAllocations?: BranchAllocationUncheckedCreateNestedManyWithoutAllocatorAdminUserInput
    postedLedgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutPostedByAdminUserInput
    orderStatusEvents?: OrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput
    preOrderStatusEvents?: PreOrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput
    sentSmsMessages?: SmsMessageUncheckedCreateNestedManyWithoutSentByAdminUserInput
    sentNotifications?: NotificationUncheckedCreateNestedManyWithoutSentByAdminUserInput
    uploadedFiles?: UploadedFileUncheckedCreateNestedManyWithoutUploadedByAdminUserInput
    salesExpertProfile?: SalesExpertProfileUncheckedCreateNestedOneWithoutAdminUserInput
  }

  export type AdminUserCreateOrConnectWithoutSessionsInput = {
    where: AdminUserWhereUniqueInput
    create: XOR<AdminUserCreateWithoutSessionsInput, AdminUserUncheckedCreateWithoutSessionsInput>
  }

  export type AdminUserUpsertWithoutSessionsInput = {
    update: XOR<AdminUserUpdateWithoutSessionsInput, AdminUserUncheckedUpdateWithoutSessionsInput>
    create: XOR<AdminUserCreateWithoutSessionsInput, AdminUserUncheckedCreateWithoutSessionsInput>
    where?: AdminUserWhereInput
  }

  export type AdminUserUpdateToOneWithWhereWithoutSessionsInput = {
    where?: AdminUserWhereInput
    data: XOR<AdminUserUpdateWithoutSessionsInput, AdminUserUncheckedUpdateWithoutSessionsInput>
  }

  export type AdminUserUpdateWithoutSessionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    userType?: UserTypeUpdateOneWithoutAdminUsersNestedInput
    branch?: BranchUpdateOneWithoutAdminUsersNestedInput
    avatarFile?: UploadedFileUpdateOneWithoutAdminUserAvatarsNestedInput
    referredCustomers?: CustomerUpdateManyWithoutReferredByAgentNestedInput
    supervisedWorkshops?: WorkshopUpdateManyWithoutSupervisorNestedInput
    branchAllocations?: BranchAllocationUpdateManyWithoutAllocatorAdminUserNestedInput
    postedLedgerEntries?: LedgerEntryUpdateManyWithoutPostedByAdminUserNestedInput
    orderStatusEvents?: OrderStatusEventUpdateManyWithoutActorAdminUserNestedInput
    preOrderStatusEvents?: PreOrderStatusEventUpdateManyWithoutActorAdminUserNestedInput
    sentSmsMessages?: SmsMessageUpdateManyWithoutSentByAdminUserNestedInput
    sentNotifications?: NotificationUpdateManyWithoutSentByAdminUserNestedInput
    uploadedFiles?: UploadedFileUpdateManyWithoutUploadedByAdminUserNestedInput
    salesExpertProfile?: SalesExpertProfileUpdateOneWithoutAdminUserNestedInput
  }

  export type AdminUserUncheckedUpdateWithoutSessionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    userTypeId?: NullableIntFieldUpdateOperationsInput | number | null
    branchId?: NullableStringFieldUpdateOperationsInput | string | null
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredCustomers?: CustomerUncheckedUpdateManyWithoutReferredByAgentNestedInput
    supervisedWorkshops?: WorkshopUncheckedUpdateManyWithoutSupervisorNestedInput
    branchAllocations?: BranchAllocationUncheckedUpdateManyWithoutAllocatorAdminUserNestedInput
    postedLedgerEntries?: LedgerEntryUncheckedUpdateManyWithoutPostedByAdminUserNestedInput
    orderStatusEvents?: OrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput
    preOrderStatusEvents?: PreOrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput
    sentSmsMessages?: SmsMessageUncheckedUpdateManyWithoutSentByAdminUserNestedInput
    sentNotifications?: NotificationUncheckedUpdateManyWithoutSentByAdminUserNestedInput
    uploadedFiles?: UploadedFileUncheckedUpdateManyWithoutUploadedByAdminUserNestedInput
    salesExpertProfile?: SalesExpertProfileUncheckedUpdateOneWithoutAdminUserNestedInput
  }

  export type AdminUserCreateWithoutSalesExpertProfileInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    userType?: UserTypeCreateNestedOneWithoutAdminUsersInput
    branch?: BranchCreateNestedOneWithoutAdminUsersInput
    avatarFile?: UploadedFileCreateNestedOneWithoutAdminUserAvatarsInput
    referredCustomers?: CustomerCreateNestedManyWithoutReferredByAgentInput
    supervisedWorkshops?: WorkshopCreateNestedManyWithoutSupervisorInput
    branchAllocations?: BranchAllocationCreateNestedManyWithoutAllocatorAdminUserInput
    postedLedgerEntries?: LedgerEntryCreateNestedManyWithoutPostedByAdminUserInput
    orderStatusEvents?: OrderStatusEventCreateNestedManyWithoutActorAdminUserInput
    preOrderStatusEvents?: PreOrderStatusEventCreateNestedManyWithoutActorAdminUserInput
    sentSmsMessages?: SmsMessageCreateNestedManyWithoutSentByAdminUserInput
    sentNotifications?: NotificationCreateNestedManyWithoutSentByAdminUserInput
    uploadedFiles?: UploadedFileCreateNestedManyWithoutUploadedByAdminUserInput
    sessions?: AdminSessionCreateNestedManyWithoutAdminUserInput
  }

  export type AdminUserUncheckedCreateWithoutSalesExpertProfileInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    userTypeId?: number | null
    branchId?: string | null
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    avatarFileId?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    referredCustomers?: CustomerUncheckedCreateNestedManyWithoutReferredByAgentInput
    supervisedWorkshops?: WorkshopUncheckedCreateNestedManyWithoutSupervisorInput
    branchAllocations?: BranchAllocationUncheckedCreateNestedManyWithoutAllocatorAdminUserInput
    postedLedgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutPostedByAdminUserInput
    orderStatusEvents?: OrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput
    preOrderStatusEvents?: PreOrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput
    sentSmsMessages?: SmsMessageUncheckedCreateNestedManyWithoutSentByAdminUserInput
    sentNotifications?: NotificationUncheckedCreateNestedManyWithoutSentByAdminUserInput
    uploadedFiles?: UploadedFileUncheckedCreateNestedManyWithoutUploadedByAdminUserInput
    sessions?: AdminSessionUncheckedCreateNestedManyWithoutAdminUserInput
  }

  export type AdminUserCreateOrConnectWithoutSalesExpertProfileInput = {
    where: AdminUserWhereUniqueInput
    create: XOR<AdminUserCreateWithoutSalesExpertProfileInput, AdminUserUncheckedCreateWithoutSalesExpertProfileInput>
  }

  export type CityCreateWithoutSalesExpertProfilesInput = {
    id?: string
    name: string
    province?: string | null
    percent?: Decimal | DecimalJsLike | number | string | null
    percentAux?: Decimal | DecimalJsLike | number | string | null
    customers?: CustomerCreateNestedManyWithoutCityInput
    addresses?: CustomerAddressCreateNestedManyWithoutCityInput
    branches?: BranchCreateNestedManyWithoutCityInput
    preOrders?: PreOrderCreateNestedManyWithoutCityInput
  }

  export type CityUncheckedCreateWithoutSalesExpertProfilesInput = {
    id?: string
    name: string
    province?: string | null
    percent?: Decimal | DecimalJsLike | number | string | null
    percentAux?: Decimal | DecimalJsLike | number | string | null
    customers?: CustomerUncheckedCreateNestedManyWithoutCityInput
    addresses?: CustomerAddressUncheckedCreateNestedManyWithoutCityInput
    branches?: BranchUncheckedCreateNestedManyWithoutCityInput
    preOrders?: PreOrderUncheckedCreateNestedManyWithoutCityInput
  }

  export type CityCreateOrConnectWithoutSalesExpertProfilesInput = {
    where: CityWhereUniqueInput
    create: XOR<CityCreateWithoutSalesExpertProfilesInput, CityUncheckedCreateWithoutSalesExpertProfilesInput>
  }

  export type CustomerCreateWithoutSalesExpertTradingForInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    city?: CityCreateNestedOneWithoutCustomersInput
    referredByAgent?: AdminUserCreateNestedOneWithoutReferredCustomersInput
    avatarFile?: UploadedFileCreateNestedOneWithoutCustomerAvatarsInput
    addresses?: CustomerAddressCreateNestedManyWithoutCustomerInput
    orders?: OrderCreateNestedManyWithoutCustomerInput
    preOrders?: PreOrderCreateNestedManyWithoutCustomerInput
    ledgerEntries?: LedgerEntryCreateNestedManyWithoutCustomerInput
    walletBonuses?: WalletBonusCreateNestedManyWithoutCustomerInput
    comments?: CommentCreateNestedManyWithoutCustomerInput
    promotions?: PromotionCreateNestedManyWithoutCustomerInput
    notifications?: NotificationRecipientCreateNestedManyWithoutCustomerInput
    activityLogs?: CustomerActivityLogCreateNestedManyWithoutCustomerInput
    otpChallenges?: CustomerOtpCreateNestedManyWithoutCustomerInput
  }

  export type CustomerUncheckedCreateWithoutSalesExpertTradingForInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    cityId?: string | null
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    referredByAgentId?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    avatarFileId?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    addresses?: CustomerAddressUncheckedCreateNestedManyWithoutCustomerInput
    orders?: OrderUncheckedCreateNestedManyWithoutCustomerInput
    preOrders?: PreOrderUncheckedCreateNestedManyWithoutCustomerInput
    ledgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutCustomerInput
    walletBonuses?: WalletBonusUncheckedCreateNestedManyWithoutCustomerInput
    comments?: CommentUncheckedCreateNestedManyWithoutCustomerInput
    promotions?: PromotionUncheckedCreateNestedManyWithoutCustomerInput
    notifications?: NotificationRecipientUncheckedCreateNestedManyWithoutCustomerInput
    activityLogs?: CustomerActivityLogUncheckedCreateNestedManyWithoutCustomerInput
    otpChallenges?: CustomerOtpUncheckedCreateNestedManyWithoutCustomerInput
  }

  export type CustomerCreateOrConnectWithoutSalesExpertTradingForInput = {
    where: CustomerWhereUniqueInput
    create: XOR<CustomerCreateWithoutSalesExpertTradingForInput, CustomerUncheckedCreateWithoutSalesExpertTradingForInput>
  }

  export type AdminUserUpsertWithoutSalesExpertProfileInput = {
    update: XOR<AdminUserUpdateWithoutSalesExpertProfileInput, AdminUserUncheckedUpdateWithoutSalesExpertProfileInput>
    create: XOR<AdminUserCreateWithoutSalesExpertProfileInput, AdminUserUncheckedCreateWithoutSalesExpertProfileInput>
    where?: AdminUserWhereInput
  }

  export type AdminUserUpdateToOneWithWhereWithoutSalesExpertProfileInput = {
    where?: AdminUserWhereInput
    data: XOR<AdminUserUpdateWithoutSalesExpertProfileInput, AdminUserUncheckedUpdateWithoutSalesExpertProfileInput>
  }

  export type AdminUserUpdateWithoutSalesExpertProfileInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    userType?: UserTypeUpdateOneWithoutAdminUsersNestedInput
    branch?: BranchUpdateOneWithoutAdminUsersNestedInput
    avatarFile?: UploadedFileUpdateOneWithoutAdminUserAvatarsNestedInput
    referredCustomers?: CustomerUpdateManyWithoutReferredByAgentNestedInput
    supervisedWorkshops?: WorkshopUpdateManyWithoutSupervisorNestedInput
    branchAllocations?: BranchAllocationUpdateManyWithoutAllocatorAdminUserNestedInput
    postedLedgerEntries?: LedgerEntryUpdateManyWithoutPostedByAdminUserNestedInput
    orderStatusEvents?: OrderStatusEventUpdateManyWithoutActorAdminUserNestedInput
    preOrderStatusEvents?: PreOrderStatusEventUpdateManyWithoutActorAdminUserNestedInput
    sentSmsMessages?: SmsMessageUpdateManyWithoutSentByAdminUserNestedInput
    sentNotifications?: NotificationUpdateManyWithoutSentByAdminUserNestedInput
    uploadedFiles?: UploadedFileUpdateManyWithoutUploadedByAdminUserNestedInput
    sessions?: AdminSessionUpdateManyWithoutAdminUserNestedInput
  }

  export type AdminUserUncheckedUpdateWithoutSalesExpertProfileInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    userTypeId?: NullableIntFieldUpdateOperationsInput | number | null
    branchId?: NullableStringFieldUpdateOperationsInput | string | null
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredCustomers?: CustomerUncheckedUpdateManyWithoutReferredByAgentNestedInput
    supervisedWorkshops?: WorkshopUncheckedUpdateManyWithoutSupervisorNestedInput
    branchAllocations?: BranchAllocationUncheckedUpdateManyWithoutAllocatorAdminUserNestedInput
    postedLedgerEntries?: LedgerEntryUncheckedUpdateManyWithoutPostedByAdminUserNestedInput
    orderStatusEvents?: OrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput
    preOrderStatusEvents?: PreOrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput
    sentSmsMessages?: SmsMessageUncheckedUpdateManyWithoutSentByAdminUserNestedInput
    sentNotifications?: NotificationUncheckedUpdateManyWithoutSentByAdminUserNestedInput
    uploadedFiles?: UploadedFileUncheckedUpdateManyWithoutUploadedByAdminUserNestedInput
    sessions?: AdminSessionUncheckedUpdateManyWithoutAdminUserNestedInput
  }

  export type CityUpsertWithoutSalesExpertProfilesInput = {
    update: XOR<CityUpdateWithoutSalesExpertProfilesInput, CityUncheckedUpdateWithoutSalesExpertProfilesInput>
    create: XOR<CityCreateWithoutSalesExpertProfilesInput, CityUncheckedCreateWithoutSalesExpertProfilesInput>
    where?: CityWhereInput
  }

  export type CityUpdateToOneWithWhereWithoutSalesExpertProfilesInput = {
    where?: CityWhereInput
    data: XOR<CityUpdateWithoutSalesExpertProfilesInput, CityUncheckedUpdateWithoutSalesExpertProfilesInput>
  }

  export type CityUpdateWithoutSalesExpertProfilesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    province?: NullableStringFieldUpdateOperationsInput | string | null
    percent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    percentAux?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    customers?: CustomerUpdateManyWithoutCityNestedInput
    addresses?: CustomerAddressUpdateManyWithoutCityNestedInput
    branches?: BranchUpdateManyWithoutCityNestedInput
    preOrders?: PreOrderUpdateManyWithoutCityNestedInput
  }

  export type CityUncheckedUpdateWithoutSalesExpertProfilesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    province?: NullableStringFieldUpdateOperationsInput | string | null
    percent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    percentAux?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    customers?: CustomerUncheckedUpdateManyWithoutCityNestedInput
    addresses?: CustomerAddressUncheckedUpdateManyWithoutCityNestedInput
    branches?: BranchUncheckedUpdateManyWithoutCityNestedInput
    preOrders?: PreOrderUncheckedUpdateManyWithoutCityNestedInput
  }

  export type CustomerUpsertWithoutSalesExpertTradingForInput = {
    update: XOR<CustomerUpdateWithoutSalesExpertTradingForInput, CustomerUncheckedUpdateWithoutSalesExpertTradingForInput>
    create: XOR<CustomerCreateWithoutSalesExpertTradingForInput, CustomerUncheckedCreateWithoutSalesExpertTradingForInput>
    where?: CustomerWhereInput
  }

  export type CustomerUpdateToOneWithWhereWithoutSalesExpertTradingForInput = {
    where?: CustomerWhereInput
    data: XOR<CustomerUpdateWithoutSalesExpertTradingForInput, CustomerUncheckedUpdateWithoutSalesExpertTradingForInput>
  }

  export type CustomerUpdateWithoutSalesExpertTradingForInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutCustomersNestedInput
    referredByAgent?: AdminUserUpdateOneWithoutReferredCustomersNestedInput
    avatarFile?: UploadedFileUpdateOneWithoutCustomerAvatarsNestedInput
    addresses?: CustomerAddressUpdateManyWithoutCustomerNestedInput
    orders?: OrderUpdateManyWithoutCustomerNestedInput
    preOrders?: PreOrderUpdateManyWithoutCustomerNestedInput
    ledgerEntries?: LedgerEntryUpdateManyWithoutCustomerNestedInput
    walletBonuses?: WalletBonusUpdateManyWithoutCustomerNestedInput
    comments?: CommentUpdateManyWithoutCustomerNestedInput
    promotions?: PromotionUpdateManyWithoutCustomerNestedInput
    notifications?: NotificationRecipientUpdateManyWithoutCustomerNestedInput
    activityLogs?: CustomerActivityLogUpdateManyWithoutCustomerNestedInput
    otpChallenges?: CustomerOtpUpdateManyWithoutCustomerNestedInput
  }

  export type CustomerUncheckedUpdateWithoutSalesExpertTradingForInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredByAgentId?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    addresses?: CustomerAddressUncheckedUpdateManyWithoutCustomerNestedInput
    orders?: OrderUncheckedUpdateManyWithoutCustomerNestedInput
    preOrders?: PreOrderUncheckedUpdateManyWithoutCustomerNestedInput
    ledgerEntries?: LedgerEntryUncheckedUpdateManyWithoutCustomerNestedInput
    walletBonuses?: WalletBonusUncheckedUpdateManyWithoutCustomerNestedInput
    comments?: CommentUncheckedUpdateManyWithoutCustomerNestedInput
    promotions?: PromotionUncheckedUpdateManyWithoutCustomerNestedInput
    notifications?: NotificationRecipientUncheckedUpdateManyWithoutCustomerNestedInput
    activityLogs?: CustomerActivityLogUncheckedUpdateManyWithoutCustomerNestedInput
    otpChallenges?: CustomerOtpUncheckedUpdateManyWithoutCustomerNestedInput
  }

  export type CityCreateWithoutCustomersInput = {
    id?: string
    name: string
    province?: string | null
    percent?: Decimal | DecimalJsLike | number | string | null
    percentAux?: Decimal | DecimalJsLike | number | string | null
    addresses?: CustomerAddressCreateNestedManyWithoutCityInput
    branches?: BranchCreateNestedManyWithoutCityInput
    preOrders?: PreOrderCreateNestedManyWithoutCityInput
    salesExpertProfiles?: SalesExpertProfileCreateNestedManyWithoutCityInput
  }

  export type CityUncheckedCreateWithoutCustomersInput = {
    id?: string
    name: string
    province?: string | null
    percent?: Decimal | DecimalJsLike | number | string | null
    percentAux?: Decimal | DecimalJsLike | number | string | null
    addresses?: CustomerAddressUncheckedCreateNestedManyWithoutCityInput
    branches?: BranchUncheckedCreateNestedManyWithoutCityInput
    preOrders?: PreOrderUncheckedCreateNestedManyWithoutCityInput
    salesExpertProfiles?: SalesExpertProfileUncheckedCreateNestedManyWithoutCityInput
  }

  export type CityCreateOrConnectWithoutCustomersInput = {
    where: CityWhereUniqueInput
    create: XOR<CityCreateWithoutCustomersInput, CityUncheckedCreateWithoutCustomersInput>
  }

  export type AdminUserCreateWithoutReferredCustomersInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    userType?: UserTypeCreateNestedOneWithoutAdminUsersInput
    branch?: BranchCreateNestedOneWithoutAdminUsersInput
    avatarFile?: UploadedFileCreateNestedOneWithoutAdminUserAvatarsInput
    supervisedWorkshops?: WorkshopCreateNestedManyWithoutSupervisorInput
    branchAllocations?: BranchAllocationCreateNestedManyWithoutAllocatorAdminUserInput
    postedLedgerEntries?: LedgerEntryCreateNestedManyWithoutPostedByAdminUserInput
    orderStatusEvents?: OrderStatusEventCreateNestedManyWithoutActorAdminUserInput
    preOrderStatusEvents?: PreOrderStatusEventCreateNestedManyWithoutActorAdminUserInput
    sentSmsMessages?: SmsMessageCreateNestedManyWithoutSentByAdminUserInput
    sentNotifications?: NotificationCreateNestedManyWithoutSentByAdminUserInput
    uploadedFiles?: UploadedFileCreateNestedManyWithoutUploadedByAdminUserInput
    salesExpertProfile?: SalesExpertProfileCreateNestedOneWithoutAdminUserInput
    sessions?: AdminSessionCreateNestedManyWithoutAdminUserInput
  }

  export type AdminUserUncheckedCreateWithoutReferredCustomersInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    userTypeId?: number | null
    branchId?: string | null
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    avatarFileId?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    supervisedWorkshops?: WorkshopUncheckedCreateNestedManyWithoutSupervisorInput
    branchAllocations?: BranchAllocationUncheckedCreateNestedManyWithoutAllocatorAdminUserInput
    postedLedgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutPostedByAdminUserInput
    orderStatusEvents?: OrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput
    preOrderStatusEvents?: PreOrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput
    sentSmsMessages?: SmsMessageUncheckedCreateNestedManyWithoutSentByAdminUserInput
    sentNotifications?: NotificationUncheckedCreateNestedManyWithoutSentByAdminUserInput
    uploadedFiles?: UploadedFileUncheckedCreateNestedManyWithoutUploadedByAdminUserInput
    salesExpertProfile?: SalesExpertProfileUncheckedCreateNestedOneWithoutAdminUserInput
    sessions?: AdminSessionUncheckedCreateNestedManyWithoutAdminUserInput
  }

  export type AdminUserCreateOrConnectWithoutReferredCustomersInput = {
    where: AdminUserWhereUniqueInput
    create: XOR<AdminUserCreateWithoutReferredCustomersInput, AdminUserUncheckedCreateWithoutReferredCustomersInput>
  }

  export type SalesExpertProfileCreateWithoutTradingCustomerInput = {
    id?: string
    gramLevel?: Decimal | DecimalJsLike | number | string
    phone?: string | null
    nationalCode?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    adminUser: AdminUserCreateNestedOneWithoutSalesExpertProfileInput
    city?: CityCreateNestedOneWithoutSalesExpertProfilesInput
  }

  export type SalesExpertProfileUncheckedCreateWithoutTradingCustomerInput = {
    id?: string
    adminUserId: string
    cityId?: string | null
    gramLevel?: Decimal | DecimalJsLike | number | string
    phone?: string | null
    nationalCode?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SalesExpertProfileCreateOrConnectWithoutTradingCustomerInput = {
    where: SalesExpertProfileWhereUniqueInput
    create: XOR<SalesExpertProfileCreateWithoutTradingCustomerInput, SalesExpertProfileUncheckedCreateWithoutTradingCustomerInput>
  }

  export type UploadedFileCreateWithoutCustomerAvatarsInput = {
    id?: string
    url: string
    originalName: string
    mimeType: string
    sizeBytes: number
    purpose?: string | null
    createdAt?: Date | string
    uploadedByAdminUser?: AdminUserCreateNestedOneWithoutUploadedFilesInput
    adminUserAvatars?: AdminUserCreateNestedManyWithoutAvatarFileInput
  }

  export type UploadedFileUncheckedCreateWithoutCustomerAvatarsInput = {
    id?: string
    url: string
    originalName: string
    mimeType: string
    sizeBytes: number
    purpose?: string | null
    uploadedByAdminUserId?: string | null
    createdAt?: Date | string
    adminUserAvatars?: AdminUserUncheckedCreateNestedManyWithoutAvatarFileInput
  }

  export type UploadedFileCreateOrConnectWithoutCustomerAvatarsInput = {
    where: UploadedFileWhereUniqueInput
    create: XOR<UploadedFileCreateWithoutCustomerAvatarsInput, UploadedFileUncheckedCreateWithoutCustomerAvatarsInput>
  }

  export type CustomerAddressCreateWithoutCustomerInput = {
    id?: string
    addressLine: string
    isDefault?: boolean
    city?: CityCreateNestedOneWithoutAddressesInput
  }

  export type CustomerAddressUncheckedCreateWithoutCustomerInput = {
    id?: string
    cityId?: string | null
    addressLine: string
    isDefault?: boolean
  }

  export type CustomerAddressCreateOrConnectWithoutCustomerInput = {
    where: CustomerAddressWhereUniqueInput
    create: XOR<CustomerAddressCreateWithoutCustomerInput, CustomerAddressUncheckedCreateWithoutCustomerInput>
  }

  export type CustomerAddressCreateManyCustomerInputEnvelope = {
    data: CustomerAddressCreateManyCustomerInput | CustomerAddressCreateManyCustomerInput[]
    skipDuplicates?: boolean
  }

  export type OrderCreateWithoutCustomerInput = {
    id?: string
    orderNumber: string
    channel?: $Enums.OrderChannel
    status?: $Enums.OrderStatus
    totalGoldWeightGrams: Decimal | DecimalJsLike | number | string
    wageWeightGrams: Decimal | DecimalJsLike | number | string
    flatRialCharge?: Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: boolean
    deliveredAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    branch?: BranchCreateNestedOneWithoutOrdersInput
    items?: OrderItemCreateNestedManyWithoutOrderInput
    statusEvents?: OrderStatusEventCreateNestedManyWithoutOrderInput
    ledgerEntries?: LedgerEntryCreateNestedManyWithoutOrderInput
    convertedFromPreOrder?: PreOrderCreateNestedOneWithoutConvertedOrderInput
  }

  export type OrderUncheckedCreateWithoutCustomerInput = {
    id?: string
    orderNumber: string
    branchId?: string | null
    channel?: $Enums.OrderChannel
    status?: $Enums.OrderStatus
    totalGoldWeightGrams: Decimal | DecimalJsLike | number | string
    wageWeightGrams: Decimal | DecimalJsLike | number | string
    flatRialCharge?: Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: boolean
    deliveredAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    items?: OrderItemUncheckedCreateNestedManyWithoutOrderInput
    statusEvents?: OrderStatusEventUncheckedCreateNestedManyWithoutOrderInput
    ledgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutOrderInput
    convertedFromPreOrder?: PreOrderUncheckedCreateNestedOneWithoutConvertedOrderInput
  }

  export type OrderCreateOrConnectWithoutCustomerInput = {
    where: OrderWhereUniqueInput
    create: XOR<OrderCreateWithoutCustomerInput, OrderUncheckedCreateWithoutCustomerInput>
  }

  export type OrderCreateManyCustomerInputEnvelope = {
    data: OrderCreateManyCustomerInput | OrderCreateManyCustomerInput[]
    skipDuplicates?: boolean
  }

  export type PreOrderCreateWithoutCustomerInput = {
    id?: string
    status?: $Enums.PreOrderStatus
    designImageUrl?: string | null
    colorName?: string | null
    sizeSpec?: string | null
    stoneColor?: string | null
    minaColor?: string | null
    estimatedWeightGrams?: Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: Decimal | DecimalJsLike | number | string | null
    description?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    city?: CityCreateNestedOneWithoutPreOrdersInput
    workshop?: WorkshopCreateNestedOneWithoutPreOrdersInput
    convertedOrder?: OrderCreateNestedOneWithoutConvertedFromPreOrderInput
    statusEvents?: PreOrderStatusEventCreateNestedManyWithoutPreOrderInput
  }

  export type PreOrderUncheckedCreateWithoutCustomerInput = {
    id?: string
    cityId?: string | null
    workshopId?: string | null
    status?: $Enums.PreOrderStatus
    designImageUrl?: string | null
    colorName?: string | null
    sizeSpec?: string | null
    stoneColor?: string | null
    minaColor?: string | null
    estimatedWeightGrams?: Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: Decimal | DecimalJsLike | number | string | null
    description?: string | null
    convertedOrderId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    statusEvents?: PreOrderStatusEventUncheckedCreateNestedManyWithoutPreOrderInput
  }

  export type PreOrderCreateOrConnectWithoutCustomerInput = {
    where: PreOrderWhereUniqueInput
    create: XOR<PreOrderCreateWithoutCustomerInput, PreOrderUncheckedCreateWithoutCustomerInput>
  }

  export type PreOrderCreateManyCustomerInputEnvelope = {
    data: PreOrderCreateManyCustomerInput | PreOrderCreateManyCustomerInput[]
    skipDuplicates?: boolean
  }

  export type LedgerEntryCreateWithoutCustomerInput = {
    id?: string
    currency: $Enums.LedgerCurrency
    direction: $Enums.LedgerDirection
    sourceType: $Enums.LedgerSourceType
    amount: Decimal | DecimalJsLike | number | string
    karatPerMille?: number | null
    pricePerGramRialAtEntry?: Decimal | DecimalJsLike | number | string | null
    confirmed?: boolean
    confirmedAt?: Date | string | null
    labName?: string | null
    hallmark?: string | null
    accountName?: string | null
    bankName?: string | null
    transferTo?: string | null
    originalValue?: Decimal | DecimalJsLike | number | string | null
    priceRial?: Decimal | DecimalJsLike | number | string | null
    receivedAt?: Date | string | null
    note?: string | null
    createdAt?: Date | string
    order?: OrderCreateNestedOneWithoutLedgerEntriesInput
    postedByAdminUser?: AdminUserCreateNestedOneWithoutPostedLedgerEntriesInput
  }

  export type LedgerEntryUncheckedCreateWithoutCustomerInput = {
    id?: string
    currency: $Enums.LedgerCurrency
    direction: $Enums.LedgerDirection
    sourceType: $Enums.LedgerSourceType
    amount: Decimal | DecimalJsLike | number | string
    karatPerMille?: number | null
    pricePerGramRialAtEntry?: Decimal | DecimalJsLike | number | string | null
    orderId?: string | null
    confirmed?: boolean
    confirmedAt?: Date | string | null
    postedByAdminUserId?: string | null
    labName?: string | null
    hallmark?: string | null
    accountName?: string | null
    bankName?: string | null
    transferTo?: string | null
    originalValue?: Decimal | DecimalJsLike | number | string | null
    priceRial?: Decimal | DecimalJsLike | number | string | null
    receivedAt?: Date | string | null
    note?: string | null
    createdAt?: Date | string
  }

  export type LedgerEntryCreateOrConnectWithoutCustomerInput = {
    where: LedgerEntryWhereUniqueInput
    create: XOR<LedgerEntryCreateWithoutCustomerInput, LedgerEntryUncheckedCreateWithoutCustomerInput>
  }

  export type LedgerEntryCreateManyCustomerInputEnvelope = {
    data: LedgerEntryCreateManyCustomerInput | LedgerEntryCreateManyCustomerInput[]
    skipDuplicates?: boolean
  }

  export type WalletBonusCreateWithoutCustomerInput = {
    id?: string
    orderId?: string | null
    goldGrams: Decimal | DecimalJsLike | number | string
    grantedAt?: Date | string
    expiresAt: Date | string
    consumedAt?: Date | string | null
    isActive?: boolean
  }

  export type WalletBonusUncheckedCreateWithoutCustomerInput = {
    id?: string
    orderId?: string | null
    goldGrams: Decimal | DecimalJsLike | number | string
    grantedAt?: Date | string
    expiresAt: Date | string
    consumedAt?: Date | string | null
    isActive?: boolean
  }

  export type WalletBonusCreateOrConnectWithoutCustomerInput = {
    where: WalletBonusWhereUniqueInput
    create: XOR<WalletBonusCreateWithoutCustomerInput, WalletBonusUncheckedCreateWithoutCustomerInput>
  }

  export type WalletBonusCreateManyCustomerInputEnvelope = {
    data: WalletBonusCreateManyCustomerInput | WalletBonusCreateManyCustomerInput[]
    skipDuplicates?: boolean
  }

  export type CommentCreateWithoutCustomerInput = {
    id?: string
    body: string
    status?: $Enums.CommentStatus
    createdAt?: Date | string
    updatedAt?: Date | string
    product: ProductCreateNestedOneWithoutCommentsInput
    replyTo?: CommentCreateNestedOneWithoutRepliesInput
    replies?: CommentCreateNestedManyWithoutReplyToInput
  }

  export type CommentUncheckedCreateWithoutCustomerInput = {
    id?: string
    productId: string
    body: string
    status?: $Enums.CommentStatus
    replyToId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    replies?: CommentUncheckedCreateNestedManyWithoutReplyToInput
  }

  export type CommentCreateOrConnectWithoutCustomerInput = {
    where: CommentWhereUniqueInput
    create: XOR<CommentCreateWithoutCustomerInput, CommentUncheckedCreateWithoutCustomerInput>
  }

  export type CommentCreateManyCustomerInputEnvelope = {
    data: CommentCreateManyCustomerInput | CommentCreateManyCustomerInput[]
    skipDuplicates?: boolean
  }

  export type PromotionCreateWithoutCustomerInput = {
    id?: string
    title: string
    description?: string | null
    scope?: $Enums.PromotionScope
    usage?: $Enums.PromotionUsage
    discountPercent: Decimal | DecimalJsLike | number | string
    isActive?: boolean
    platform?: number
    startsAt?: Date | string | null
    endsAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    product?: ProductCreateNestedOneWithoutPromotionsInput
    category?: CategoryCreateNestedOneWithoutPromotionsInput
    brand?: BrandCreateNestedOneWithoutPromotionsInput
  }

  export type PromotionUncheckedCreateWithoutCustomerInput = {
    id?: string
    title: string
    description?: string | null
    scope?: $Enums.PromotionScope
    usage?: $Enums.PromotionUsage
    discountPercent: Decimal | DecimalJsLike | number | string
    isActive?: boolean
    platform?: number
    startsAt?: Date | string | null
    endsAt?: Date | string | null
    productId?: string | null
    categoryId?: string | null
    brandId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type PromotionCreateOrConnectWithoutCustomerInput = {
    where: PromotionWhereUniqueInput
    create: XOR<PromotionCreateWithoutCustomerInput, PromotionUncheckedCreateWithoutCustomerInput>
  }

  export type PromotionCreateManyCustomerInputEnvelope = {
    data: PromotionCreateManyCustomerInput | PromotionCreateManyCustomerInput[]
    skipDuplicates?: boolean
  }

  export type NotificationRecipientCreateWithoutCustomerInput = {
    id?: string
    readAt?: Date | string | null
    notification: NotificationCreateNestedOneWithoutRecipientsInput
  }

  export type NotificationRecipientUncheckedCreateWithoutCustomerInput = {
    id?: string
    notificationId: string
    readAt?: Date | string | null
  }

  export type NotificationRecipientCreateOrConnectWithoutCustomerInput = {
    where: NotificationRecipientWhereUniqueInput
    create: XOR<NotificationRecipientCreateWithoutCustomerInput, NotificationRecipientUncheckedCreateWithoutCustomerInput>
  }

  export type NotificationRecipientCreateManyCustomerInputEnvelope = {
    data: NotificationRecipientCreateManyCustomerInput | NotificationRecipientCreateManyCustomerInput[]
    skipDuplicates?: boolean
  }

  export type CustomerActivityLogCreateWithoutCustomerInput = {
    id?: string
    action: string
    detail?: string | null
    createdAt?: Date | string
  }

  export type CustomerActivityLogUncheckedCreateWithoutCustomerInput = {
    id?: string
    action: string
    detail?: string | null
    createdAt?: Date | string
  }

  export type CustomerActivityLogCreateOrConnectWithoutCustomerInput = {
    where: CustomerActivityLogWhereUniqueInput
    create: XOR<CustomerActivityLogCreateWithoutCustomerInput, CustomerActivityLogUncheckedCreateWithoutCustomerInput>
  }

  export type CustomerActivityLogCreateManyCustomerInputEnvelope = {
    data: CustomerActivityLogCreateManyCustomerInput | CustomerActivityLogCreateManyCustomerInput[]
    skipDuplicates?: boolean
  }

  export type CustomerOtpCreateWithoutCustomerInput = {
    id?: string
    mobile: string
    codeHash: string
    expiresAt: Date | string
    attempts?: number
    consumedAt?: Date | string | null
    requestIp?: string | null
    createdAt?: Date | string
  }

  export type CustomerOtpUncheckedCreateWithoutCustomerInput = {
    id?: string
    mobile: string
    codeHash: string
    expiresAt: Date | string
    attempts?: number
    consumedAt?: Date | string | null
    requestIp?: string | null
    createdAt?: Date | string
  }

  export type CustomerOtpCreateOrConnectWithoutCustomerInput = {
    where: CustomerOtpWhereUniqueInput
    create: XOR<CustomerOtpCreateWithoutCustomerInput, CustomerOtpUncheckedCreateWithoutCustomerInput>
  }

  export type CustomerOtpCreateManyCustomerInputEnvelope = {
    data: CustomerOtpCreateManyCustomerInput | CustomerOtpCreateManyCustomerInput[]
    skipDuplicates?: boolean
  }

  export type CityUpsertWithoutCustomersInput = {
    update: XOR<CityUpdateWithoutCustomersInput, CityUncheckedUpdateWithoutCustomersInput>
    create: XOR<CityCreateWithoutCustomersInput, CityUncheckedCreateWithoutCustomersInput>
    where?: CityWhereInput
  }

  export type CityUpdateToOneWithWhereWithoutCustomersInput = {
    where?: CityWhereInput
    data: XOR<CityUpdateWithoutCustomersInput, CityUncheckedUpdateWithoutCustomersInput>
  }

  export type CityUpdateWithoutCustomersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    province?: NullableStringFieldUpdateOperationsInput | string | null
    percent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    percentAux?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    addresses?: CustomerAddressUpdateManyWithoutCityNestedInput
    branches?: BranchUpdateManyWithoutCityNestedInput
    preOrders?: PreOrderUpdateManyWithoutCityNestedInput
    salesExpertProfiles?: SalesExpertProfileUpdateManyWithoutCityNestedInput
  }

  export type CityUncheckedUpdateWithoutCustomersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    province?: NullableStringFieldUpdateOperationsInput | string | null
    percent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    percentAux?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    addresses?: CustomerAddressUncheckedUpdateManyWithoutCityNestedInput
    branches?: BranchUncheckedUpdateManyWithoutCityNestedInput
    preOrders?: PreOrderUncheckedUpdateManyWithoutCityNestedInput
    salesExpertProfiles?: SalesExpertProfileUncheckedUpdateManyWithoutCityNestedInput
  }

  export type AdminUserUpsertWithoutReferredCustomersInput = {
    update: XOR<AdminUserUpdateWithoutReferredCustomersInput, AdminUserUncheckedUpdateWithoutReferredCustomersInput>
    create: XOR<AdminUserCreateWithoutReferredCustomersInput, AdminUserUncheckedCreateWithoutReferredCustomersInput>
    where?: AdminUserWhereInput
  }

  export type AdminUserUpdateToOneWithWhereWithoutReferredCustomersInput = {
    where?: AdminUserWhereInput
    data: XOR<AdminUserUpdateWithoutReferredCustomersInput, AdminUserUncheckedUpdateWithoutReferredCustomersInput>
  }

  export type AdminUserUpdateWithoutReferredCustomersInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    userType?: UserTypeUpdateOneWithoutAdminUsersNestedInput
    branch?: BranchUpdateOneWithoutAdminUsersNestedInput
    avatarFile?: UploadedFileUpdateOneWithoutAdminUserAvatarsNestedInput
    supervisedWorkshops?: WorkshopUpdateManyWithoutSupervisorNestedInput
    branchAllocations?: BranchAllocationUpdateManyWithoutAllocatorAdminUserNestedInput
    postedLedgerEntries?: LedgerEntryUpdateManyWithoutPostedByAdminUserNestedInput
    orderStatusEvents?: OrderStatusEventUpdateManyWithoutActorAdminUserNestedInput
    preOrderStatusEvents?: PreOrderStatusEventUpdateManyWithoutActorAdminUserNestedInput
    sentSmsMessages?: SmsMessageUpdateManyWithoutSentByAdminUserNestedInput
    sentNotifications?: NotificationUpdateManyWithoutSentByAdminUserNestedInput
    uploadedFiles?: UploadedFileUpdateManyWithoutUploadedByAdminUserNestedInput
    salesExpertProfile?: SalesExpertProfileUpdateOneWithoutAdminUserNestedInput
    sessions?: AdminSessionUpdateManyWithoutAdminUserNestedInput
  }

  export type AdminUserUncheckedUpdateWithoutReferredCustomersInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    userTypeId?: NullableIntFieldUpdateOperationsInput | number | null
    branchId?: NullableStringFieldUpdateOperationsInput | string | null
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    supervisedWorkshops?: WorkshopUncheckedUpdateManyWithoutSupervisorNestedInput
    branchAllocations?: BranchAllocationUncheckedUpdateManyWithoutAllocatorAdminUserNestedInput
    postedLedgerEntries?: LedgerEntryUncheckedUpdateManyWithoutPostedByAdminUserNestedInput
    orderStatusEvents?: OrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput
    preOrderStatusEvents?: PreOrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput
    sentSmsMessages?: SmsMessageUncheckedUpdateManyWithoutSentByAdminUserNestedInput
    sentNotifications?: NotificationUncheckedUpdateManyWithoutSentByAdminUserNestedInput
    uploadedFiles?: UploadedFileUncheckedUpdateManyWithoutUploadedByAdminUserNestedInput
    salesExpertProfile?: SalesExpertProfileUncheckedUpdateOneWithoutAdminUserNestedInput
    sessions?: AdminSessionUncheckedUpdateManyWithoutAdminUserNestedInput
  }

  export type SalesExpertProfileUpsertWithoutTradingCustomerInput = {
    update: XOR<SalesExpertProfileUpdateWithoutTradingCustomerInput, SalesExpertProfileUncheckedUpdateWithoutTradingCustomerInput>
    create: XOR<SalesExpertProfileCreateWithoutTradingCustomerInput, SalesExpertProfileUncheckedCreateWithoutTradingCustomerInput>
    where?: SalesExpertProfileWhereInput
  }

  export type SalesExpertProfileUpdateToOneWithWhereWithoutTradingCustomerInput = {
    where?: SalesExpertProfileWhereInput
    data: XOR<SalesExpertProfileUpdateWithoutTradingCustomerInput, SalesExpertProfileUncheckedUpdateWithoutTradingCustomerInput>
  }

  export type SalesExpertProfileUpdateWithoutTradingCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    gramLevel?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    nationalCode?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    adminUser?: AdminUserUpdateOneRequiredWithoutSalesExpertProfileNestedInput
    city?: CityUpdateOneWithoutSalesExpertProfilesNestedInput
  }

  export type SalesExpertProfileUncheckedUpdateWithoutTradingCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    adminUserId?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    gramLevel?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    nationalCode?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UploadedFileUpsertWithoutCustomerAvatarsInput = {
    update: XOR<UploadedFileUpdateWithoutCustomerAvatarsInput, UploadedFileUncheckedUpdateWithoutCustomerAvatarsInput>
    create: XOR<UploadedFileCreateWithoutCustomerAvatarsInput, UploadedFileUncheckedCreateWithoutCustomerAvatarsInput>
    where?: UploadedFileWhereInput
  }

  export type UploadedFileUpdateToOneWithWhereWithoutCustomerAvatarsInput = {
    where?: UploadedFileWhereInput
    data: XOR<UploadedFileUpdateWithoutCustomerAvatarsInput, UploadedFileUncheckedUpdateWithoutCustomerAvatarsInput>
  }

  export type UploadedFileUpdateWithoutCustomerAvatarsInput = {
    id?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    originalName?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
    sizeBytes?: IntFieldUpdateOperationsInput | number
    purpose?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    uploadedByAdminUser?: AdminUserUpdateOneWithoutUploadedFilesNestedInput
    adminUserAvatars?: AdminUserUpdateManyWithoutAvatarFileNestedInput
  }

  export type UploadedFileUncheckedUpdateWithoutCustomerAvatarsInput = {
    id?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    originalName?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
    sizeBytes?: IntFieldUpdateOperationsInput | number
    purpose?: NullableStringFieldUpdateOperationsInput | string | null
    uploadedByAdminUserId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    adminUserAvatars?: AdminUserUncheckedUpdateManyWithoutAvatarFileNestedInput
  }

  export type CustomerAddressUpsertWithWhereUniqueWithoutCustomerInput = {
    where: CustomerAddressWhereUniqueInput
    update: XOR<CustomerAddressUpdateWithoutCustomerInput, CustomerAddressUncheckedUpdateWithoutCustomerInput>
    create: XOR<CustomerAddressCreateWithoutCustomerInput, CustomerAddressUncheckedCreateWithoutCustomerInput>
  }

  export type CustomerAddressUpdateWithWhereUniqueWithoutCustomerInput = {
    where: CustomerAddressWhereUniqueInput
    data: XOR<CustomerAddressUpdateWithoutCustomerInput, CustomerAddressUncheckedUpdateWithoutCustomerInput>
  }

  export type CustomerAddressUpdateManyWithWhereWithoutCustomerInput = {
    where: CustomerAddressScalarWhereInput
    data: XOR<CustomerAddressUpdateManyMutationInput, CustomerAddressUncheckedUpdateManyWithoutCustomerInput>
  }

  export type OrderUpsertWithWhereUniqueWithoutCustomerInput = {
    where: OrderWhereUniqueInput
    update: XOR<OrderUpdateWithoutCustomerInput, OrderUncheckedUpdateWithoutCustomerInput>
    create: XOR<OrderCreateWithoutCustomerInput, OrderUncheckedCreateWithoutCustomerInput>
  }

  export type OrderUpdateWithWhereUniqueWithoutCustomerInput = {
    where: OrderWhereUniqueInput
    data: XOR<OrderUpdateWithoutCustomerInput, OrderUncheckedUpdateWithoutCustomerInput>
  }

  export type OrderUpdateManyWithWhereWithoutCustomerInput = {
    where: OrderScalarWhereInput
    data: XOR<OrderUpdateManyMutationInput, OrderUncheckedUpdateManyWithoutCustomerInput>
  }

  export type OrderScalarWhereInput = {
    AND?: OrderScalarWhereInput | OrderScalarWhereInput[]
    OR?: OrderScalarWhereInput[]
    NOT?: OrderScalarWhereInput | OrderScalarWhereInput[]
    id?: StringFilter<"Order"> | string
    orderNumber?: StringFilter<"Order"> | string
    customerId?: StringFilter<"Order"> | string
    branchId?: StringNullableFilter<"Order"> | string | null
    channel?: EnumOrderChannelFilter<"Order"> | $Enums.OrderChannel
    status?: EnumOrderStatusFilter<"Order"> | $Enums.OrderStatus
    totalGoldWeightGrams?: DecimalFilter<"Order"> | Decimal | DecimalJsLike | number | string
    wageWeightGrams?: DecimalFilter<"Order"> | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFilter<"Order"> | Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: BoolFilter<"Order"> | boolean
    deliveredAt?: DateTimeNullableFilter<"Order"> | Date | string | null
    createdAt?: DateTimeFilter<"Order"> | Date | string
    updatedAt?: DateTimeFilter<"Order"> | Date | string
  }

  export type PreOrderUpsertWithWhereUniqueWithoutCustomerInput = {
    where: PreOrderWhereUniqueInput
    update: XOR<PreOrderUpdateWithoutCustomerInput, PreOrderUncheckedUpdateWithoutCustomerInput>
    create: XOR<PreOrderCreateWithoutCustomerInput, PreOrderUncheckedCreateWithoutCustomerInput>
  }

  export type PreOrderUpdateWithWhereUniqueWithoutCustomerInput = {
    where: PreOrderWhereUniqueInput
    data: XOR<PreOrderUpdateWithoutCustomerInput, PreOrderUncheckedUpdateWithoutCustomerInput>
  }

  export type PreOrderUpdateManyWithWhereWithoutCustomerInput = {
    where: PreOrderScalarWhereInput
    data: XOR<PreOrderUpdateManyMutationInput, PreOrderUncheckedUpdateManyWithoutCustomerInput>
  }

  export type LedgerEntryUpsertWithWhereUniqueWithoutCustomerInput = {
    where: LedgerEntryWhereUniqueInput
    update: XOR<LedgerEntryUpdateWithoutCustomerInput, LedgerEntryUncheckedUpdateWithoutCustomerInput>
    create: XOR<LedgerEntryCreateWithoutCustomerInput, LedgerEntryUncheckedCreateWithoutCustomerInput>
  }

  export type LedgerEntryUpdateWithWhereUniqueWithoutCustomerInput = {
    where: LedgerEntryWhereUniqueInput
    data: XOR<LedgerEntryUpdateWithoutCustomerInput, LedgerEntryUncheckedUpdateWithoutCustomerInput>
  }

  export type LedgerEntryUpdateManyWithWhereWithoutCustomerInput = {
    where: LedgerEntryScalarWhereInput
    data: XOR<LedgerEntryUpdateManyMutationInput, LedgerEntryUncheckedUpdateManyWithoutCustomerInput>
  }

  export type WalletBonusUpsertWithWhereUniqueWithoutCustomerInput = {
    where: WalletBonusWhereUniqueInput
    update: XOR<WalletBonusUpdateWithoutCustomerInput, WalletBonusUncheckedUpdateWithoutCustomerInput>
    create: XOR<WalletBonusCreateWithoutCustomerInput, WalletBonusUncheckedCreateWithoutCustomerInput>
  }

  export type WalletBonusUpdateWithWhereUniqueWithoutCustomerInput = {
    where: WalletBonusWhereUniqueInput
    data: XOR<WalletBonusUpdateWithoutCustomerInput, WalletBonusUncheckedUpdateWithoutCustomerInput>
  }

  export type WalletBonusUpdateManyWithWhereWithoutCustomerInput = {
    where: WalletBonusScalarWhereInput
    data: XOR<WalletBonusUpdateManyMutationInput, WalletBonusUncheckedUpdateManyWithoutCustomerInput>
  }

  export type WalletBonusScalarWhereInput = {
    AND?: WalletBonusScalarWhereInput | WalletBonusScalarWhereInput[]
    OR?: WalletBonusScalarWhereInput[]
    NOT?: WalletBonusScalarWhereInput | WalletBonusScalarWhereInput[]
    id?: StringFilter<"WalletBonus"> | string
    customerId?: StringFilter<"WalletBonus"> | string
    orderId?: StringNullableFilter<"WalletBonus"> | string | null
    goldGrams?: DecimalFilter<"WalletBonus"> | Decimal | DecimalJsLike | number | string
    grantedAt?: DateTimeFilter<"WalletBonus"> | Date | string
    expiresAt?: DateTimeFilter<"WalletBonus"> | Date | string
    consumedAt?: DateTimeNullableFilter<"WalletBonus"> | Date | string | null
    isActive?: BoolFilter<"WalletBonus"> | boolean
  }

  export type CommentUpsertWithWhereUniqueWithoutCustomerInput = {
    where: CommentWhereUniqueInput
    update: XOR<CommentUpdateWithoutCustomerInput, CommentUncheckedUpdateWithoutCustomerInput>
    create: XOR<CommentCreateWithoutCustomerInput, CommentUncheckedCreateWithoutCustomerInput>
  }

  export type CommentUpdateWithWhereUniqueWithoutCustomerInput = {
    where: CommentWhereUniqueInput
    data: XOR<CommentUpdateWithoutCustomerInput, CommentUncheckedUpdateWithoutCustomerInput>
  }

  export type CommentUpdateManyWithWhereWithoutCustomerInput = {
    where: CommentScalarWhereInput
    data: XOR<CommentUpdateManyMutationInput, CommentUncheckedUpdateManyWithoutCustomerInput>
  }

  export type CommentScalarWhereInput = {
    AND?: CommentScalarWhereInput | CommentScalarWhereInput[]
    OR?: CommentScalarWhereInput[]
    NOT?: CommentScalarWhereInput | CommentScalarWhereInput[]
    id?: StringFilter<"Comment"> | string
    productId?: StringFilter<"Comment"> | string
    customerId?: StringFilter<"Comment"> | string
    body?: StringFilter<"Comment"> | string
    status?: EnumCommentStatusFilter<"Comment"> | $Enums.CommentStatus
    replyToId?: StringNullableFilter<"Comment"> | string | null
    createdAt?: DateTimeFilter<"Comment"> | Date | string
    updatedAt?: DateTimeFilter<"Comment"> | Date | string
  }

  export type PromotionUpsertWithWhereUniqueWithoutCustomerInput = {
    where: PromotionWhereUniqueInput
    update: XOR<PromotionUpdateWithoutCustomerInput, PromotionUncheckedUpdateWithoutCustomerInput>
    create: XOR<PromotionCreateWithoutCustomerInput, PromotionUncheckedCreateWithoutCustomerInput>
  }

  export type PromotionUpdateWithWhereUniqueWithoutCustomerInput = {
    where: PromotionWhereUniqueInput
    data: XOR<PromotionUpdateWithoutCustomerInput, PromotionUncheckedUpdateWithoutCustomerInput>
  }

  export type PromotionUpdateManyWithWhereWithoutCustomerInput = {
    where: PromotionScalarWhereInput
    data: XOR<PromotionUpdateManyMutationInput, PromotionUncheckedUpdateManyWithoutCustomerInput>
  }

  export type PromotionScalarWhereInput = {
    AND?: PromotionScalarWhereInput | PromotionScalarWhereInput[]
    OR?: PromotionScalarWhereInput[]
    NOT?: PromotionScalarWhereInput | PromotionScalarWhereInput[]
    id?: StringFilter<"Promotion"> | string
    title?: StringFilter<"Promotion"> | string
    description?: StringNullableFilter<"Promotion"> | string | null
    scope?: EnumPromotionScopeFilter<"Promotion"> | $Enums.PromotionScope
    usage?: EnumPromotionUsageFilter<"Promotion"> | $Enums.PromotionUsage
    discountPercent?: DecimalFilter<"Promotion"> | Decimal | DecimalJsLike | number | string
    isActive?: BoolFilter<"Promotion"> | boolean
    platform?: IntFilter<"Promotion"> | number
    startsAt?: DateTimeNullableFilter<"Promotion"> | Date | string | null
    endsAt?: DateTimeNullableFilter<"Promotion"> | Date | string | null
    productId?: StringNullableFilter<"Promotion"> | string | null
    categoryId?: StringNullableFilter<"Promotion"> | string | null
    customerId?: StringNullableFilter<"Promotion"> | string | null
    brandId?: StringNullableFilter<"Promotion"> | string | null
    createdAt?: DateTimeFilter<"Promotion"> | Date | string
    updatedAt?: DateTimeFilter<"Promotion"> | Date | string
  }

  export type NotificationRecipientUpsertWithWhereUniqueWithoutCustomerInput = {
    where: NotificationRecipientWhereUniqueInput
    update: XOR<NotificationRecipientUpdateWithoutCustomerInput, NotificationRecipientUncheckedUpdateWithoutCustomerInput>
    create: XOR<NotificationRecipientCreateWithoutCustomerInput, NotificationRecipientUncheckedCreateWithoutCustomerInput>
  }

  export type NotificationRecipientUpdateWithWhereUniqueWithoutCustomerInput = {
    where: NotificationRecipientWhereUniqueInput
    data: XOR<NotificationRecipientUpdateWithoutCustomerInput, NotificationRecipientUncheckedUpdateWithoutCustomerInput>
  }

  export type NotificationRecipientUpdateManyWithWhereWithoutCustomerInput = {
    where: NotificationRecipientScalarWhereInput
    data: XOR<NotificationRecipientUpdateManyMutationInput, NotificationRecipientUncheckedUpdateManyWithoutCustomerInput>
  }

  export type NotificationRecipientScalarWhereInput = {
    AND?: NotificationRecipientScalarWhereInput | NotificationRecipientScalarWhereInput[]
    OR?: NotificationRecipientScalarWhereInput[]
    NOT?: NotificationRecipientScalarWhereInput | NotificationRecipientScalarWhereInput[]
    id?: StringFilter<"NotificationRecipient"> | string
    notificationId?: StringFilter<"NotificationRecipient"> | string
    customerId?: StringFilter<"NotificationRecipient"> | string
    readAt?: DateTimeNullableFilter<"NotificationRecipient"> | Date | string | null
  }

  export type CustomerActivityLogUpsertWithWhereUniqueWithoutCustomerInput = {
    where: CustomerActivityLogWhereUniqueInput
    update: XOR<CustomerActivityLogUpdateWithoutCustomerInput, CustomerActivityLogUncheckedUpdateWithoutCustomerInput>
    create: XOR<CustomerActivityLogCreateWithoutCustomerInput, CustomerActivityLogUncheckedCreateWithoutCustomerInput>
  }

  export type CustomerActivityLogUpdateWithWhereUniqueWithoutCustomerInput = {
    where: CustomerActivityLogWhereUniqueInput
    data: XOR<CustomerActivityLogUpdateWithoutCustomerInput, CustomerActivityLogUncheckedUpdateWithoutCustomerInput>
  }

  export type CustomerActivityLogUpdateManyWithWhereWithoutCustomerInput = {
    where: CustomerActivityLogScalarWhereInput
    data: XOR<CustomerActivityLogUpdateManyMutationInput, CustomerActivityLogUncheckedUpdateManyWithoutCustomerInput>
  }

  export type CustomerActivityLogScalarWhereInput = {
    AND?: CustomerActivityLogScalarWhereInput | CustomerActivityLogScalarWhereInput[]
    OR?: CustomerActivityLogScalarWhereInput[]
    NOT?: CustomerActivityLogScalarWhereInput | CustomerActivityLogScalarWhereInput[]
    id?: StringFilter<"CustomerActivityLog"> | string
    customerId?: StringFilter<"CustomerActivityLog"> | string
    action?: StringFilter<"CustomerActivityLog"> | string
    detail?: StringNullableFilter<"CustomerActivityLog"> | string | null
    createdAt?: DateTimeFilter<"CustomerActivityLog"> | Date | string
  }

  export type CustomerOtpUpsertWithWhereUniqueWithoutCustomerInput = {
    where: CustomerOtpWhereUniqueInput
    update: XOR<CustomerOtpUpdateWithoutCustomerInput, CustomerOtpUncheckedUpdateWithoutCustomerInput>
    create: XOR<CustomerOtpCreateWithoutCustomerInput, CustomerOtpUncheckedCreateWithoutCustomerInput>
  }

  export type CustomerOtpUpdateWithWhereUniqueWithoutCustomerInput = {
    where: CustomerOtpWhereUniqueInput
    data: XOR<CustomerOtpUpdateWithoutCustomerInput, CustomerOtpUncheckedUpdateWithoutCustomerInput>
  }

  export type CustomerOtpUpdateManyWithWhereWithoutCustomerInput = {
    where: CustomerOtpScalarWhereInput
    data: XOR<CustomerOtpUpdateManyMutationInput, CustomerOtpUncheckedUpdateManyWithoutCustomerInput>
  }

  export type CustomerOtpScalarWhereInput = {
    AND?: CustomerOtpScalarWhereInput | CustomerOtpScalarWhereInput[]
    OR?: CustomerOtpScalarWhereInput[]
    NOT?: CustomerOtpScalarWhereInput | CustomerOtpScalarWhereInput[]
    id?: StringFilter<"CustomerOtp"> | string
    mobile?: StringFilter<"CustomerOtp"> | string
    customerId?: StringFilter<"CustomerOtp"> | string
    codeHash?: StringFilter<"CustomerOtp"> | string
    expiresAt?: DateTimeFilter<"CustomerOtp"> | Date | string
    attempts?: IntFilter<"CustomerOtp"> | number
    consumedAt?: DateTimeNullableFilter<"CustomerOtp"> | Date | string | null
    requestIp?: StringNullableFilter<"CustomerOtp"> | string | null
    createdAt?: DateTimeFilter<"CustomerOtp"> | Date | string
  }

  export type CustomerCreateWithoutAddressesInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    city?: CityCreateNestedOneWithoutCustomersInput
    referredByAgent?: AdminUserCreateNestedOneWithoutReferredCustomersInput
    salesExpertTradingFor?: SalesExpertProfileCreateNestedOneWithoutTradingCustomerInput
    avatarFile?: UploadedFileCreateNestedOneWithoutCustomerAvatarsInput
    orders?: OrderCreateNestedManyWithoutCustomerInput
    preOrders?: PreOrderCreateNestedManyWithoutCustomerInput
    ledgerEntries?: LedgerEntryCreateNestedManyWithoutCustomerInput
    walletBonuses?: WalletBonusCreateNestedManyWithoutCustomerInput
    comments?: CommentCreateNestedManyWithoutCustomerInput
    promotions?: PromotionCreateNestedManyWithoutCustomerInput
    notifications?: NotificationRecipientCreateNestedManyWithoutCustomerInput
    activityLogs?: CustomerActivityLogCreateNestedManyWithoutCustomerInput
    otpChallenges?: CustomerOtpCreateNestedManyWithoutCustomerInput
  }

  export type CustomerUncheckedCreateWithoutAddressesInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    cityId?: string | null
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    referredByAgentId?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    avatarFileId?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    salesExpertTradingFor?: SalesExpertProfileUncheckedCreateNestedOneWithoutTradingCustomerInput
    orders?: OrderUncheckedCreateNestedManyWithoutCustomerInput
    preOrders?: PreOrderUncheckedCreateNestedManyWithoutCustomerInput
    ledgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutCustomerInput
    walletBonuses?: WalletBonusUncheckedCreateNestedManyWithoutCustomerInput
    comments?: CommentUncheckedCreateNestedManyWithoutCustomerInput
    promotions?: PromotionUncheckedCreateNestedManyWithoutCustomerInput
    notifications?: NotificationRecipientUncheckedCreateNestedManyWithoutCustomerInput
    activityLogs?: CustomerActivityLogUncheckedCreateNestedManyWithoutCustomerInput
    otpChallenges?: CustomerOtpUncheckedCreateNestedManyWithoutCustomerInput
  }

  export type CustomerCreateOrConnectWithoutAddressesInput = {
    where: CustomerWhereUniqueInput
    create: XOR<CustomerCreateWithoutAddressesInput, CustomerUncheckedCreateWithoutAddressesInput>
  }

  export type CityCreateWithoutAddressesInput = {
    id?: string
    name: string
    province?: string | null
    percent?: Decimal | DecimalJsLike | number | string | null
    percentAux?: Decimal | DecimalJsLike | number | string | null
    customers?: CustomerCreateNestedManyWithoutCityInput
    branches?: BranchCreateNestedManyWithoutCityInput
    preOrders?: PreOrderCreateNestedManyWithoutCityInput
    salesExpertProfiles?: SalesExpertProfileCreateNestedManyWithoutCityInput
  }

  export type CityUncheckedCreateWithoutAddressesInput = {
    id?: string
    name: string
    province?: string | null
    percent?: Decimal | DecimalJsLike | number | string | null
    percentAux?: Decimal | DecimalJsLike | number | string | null
    customers?: CustomerUncheckedCreateNestedManyWithoutCityInput
    branches?: BranchUncheckedCreateNestedManyWithoutCityInput
    preOrders?: PreOrderUncheckedCreateNestedManyWithoutCityInput
    salesExpertProfiles?: SalesExpertProfileUncheckedCreateNestedManyWithoutCityInput
  }

  export type CityCreateOrConnectWithoutAddressesInput = {
    where: CityWhereUniqueInput
    create: XOR<CityCreateWithoutAddressesInput, CityUncheckedCreateWithoutAddressesInput>
  }

  export type CustomerUpsertWithoutAddressesInput = {
    update: XOR<CustomerUpdateWithoutAddressesInput, CustomerUncheckedUpdateWithoutAddressesInput>
    create: XOR<CustomerCreateWithoutAddressesInput, CustomerUncheckedCreateWithoutAddressesInput>
    where?: CustomerWhereInput
  }

  export type CustomerUpdateToOneWithWhereWithoutAddressesInput = {
    where?: CustomerWhereInput
    data: XOR<CustomerUpdateWithoutAddressesInput, CustomerUncheckedUpdateWithoutAddressesInput>
  }

  export type CustomerUpdateWithoutAddressesInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutCustomersNestedInput
    referredByAgent?: AdminUserUpdateOneWithoutReferredCustomersNestedInput
    salesExpertTradingFor?: SalesExpertProfileUpdateOneWithoutTradingCustomerNestedInput
    avatarFile?: UploadedFileUpdateOneWithoutCustomerAvatarsNestedInput
    orders?: OrderUpdateManyWithoutCustomerNestedInput
    preOrders?: PreOrderUpdateManyWithoutCustomerNestedInput
    ledgerEntries?: LedgerEntryUpdateManyWithoutCustomerNestedInput
    walletBonuses?: WalletBonusUpdateManyWithoutCustomerNestedInput
    comments?: CommentUpdateManyWithoutCustomerNestedInput
    promotions?: PromotionUpdateManyWithoutCustomerNestedInput
    notifications?: NotificationRecipientUpdateManyWithoutCustomerNestedInput
    activityLogs?: CustomerActivityLogUpdateManyWithoutCustomerNestedInput
    otpChallenges?: CustomerOtpUpdateManyWithoutCustomerNestedInput
  }

  export type CustomerUncheckedUpdateWithoutAddressesInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredByAgentId?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    salesExpertTradingFor?: SalesExpertProfileUncheckedUpdateOneWithoutTradingCustomerNestedInput
    orders?: OrderUncheckedUpdateManyWithoutCustomerNestedInput
    preOrders?: PreOrderUncheckedUpdateManyWithoutCustomerNestedInput
    ledgerEntries?: LedgerEntryUncheckedUpdateManyWithoutCustomerNestedInput
    walletBonuses?: WalletBonusUncheckedUpdateManyWithoutCustomerNestedInput
    comments?: CommentUncheckedUpdateManyWithoutCustomerNestedInput
    promotions?: PromotionUncheckedUpdateManyWithoutCustomerNestedInput
    notifications?: NotificationRecipientUncheckedUpdateManyWithoutCustomerNestedInput
    activityLogs?: CustomerActivityLogUncheckedUpdateManyWithoutCustomerNestedInput
    otpChallenges?: CustomerOtpUncheckedUpdateManyWithoutCustomerNestedInput
  }

  export type CityUpsertWithoutAddressesInput = {
    update: XOR<CityUpdateWithoutAddressesInput, CityUncheckedUpdateWithoutAddressesInput>
    create: XOR<CityCreateWithoutAddressesInput, CityUncheckedCreateWithoutAddressesInput>
    where?: CityWhereInput
  }

  export type CityUpdateToOneWithWhereWithoutAddressesInput = {
    where?: CityWhereInput
    data: XOR<CityUpdateWithoutAddressesInput, CityUncheckedUpdateWithoutAddressesInput>
  }

  export type CityUpdateWithoutAddressesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    province?: NullableStringFieldUpdateOperationsInput | string | null
    percent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    percentAux?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    customers?: CustomerUpdateManyWithoutCityNestedInput
    branches?: BranchUpdateManyWithoutCityNestedInput
    preOrders?: PreOrderUpdateManyWithoutCityNestedInput
    salesExpertProfiles?: SalesExpertProfileUpdateManyWithoutCityNestedInput
  }

  export type CityUncheckedUpdateWithoutAddressesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    province?: NullableStringFieldUpdateOperationsInput | string | null
    percent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    percentAux?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    customers?: CustomerUncheckedUpdateManyWithoutCityNestedInput
    branches?: BranchUncheckedUpdateManyWithoutCityNestedInput
    preOrders?: PreOrderUncheckedUpdateManyWithoutCityNestedInput
    salesExpertProfiles?: SalesExpertProfileUncheckedUpdateManyWithoutCityNestedInput
  }

  export type CityCreateWithoutBranchesInput = {
    id?: string
    name: string
    province?: string | null
    percent?: Decimal | DecimalJsLike | number | string | null
    percentAux?: Decimal | DecimalJsLike | number | string | null
    customers?: CustomerCreateNestedManyWithoutCityInput
    addresses?: CustomerAddressCreateNestedManyWithoutCityInput
    preOrders?: PreOrderCreateNestedManyWithoutCityInput
    salesExpertProfiles?: SalesExpertProfileCreateNestedManyWithoutCityInput
  }

  export type CityUncheckedCreateWithoutBranchesInput = {
    id?: string
    name: string
    province?: string | null
    percent?: Decimal | DecimalJsLike | number | string | null
    percentAux?: Decimal | DecimalJsLike | number | string | null
    customers?: CustomerUncheckedCreateNestedManyWithoutCityInput
    addresses?: CustomerAddressUncheckedCreateNestedManyWithoutCityInput
    preOrders?: PreOrderUncheckedCreateNestedManyWithoutCityInput
    salesExpertProfiles?: SalesExpertProfileUncheckedCreateNestedManyWithoutCityInput
  }

  export type CityCreateOrConnectWithoutBranchesInput = {
    where: CityWhereUniqueInput
    create: XOR<CityCreateWithoutBranchesInput, CityUncheckedCreateWithoutBranchesInput>
  }

  export type AdminUserCreateWithoutBranchInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    userType?: UserTypeCreateNestedOneWithoutAdminUsersInput
    avatarFile?: UploadedFileCreateNestedOneWithoutAdminUserAvatarsInput
    referredCustomers?: CustomerCreateNestedManyWithoutReferredByAgentInput
    supervisedWorkshops?: WorkshopCreateNestedManyWithoutSupervisorInput
    branchAllocations?: BranchAllocationCreateNestedManyWithoutAllocatorAdminUserInput
    postedLedgerEntries?: LedgerEntryCreateNestedManyWithoutPostedByAdminUserInput
    orderStatusEvents?: OrderStatusEventCreateNestedManyWithoutActorAdminUserInput
    preOrderStatusEvents?: PreOrderStatusEventCreateNestedManyWithoutActorAdminUserInput
    sentSmsMessages?: SmsMessageCreateNestedManyWithoutSentByAdminUserInput
    sentNotifications?: NotificationCreateNestedManyWithoutSentByAdminUserInput
    uploadedFiles?: UploadedFileCreateNestedManyWithoutUploadedByAdminUserInput
    salesExpertProfile?: SalesExpertProfileCreateNestedOneWithoutAdminUserInput
    sessions?: AdminSessionCreateNestedManyWithoutAdminUserInput
  }

  export type AdminUserUncheckedCreateWithoutBranchInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    userTypeId?: number | null
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    avatarFileId?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    referredCustomers?: CustomerUncheckedCreateNestedManyWithoutReferredByAgentInput
    supervisedWorkshops?: WorkshopUncheckedCreateNestedManyWithoutSupervisorInput
    branchAllocations?: BranchAllocationUncheckedCreateNestedManyWithoutAllocatorAdminUserInput
    postedLedgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutPostedByAdminUserInput
    orderStatusEvents?: OrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput
    preOrderStatusEvents?: PreOrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput
    sentSmsMessages?: SmsMessageUncheckedCreateNestedManyWithoutSentByAdminUserInput
    sentNotifications?: NotificationUncheckedCreateNestedManyWithoutSentByAdminUserInput
    uploadedFiles?: UploadedFileUncheckedCreateNestedManyWithoutUploadedByAdminUserInput
    salesExpertProfile?: SalesExpertProfileUncheckedCreateNestedOneWithoutAdminUserInput
    sessions?: AdminSessionUncheckedCreateNestedManyWithoutAdminUserInput
  }

  export type AdminUserCreateOrConnectWithoutBranchInput = {
    where: AdminUserWhereUniqueInput
    create: XOR<AdminUserCreateWithoutBranchInput, AdminUserUncheckedCreateWithoutBranchInput>
  }

  export type AdminUserCreateManyBranchInputEnvelope = {
    data: AdminUserCreateManyBranchInput | AdminUserCreateManyBranchInput[]
    skipDuplicates?: boolean
  }

  export type OrderCreateWithoutBranchInput = {
    id?: string
    orderNumber: string
    channel?: $Enums.OrderChannel
    status?: $Enums.OrderStatus
    totalGoldWeightGrams: Decimal | DecimalJsLike | number | string
    wageWeightGrams: Decimal | DecimalJsLike | number | string
    flatRialCharge?: Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: boolean
    deliveredAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    customer: CustomerCreateNestedOneWithoutOrdersInput
    items?: OrderItemCreateNestedManyWithoutOrderInput
    statusEvents?: OrderStatusEventCreateNestedManyWithoutOrderInput
    ledgerEntries?: LedgerEntryCreateNestedManyWithoutOrderInput
    convertedFromPreOrder?: PreOrderCreateNestedOneWithoutConvertedOrderInput
  }

  export type OrderUncheckedCreateWithoutBranchInput = {
    id?: string
    orderNumber: string
    customerId: string
    channel?: $Enums.OrderChannel
    status?: $Enums.OrderStatus
    totalGoldWeightGrams: Decimal | DecimalJsLike | number | string
    wageWeightGrams: Decimal | DecimalJsLike | number | string
    flatRialCharge?: Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: boolean
    deliveredAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    items?: OrderItemUncheckedCreateNestedManyWithoutOrderInput
    statusEvents?: OrderStatusEventUncheckedCreateNestedManyWithoutOrderInput
    ledgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutOrderInput
    convertedFromPreOrder?: PreOrderUncheckedCreateNestedOneWithoutConvertedOrderInput
  }

  export type OrderCreateOrConnectWithoutBranchInput = {
    where: OrderWhereUniqueInput
    create: XOR<OrderCreateWithoutBranchInput, OrderUncheckedCreateWithoutBranchInput>
  }

  export type OrderCreateManyBranchInputEnvelope = {
    data: OrderCreateManyBranchInput | OrderCreateManyBranchInput[]
    skipDuplicates?: boolean
  }

  export type BranchAllocationCreateWithoutBranchInput = {
    id?: string
    note?: string | null
    createdAt?: Date | string
    allocatorAdminUser?: AdminUserCreateNestedOneWithoutBranchAllocationsInput
    items?: BranchAllocationItemCreateNestedManyWithoutAllocationInput
  }

  export type BranchAllocationUncheckedCreateWithoutBranchInput = {
    id?: string
    allocatorAdminUserId?: string | null
    note?: string | null
    createdAt?: Date | string
    items?: BranchAllocationItemUncheckedCreateNestedManyWithoutAllocationInput
  }

  export type BranchAllocationCreateOrConnectWithoutBranchInput = {
    where: BranchAllocationWhereUniqueInput
    create: XOR<BranchAllocationCreateWithoutBranchInput, BranchAllocationUncheckedCreateWithoutBranchInput>
  }

  export type BranchAllocationCreateManyBranchInputEnvelope = {
    data: BranchAllocationCreateManyBranchInput | BranchAllocationCreateManyBranchInput[]
    skipDuplicates?: boolean
  }

  export type CityUpsertWithoutBranchesInput = {
    update: XOR<CityUpdateWithoutBranchesInput, CityUncheckedUpdateWithoutBranchesInput>
    create: XOR<CityCreateWithoutBranchesInput, CityUncheckedCreateWithoutBranchesInput>
    where?: CityWhereInput
  }

  export type CityUpdateToOneWithWhereWithoutBranchesInput = {
    where?: CityWhereInput
    data: XOR<CityUpdateWithoutBranchesInput, CityUncheckedUpdateWithoutBranchesInput>
  }

  export type CityUpdateWithoutBranchesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    province?: NullableStringFieldUpdateOperationsInput | string | null
    percent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    percentAux?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    customers?: CustomerUpdateManyWithoutCityNestedInput
    addresses?: CustomerAddressUpdateManyWithoutCityNestedInput
    preOrders?: PreOrderUpdateManyWithoutCityNestedInput
    salesExpertProfiles?: SalesExpertProfileUpdateManyWithoutCityNestedInput
  }

  export type CityUncheckedUpdateWithoutBranchesInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    province?: NullableStringFieldUpdateOperationsInput | string | null
    percent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    percentAux?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    customers?: CustomerUncheckedUpdateManyWithoutCityNestedInput
    addresses?: CustomerAddressUncheckedUpdateManyWithoutCityNestedInput
    preOrders?: PreOrderUncheckedUpdateManyWithoutCityNestedInput
    salesExpertProfiles?: SalesExpertProfileUncheckedUpdateManyWithoutCityNestedInput
  }

  export type AdminUserUpsertWithWhereUniqueWithoutBranchInput = {
    where: AdminUserWhereUniqueInput
    update: XOR<AdminUserUpdateWithoutBranchInput, AdminUserUncheckedUpdateWithoutBranchInput>
    create: XOR<AdminUserCreateWithoutBranchInput, AdminUserUncheckedCreateWithoutBranchInput>
  }

  export type AdminUserUpdateWithWhereUniqueWithoutBranchInput = {
    where: AdminUserWhereUniqueInput
    data: XOR<AdminUserUpdateWithoutBranchInput, AdminUserUncheckedUpdateWithoutBranchInput>
  }

  export type AdminUserUpdateManyWithWhereWithoutBranchInput = {
    where: AdminUserScalarWhereInput
    data: XOR<AdminUserUpdateManyMutationInput, AdminUserUncheckedUpdateManyWithoutBranchInput>
  }

  export type AdminUserScalarWhereInput = {
    AND?: AdminUserScalarWhereInput | AdminUserScalarWhereInput[]
    OR?: AdminUserScalarWhereInput[]
    NOT?: AdminUserScalarWhereInput | AdminUserScalarWhereInput[]
    id?: StringFilter<"AdminUser"> | string
    fullName?: StringFilter<"AdminUser"> | string
    firstName?: StringNullableFilter<"AdminUser"> | string | null
    lastName?: StringNullableFilter<"AdminUser"> | string | null
    mobile?: StringFilter<"AdminUser"> | string
    passwordHash?: StringFilter<"AdminUser"> | string
    role?: EnumAdminRoleFilter<"AdminUser"> | $Enums.AdminRole
    userTypeId?: IntNullableFilter<"AdminUser"> | number | null
    branchId?: StringNullableFilter<"AdminUser"> | string | null
    wagePercent?: DecimalNullableFilter<"AdminUser"> | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFilter<"AdminUser"> | boolean
    createdAt?: DateTimeFilter<"AdminUser"> | Date | string
    avatarFileId?: StringNullableFilter<"AdminUser"> | string | null
    address?: StringNullableFilter<"AdminUser"> | string | null
    storeName?: StringNullableFilter<"AdminUser"> | string | null
    pasazhName?: StringNullableFilter<"AdminUser"> | string | null
    memberCode?: StringNullableFilter<"AdminUser"> | string | null
  }

  export type OrderUpsertWithWhereUniqueWithoutBranchInput = {
    where: OrderWhereUniqueInput
    update: XOR<OrderUpdateWithoutBranchInput, OrderUncheckedUpdateWithoutBranchInput>
    create: XOR<OrderCreateWithoutBranchInput, OrderUncheckedCreateWithoutBranchInput>
  }

  export type OrderUpdateWithWhereUniqueWithoutBranchInput = {
    where: OrderWhereUniqueInput
    data: XOR<OrderUpdateWithoutBranchInput, OrderUncheckedUpdateWithoutBranchInput>
  }

  export type OrderUpdateManyWithWhereWithoutBranchInput = {
    where: OrderScalarWhereInput
    data: XOR<OrderUpdateManyMutationInput, OrderUncheckedUpdateManyWithoutBranchInput>
  }

  export type BranchAllocationUpsertWithWhereUniqueWithoutBranchInput = {
    where: BranchAllocationWhereUniqueInput
    update: XOR<BranchAllocationUpdateWithoutBranchInput, BranchAllocationUncheckedUpdateWithoutBranchInput>
    create: XOR<BranchAllocationCreateWithoutBranchInput, BranchAllocationUncheckedCreateWithoutBranchInput>
  }

  export type BranchAllocationUpdateWithWhereUniqueWithoutBranchInput = {
    where: BranchAllocationWhereUniqueInput
    data: XOR<BranchAllocationUpdateWithoutBranchInput, BranchAllocationUncheckedUpdateWithoutBranchInput>
  }

  export type BranchAllocationUpdateManyWithWhereWithoutBranchInput = {
    where: BranchAllocationScalarWhereInput
    data: XOR<BranchAllocationUpdateManyMutationInput, BranchAllocationUncheckedUpdateManyWithoutBranchInput>
  }

  export type AdminUserCreateWithoutSupervisedWorkshopsInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    userType?: UserTypeCreateNestedOneWithoutAdminUsersInput
    branch?: BranchCreateNestedOneWithoutAdminUsersInput
    avatarFile?: UploadedFileCreateNestedOneWithoutAdminUserAvatarsInput
    referredCustomers?: CustomerCreateNestedManyWithoutReferredByAgentInput
    branchAllocations?: BranchAllocationCreateNestedManyWithoutAllocatorAdminUserInput
    postedLedgerEntries?: LedgerEntryCreateNestedManyWithoutPostedByAdminUserInput
    orderStatusEvents?: OrderStatusEventCreateNestedManyWithoutActorAdminUserInput
    preOrderStatusEvents?: PreOrderStatusEventCreateNestedManyWithoutActorAdminUserInput
    sentSmsMessages?: SmsMessageCreateNestedManyWithoutSentByAdminUserInput
    sentNotifications?: NotificationCreateNestedManyWithoutSentByAdminUserInput
    uploadedFiles?: UploadedFileCreateNestedManyWithoutUploadedByAdminUserInput
    salesExpertProfile?: SalesExpertProfileCreateNestedOneWithoutAdminUserInput
    sessions?: AdminSessionCreateNestedManyWithoutAdminUserInput
  }

  export type AdminUserUncheckedCreateWithoutSupervisedWorkshopsInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    userTypeId?: number | null
    branchId?: string | null
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    avatarFileId?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    referredCustomers?: CustomerUncheckedCreateNestedManyWithoutReferredByAgentInput
    branchAllocations?: BranchAllocationUncheckedCreateNestedManyWithoutAllocatorAdminUserInput
    postedLedgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutPostedByAdminUserInput
    orderStatusEvents?: OrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput
    preOrderStatusEvents?: PreOrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput
    sentSmsMessages?: SmsMessageUncheckedCreateNestedManyWithoutSentByAdminUserInput
    sentNotifications?: NotificationUncheckedCreateNestedManyWithoutSentByAdminUserInput
    uploadedFiles?: UploadedFileUncheckedCreateNestedManyWithoutUploadedByAdminUserInput
    salesExpertProfile?: SalesExpertProfileUncheckedCreateNestedOneWithoutAdminUserInput
    sessions?: AdminSessionUncheckedCreateNestedManyWithoutAdminUserInput
  }

  export type AdminUserCreateOrConnectWithoutSupervisedWorkshopsInput = {
    where: AdminUserWhereUniqueInput
    create: XOR<AdminUserCreateWithoutSupervisedWorkshopsInput, AdminUserUncheckedCreateWithoutSupervisedWorkshopsInput>
  }

  export type PreOrderCreateWithoutWorkshopInput = {
    id?: string
    status?: $Enums.PreOrderStatus
    designImageUrl?: string | null
    colorName?: string | null
    sizeSpec?: string | null
    stoneColor?: string | null
    minaColor?: string | null
    estimatedWeightGrams?: Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: Decimal | DecimalJsLike | number | string | null
    description?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    customer: CustomerCreateNestedOneWithoutPreOrdersInput
    city?: CityCreateNestedOneWithoutPreOrdersInput
    convertedOrder?: OrderCreateNestedOneWithoutConvertedFromPreOrderInput
    statusEvents?: PreOrderStatusEventCreateNestedManyWithoutPreOrderInput
  }

  export type PreOrderUncheckedCreateWithoutWorkshopInput = {
    id?: string
    customerId: string
    cityId?: string | null
    status?: $Enums.PreOrderStatus
    designImageUrl?: string | null
    colorName?: string | null
    sizeSpec?: string | null
    stoneColor?: string | null
    minaColor?: string | null
    estimatedWeightGrams?: Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: Decimal | DecimalJsLike | number | string | null
    description?: string | null
    convertedOrderId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    statusEvents?: PreOrderStatusEventUncheckedCreateNestedManyWithoutPreOrderInput
  }

  export type PreOrderCreateOrConnectWithoutWorkshopInput = {
    where: PreOrderWhereUniqueInput
    create: XOR<PreOrderCreateWithoutWorkshopInput, PreOrderUncheckedCreateWithoutWorkshopInput>
  }

  export type PreOrderCreateManyWorkshopInputEnvelope = {
    data: PreOrderCreateManyWorkshopInput | PreOrderCreateManyWorkshopInput[]
    skipDuplicates?: boolean
  }

  export type AdminUserUpsertWithoutSupervisedWorkshopsInput = {
    update: XOR<AdminUserUpdateWithoutSupervisedWorkshopsInput, AdminUserUncheckedUpdateWithoutSupervisedWorkshopsInput>
    create: XOR<AdminUserCreateWithoutSupervisedWorkshopsInput, AdminUserUncheckedCreateWithoutSupervisedWorkshopsInput>
    where?: AdminUserWhereInput
  }

  export type AdminUserUpdateToOneWithWhereWithoutSupervisedWorkshopsInput = {
    where?: AdminUserWhereInput
    data: XOR<AdminUserUpdateWithoutSupervisedWorkshopsInput, AdminUserUncheckedUpdateWithoutSupervisedWorkshopsInput>
  }

  export type AdminUserUpdateWithoutSupervisedWorkshopsInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    userType?: UserTypeUpdateOneWithoutAdminUsersNestedInput
    branch?: BranchUpdateOneWithoutAdminUsersNestedInput
    avatarFile?: UploadedFileUpdateOneWithoutAdminUserAvatarsNestedInput
    referredCustomers?: CustomerUpdateManyWithoutReferredByAgentNestedInput
    branchAllocations?: BranchAllocationUpdateManyWithoutAllocatorAdminUserNestedInput
    postedLedgerEntries?: LedgerEntryUpdateManyWithoutPostedByAdminUserNestedInput
    orderStatusEvents?: OrderStatusEventUpdateManyWithoutActorAdminUserNestedInput
    preOrderStatusEvents?: PreOrderStatusEventUpdateManyWithoutActorAdminUserNestedInput
    sentSmsMessages?: SmsMessageUpdateManyWithoutSentByAdminUserNestedInput
    sentNotifications?: NotificationUpdateManyWithoutSentByAdminUserNestedInput
    uploadedFiles?: UploadedFileUpdateManyWithoutUploadedByAdminUserNestedInput
    salesExpertProfile?: SalesExpertProfileUpdateOneWithoutAdminUserNestedInput
    sessions?: AdminSessionUpdateManyWithoutAdminUserNestedInput
  }

  export type AdminUserUncheckedUpdateWithoutSupervisedWorkshopsInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    userTypeId?: NullableIntFieldUpdateOperationsInput | number | null
    branchId?: NullableStringFieldUpdateOperationsInput | string | null
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredCustomers?: CustomerUncheckedUpdateManyWithoutReferredByAgentNestedInput
    branchAllocations?: BranchAllocationUncheckedUpdateManyWithoutAllocatorAdminUserNestedInput
    postedLedgerEntries?: LedgerEntryUncheckedUpdateManyWithoutPostedByAdminUserNestedInput
    orderStatusEvents?: OrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput
    preOrderStatusEvents?: PreOrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput
    sentSmsMessages?: SmsMessageUncheckedUpdateManyWithoutSentByAdminUserNestedInput
    sentNotifications?: NotificationUncheckedUpdateManyWithoutSentByAdminUserNestedInput
    uploadedFiles?: UploadedFileUncheckedUpdateManyWithoutUploadedByAdminUserNestedInput
    salesExpertProfile?: SalesExpertProfileUncheckedUpdateOneWithoutAdminUserNestedInput
    sessions?: AdminSessionUncheckedUpdateManyWithoutAdminUserNestedInput
  }

  export type PreOrderUpsertWithWhereUniqueWithoutWorkshopInput = {
    where: PreOrderWhereUniqueInput
    update: XOR<PreOrderUpdateWithoutWorkshopInput, PreOrderUncheckedUpdateWithoutWorkshopInput>
    create: XOR<PreOrderCreateWithoutWorkshopInput, PreOrderUncheckedCreateWithoutWorkshopInput>
  }

  export type PreOrderUpdateWithWhereUniqueWithoutWorkshopInput = {
    where: PreOrderWhereUniqueInput
    data: XOR<PreOrderUpdateWithoutWorkshopInput, PreOrderUncheckedUpdateWithoutWorkshopInput>
  }

  export type PreOrderUpdateManyWithWhereWithoutWorkshopInput = {
    where: PreOrderScalarWhereInput
    data: XOR<PreOrderUpdateManyMutationInput, PreOrderUncheckedUpdateManyWithoutWorkshopInput>
  }

  export type CategoryCreateWithoutChildrenInput = {
    id?: string
    title: string
    type?: number
    imageUrl?: string | null
    iconUrl?: string | null
    metaTag?: string | null
    description?: string | null
    parent?: CategoryCreateNestedOneWithoutChildrenInput
    products?: ProductCreateNestedManyWithoutCategoryInput
    promotions?: PromotionCreateNestedManyWithoutCategoryInput
  }

  export type CategoryUncheckedCreateWithoutChildrenInput = {
    id?: string
    title: string
    type?: number
    imageUrl?: string | null
    iconUrl?: string | null
    metaTag?: string | null
    description?: string | null
    parentId?: string | null
    products?: ProductUncheckedCreateNestedManyWithoutCategoryInput
    promotions?: PromotionUncheckedCreateNestedManyWithoutCategoryInput
  }

  export type CategoryCreateOrConnectWithoutChildrenInput = {
    where: CategoryWhereUniqueInput
    create: XOR<CategoryCreateWithoutChildrenInput, CategoryUncheckedCreateWithoutChildrenInput>
  }

  export type CategoryCreateWithoutParentInput = {
    id?: string
    title: string
    type?: number
    imageUrl?: string | null
    iconUrl?: string | null
    metaTag?: string | null
    description?: string | null
    children?: CategoryCreateNestedManyWithoutParentInput
    products?: ProductCreateNestedManyWithoutCategoryInput
    promotions?: PromotionCreateNestedManyWithoutCategoryInput
  }

  export type CategoryUncheckedCreateWithoutParentInput = {
    id?: string
    title: string
    type?: number
    imageUrl?: string | null
    iconUrl?: string | null
    metaTag?: string | null
    description?: string | null
    children?: CategoryUncheckedCreateNestedManyWithoutParentInput
    products?: ProductUncheckedCreateNestedManyWithoutCategoryInput
    promotions?: PromotionUncheckedCreateNestedManyWithoutCategoryInput
  }

  export type CategoryCreateOrConnectWithoutParentInput = {
    where: CategoryWhereUniqueInput
    create: XOR<CategoryCreateWithoutParentInput, CategoryUncheckedCreateWithoutParentInput>
  }

  export type CategoryCreateManyParentInputEnvelope = {
    data: CategoryCreateManyParentInput | CategoryCreateManyParentInput[]
    skipDuplicates?: boolean
  }

  export type ProductCreateWithoutCategoryInput = {
    id?: string
    title: string
    description?: string | null
    productCode?: string | null
    showType?: number
    isActive?: boolean
    createdAt?: Date | string
    brand?: BrandCreateNestedOneWithoutProductsInput
    variants?: ProductVariantCreateNestedManyWithoutProductInput
    images?: ProductImageCreateNestedManyWithoutProductInput
    collections?: CollectionProductCreateNestedManyWithoutProductInput
    comments?: CommentCreateNestedManyWithoutProductInput
    promotions?: PromotionCreateNestedManyWithoutProductInput
    allocationItems?: BranchAllocationItemCreateNestedManyWithoutProductInput
  }

  export type ProductUncheckedCreateWithoutCategoryInput = {
    id?: string
    title: string
    description?: string | null
    brandId?: string | null
    productCode?: string | null
    showType?: number
    isActive?: boolean
    createdAt?: Date | string
    variants?: ProductVariantUncheckedCreateNestedManyWithoutProductInput
    images?: ProductImageUncheckedCreateNestedManyWithoutProductInput
    collections?: CollectionProductUncheckedCreateNestedManyWithoutProductInput
    comments?: CommentUncheckedCreateNestedManyWithoutProductInput
    promotions?: PromotionUncheckedCreateNestedManyWithoutProductInput
    allocationItems?: BranchAllocationItemUncheckedCreateNestedManyWithoutProductInput
  }

  export type ProductCreateOrConnectWithoutCategoryInput = {
    where: ProductWhereUniqueInput
    create: XOR<ProductCreateWithoutCategoryInput, ProductUncheckedCreateWithoutCategoryInput>
  }

  export type ProductCreateManyCategoryInputEnvelope = {
    data: ProductCreateManyCategoryInput | ProductCreateManyCategoryInput[]
    skipDuplicates?: boolean
  }

  export type PromotionCreateWithoutCategoryInput = {
    id?: string
    title: string
    description?: string | null
    scope?: $Enums.PromotionScope
    usage?: $Enums.PromotionUsage
    discountPercent: Decimal | DecimalJsLike | number | string
    isActive?: boolean
    platform?: number
    startsAt?: Date | string | null
    endsAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    product?: ProductCreateNestedOneWithoutPromotionsInput
    customer?: CustomerCreateNestedOneWithoutPromotionsInput
    brand?: BrandCreateNestedOneWithoutPromotionsInput
  }

  export type PromotionUncheckedCreateWithoutCategoryInput = {
    id?: string
    title: string
    description?: string | null
    scope?: $Enums.PromotionScope
    usage?: $Enums.PromotionUsage
    discountPercent: Decimal | DecimalJsLike | number | string
    isActive?: boolean
    platform?: number
    startsAt?: Date | string | null
    endsAt?: Date | string | null
    productId?: string | null
    customerId?: string | null
    brandId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type PromotionCreateOrConnectWithoutCategoryInput = {
    where: PromotionWhereUniqueInput
    create: XOR<PromotionCreateWithoutCategoryInput, PromotionUncheckedCreateWithoutCategoryInput>
  }

  export type PromotionCreateManyCategoryInputEnvelope = {
    data: PromotionCreateManyCategoryInput | PromotionCreateManyCategoryInput[]
    skipDuplicates?: boolean
  }

  export type CategoryUpsertWithoutChildrenInput = {
    update: XOR<CategoryUpdateWithoutChildrenInput, CategoryUncheckedUpdateWithoutChildrenInput>
    create: XOR<CategoryCreateWithoutChildrenInput, CategoryUncheckedCreateWithoutChildrenInput>
    where?: CategoryWhereInput
  }

  export type CategoryUpdateToOneWithWhereWithoutChildrenInput = {
    where?: CategoryWhereInput
    data: XOR<CategoryUpdateWithoutChildrenInput, CategoryUncheckedUpdateWithoutChildrenInput>
  }

  export type CategoryUpdateWithoutChildrenInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    type?: IntFieldUpdateOperationsInput | number
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    iconUrl?: NullableStringFieldUpdateOperationsInput | string | null
    metaTag?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    parent?: CategoryUpdateOneWithoutChildrenNestedInput
    products?: ProductUpdateManyWithoutCategoryNestedInput
    promotions?: PromotionUpdateManyWithoutCategoryNestedInput
  }

  export type CategoryUncheckedUpdateWithoutChildrenInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    type?: IntFieldUpdateOperationsInput | number
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    iconUrl?: NullableStringFieldUpdateOperationsInput | string | null
    metaTag?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    parentId?: NullableStringFieldUpdateOperationsInput | string | null
    products?: ProductUncheckedUpdateManyWithoutCategoryNestedInput
    promotions?: PromotionUncheckedUpdateManyWithoutCategoryNestedInput
  }

  export type CategoryUpsertWithWhereUniqueWithoutParentInput = {
    where: CategoryWhereUniqueInput
    update: XOR<CategoryUpdateWithoutParentInput, CategoryUncheckedUpdateWithoutParentInput>
    create: XOR<CategoryCreateWithoutParentInput, CategoryUncheckedCreateWithoutParentInput>
  }

  export type CategoryUpdateWithWhereUniqueWithoutParentInput = {
    where: CategoryWhereUniqueInput
    data: XOR<CategoryUpdateWithoutParentInput, CategoryUncheckedUpdateWithoutParentInput>
  }

  export type CategoryUpdateManyWithWhereWithoutParentInput = {
    where: CategoryScalarWhereInput
    data: XOR<CategoryUpdateManyMutationInput, CategoryUncheckedUpdateManyWithoutParentInput>
  }

  export type CategoryScalarWhereInput = {
    AND?: CategoryScalarWhereInput | CategoryScalarWhereInput[]
    OR?: CategoryScalarWhereInput[]
    NOT?: CategoryScalarWhereInput | CategoryScalarWhereInput[]
    id?: StringFilter<"Category"> | string
    title?: StringFilter<"Category"> | string
    type?: IntFilter<"Category"> | number
    imageUrl?: StringNullableFilter<"Category"> | string | null
    iconUrl?: StringNullableFilter<"Category"> | string | null
    metaTag?: StringNullableFilter<"Category"> | string | null
    description?: StringNullableFilter<"Category"> | string | null
    parentId?: StringNullableFilter<"Category"> | string | null
  }

  export type ProductUpsertWithWhereUniqueWithoutCategoryInput = {
    where: ProductWhereUniqueInput
    update: XOR<ProductUpdateWithoutCategoryInput, ProductUncheckedUpdateWithoutCategoryInput>
    create: XOR<ProductCreateWithoutCategoryInput, ProductUncheckedCreateWithoutCategoryInput>
  }

  export type ProductUpdateWithWhereUniqueWithoutCategoryInput = {
    where: ProductWhereUniqueInput
    data: XOR<ProductUpdateWithoutCategoryInput, ProductUncheckedUpdateWithoutCategoryInput>
  }

  export type ProductUpdateManyWithWhereWithoutCategoryInput = {
    where: ProductScalarWhereInput
    data: XOR<ProductUpdateManyMutationInput, ProductUncheckedUpdateManyWithoutCategoryInput>
  }

  export type ProductScalarWhereInput = {
    AND?: ProductScalarWhereInput | ProductScalarWhereInput[]
    OR?: ProductScalarWhereInput[]
    NOT?: ProductScalarWhereInput | ProductScalarWhereInput[]
    id?: StringFilter<"Product"> | string
    title?: StringFilter<"Product"> | string
    description?: StringNullableFilter<"Product"> | string | null
    categoryId?: StringNullableFilter<"Product"> | string | null
    brandId?: StringNullableFilter<"Product"> | string | null
    productCode?: StringNullableFilter<"Product"> | string | null
    showType?: IntFilter<"Product"> | number
    isActive?: BoolFilter<"Product"> | boolean
    createdAt?: DateTimeFilter<"Product"> | Date | string
  }

  export type PromotionUpsertWithWhereUniqueWithoutCategoryInput = {
    where: PromotionWhereUniqueInput
    update: XOR<PromotionUpdateWithoutCategoryInput, PromotionUncheckedUpdateWithoutCategoryInput>
    create: XOR<PromotionCreateWithoutCategoryInput, PromotionUncheckedCreateWithoutCategoryInput>
  }

  export type PromotionUpdateWithWhereUniqueWithoutCategoryInput = {
    where: PromotionWhereUniqueInput
    data: XOR<PromotionUpdateWithoutCategoryInput, PromotionUncheckedUpdateWithoutCategoryInput>
  }

  export type PromotionUpdateManyWithWhereWithoutCategoryInput = {
    where: PromotionScalarWhereInput
    data: XOR<PromotionUpdateManyMutationInput, PromotionUncheckedUpdateManyWithoutCategoryInput>
  }

  export type ProductCreateWithoutBrandInput = {
    id?: string
    title: string
    description?: string | null
    productCode?: string | null
    showType?: number
    isActive?: boolean
    createdAt?: Date | string
    category?: CategoryCreateNestedOneWithoutProductsInput
    variants?: ProductVariantCreateNestedManyWithoutProductInput
    images?: ProductImageCreateNestedManyWithoutProductInput
    collections?: CollectionProductCreateNestedManyWithoutProductInput
    comments?: CommentCreateNestedManyWithoutProductInput
    promotions?: PromotionCreateNestedManyWithoutProductInput
    allocationItems?: BranchAllocationItemCreateNestedManyWithoutProductInput
  }

  export type ProductUncheckedCreateWithoutBrandInput = {
    id?: string
    title: string
    description?: string | null
    categoryId?: string | null
    productCode?: string | null
    showType?: number
    isActive?: boolean
    createdAt?: Date | string
    variants?: ProductVariantUncheckedCreateNestedManyWithoutProductInput
    images?: ProductImageUncheckedCreateNestedManyWithoutProductInput
    collections?: CollectionProductUncheckedCreateNestedManyWithoutProductInput
    comments?: CommentUncheckedCreateNestedManyWithoutProductInput
    promotions?: PromotionUncheckedCreateNestedManyWithoutProductInput
    allocationItems?: BranchAllocationItemUncheckedCreateNestedManyWithoutProductInput
  }

  export type ProductCreateOrConnectWithoutBrandInput = {
    where: ProductWhereUniqueInput
    create: XOR<ProductCreateWithoutBrandInput, ProductUncheckedCreateWithoutBrandInput>
  }

  export type ProductCreateManyBrandInputEnvelope = {
    data: ProductCreateManyBrandInput | ProductCreateManyBrandInput[]
    skipDuplicates?: boolean
  }

  export type PromotionCreateWithoutBrandInput = {
    id?: string
    title: string
    description?: string | null
    scope?: $Enums.PromotionScope
    usage?: $Enums.PromotionUsage
    discountPercent: Decimal | DecimalJsLike | number | string
    isActive?: boolean
    platform?: number
    startsAt?: Date | string | null
    endsAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    product?: ProductCreateNestedOneWithoutPromotionsInput
    category?: CategoryCreateNestedOneWithoutPromotionsInput
    customer?: CustomerCreateNestedOneWithoutPromotionsInput
  }

  export type PromotionUncheckedCreateWithoutBrandInput = {
    id?: string
    title: string
    description?: string | null
    scope?: $Enums.PromotionScope
    usage?: $Enums.PromotionUsage
    discountPercent: Decimal | DecimalJsLike | number | string
    isActive?: boolean
    platform?: number
    startsAt?: Date | string | null
    endsAt?: Date | string | null
    productId?: string | null
    categoryId?: string | null
    customerId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type PromotionCreateOrConnectWithoutBrandInput = {
    where: PromotionWhereUniqueInput
    create: XOR<PromotionCreateWithoutBrandInput, PromotionUncheckedCreateWithoutBrandInput>
  }

  export type PromotionCreateManyBrandInputEnvelope = {
    data: PromotionCreateManyBrandInput | PromotionCreateManyBrandInput[]
    skipDuplicates?: boolean
  }

  export type ProductUpsertWithWhereUniqueWithoutBrandInput = {
    where: ProductWhereUniqueInput
    update: XOR<ProductUpdateWithoutBrandInput, ProductUncheckedUpdateWithoutBrandInput>
    create: XOR<ProductCreateWithoutBrandInput, ProductUncheckedCreateWithoutBrandInput>
  }

  export type ProductUpdateWithWhereUniqueWithoutBrandInput = {
    where: ProductWhereUniqueInput
    data: XOR<ProductUpdateWithoutBrandInput, ProductUncheckedUpdateWithoutBrandInput>
  }

  export type ProductUpdateManyWithWhereWithoutBrandInput = {
    where: ProductScalarWhereInput
    data: XOR<ProductUpdateManyMutationInput, ProductUncheckedUpdateManyWithoutBrandInput>
  }

  export type PromotionUpsertWithWhereUniqueWithoutBrandInput = {
    where: PromotionWhereUniqueInput
    update: XOR<PromotionUpdateWithoutBrandInput, PromotionUncheckedUpdateWithoutBrandInput>
    create: XOR<PromotionCreateWithoutBrandInput, PromotionUncheckedCreateWithoutBrandInput>
  }

  export type PromotionUpdateWithWhereUniqueWithoutBrandInput = {
    where: PromotionWhereUniqueInput
    data: XOR<PromotionUpdateWithoutBrandInput, PromotionUncheckedUpdateWithoutBrandInput>
  }

  export type PromotionUpdateManyWithWhereWithoutBrandInput = {
    where: PromotionScalarWhereInput
    data: XOR<PromotionUpdateManyMutationInput, PromotionUncheckedUpdateManyWithoutBrandInput>
  }

  export type CollectionProductCreateWithoutCollectionInput = {
    product: ProductCreateNestedOneWithoutCollectionsInput
  }

  export type CollectionProductUncheckedCreateWithoutCollectionInput = {
    productId: string
  }

  export type CollectionProductCreateOrConnectWithoutCollectionInput = {
    where: CollectionProductWhereUniqueInput
    create: XOR<CollectionProductCreateWithoutCollectionInput, CollectionProductUncheckedCreateWithoutCollectionInput>
  }

  export type CollectionProductCreateManyCollectionInputEnvelope = {
    data: CollectionProductCreateManyCollectionInput | CollectionProductCreateManyCollectionInput[]
    skipDuplicates?: boolean
  }

  export type CollectionProductUpsertWithWhereUniqueWithoutCollectionInput = {
    where: CollectionProductWhereUniqueInput
    update: XOR<CollectionProductUpdateWithoutCollectionInput, CollectionProductUncheckedUpdateWithoutCollectionInput>
    create: XOR<CollectionProductCreateWithoutCollectionInput, CollectionProductUncheckedCreateWithoutCollectionInput>
  }

  export type CollectionProductUpdateWithWhereUniqueWithoutCollectionInput = {
    where: CollectionProductWhereUniqueInput
    data: XOR<CollectionProductUpdateWithoutCollectionInput, CollectionProductUncheckedUpdateWithoutCollectionInput>
  }

  export type CollectionProductUpdateManyWithWhereWithoutCollectionInput = {
    where: CollectionProductScalarWhereInput
    data: XOR<CollectionProductUpdateManyMutationInput, CollectionProductUncheckedUpdateManyWithoutCollectionInput>
  }

  export type CollectionProductScalarWhereInput = {
    AND?: CollectionProductScalarWhereInput | CollectionProductScalarWhereInput[]
    OR?: CollectionProductScalarWhereInput[]
    NOT?: CollectionProductScalarWhereInput | CollectionProductScalarWhereInput[]
    collectionId?: StringFilter<"CollectionProduct"> | string
    productId?: StringFilter<"CollectionProduct"> | string
  }

  export type CollectionCreateWithoutProductsInput = {
    id?: string
    title: string
    description?: string | null
    isActive?: boolean
  }

  export type CollectionUncheckedCreateWithoutProductsInput = {
    id?: string
    title: string
    description?: string | null
    isActive?: boolean
  }

  export type CollectionCreateOrConnectWithoutProductsInput = {
    where: CollectionWhereUniqueInput
    create: XOR<CollectionCreateWithoutProductsInput, CollectionUncheckedCreateWithoutProductsInput>
  }

  export type ProductCreateWithoutCollectionsInput = {
    id?: string
    title: string
    description?: string | null
    productCode?: string | null
    showType?: number
    isActive?: boolean
    createdAt?: Date | string
    category?: CategoryCreateNestedOneWithoutProductsInput
    brand?: BrandCreateNestedOneWithoutProductsInput
    variants?: ProductVariantCreateNestedManyWithoutProductInput
    images?: ProductImageCreateNestedManyWithoutProductInput
    comments?: CommentCreateNestedManyWithoutProductInput
    promotions?: PromotionCreateNestedManyWithoutProductInput
    allocationItems?: BranchAllocationItemCreateNestedManyWithoutProductInput
  }

  export type ProductUncheckedCreateWithoutCollectionsInput = {
    id?: string
    title: string
    description?: string | null
    categoryId?: string | null
    brandId?: string | null
    productCode?: string | null
    showType?: number
    isActive?: boolean
    createdAt?: Date | string
    variants?: ProductVariantUncheckedCreateNestedManyWithoutProductInput
    images?: ProductImageUncheckedCreateNestedManyWithoutProductInput
    comments?: CommentUncheckedCreateNestedManyWithoutProductInput
    promotions?: PromotionUncheckedCreateNestedManyWithoutProductInput
    allocationItems?: BranchAllocationItemUncheckedCreateNestedManyWithoutProductInput
  }

  export type ProductCreateOrConnectWithoutCollectionsInput = {
    where: ProductWhereUniqueInput
    create: XOR<ProductCreateWithoutCollectionsInput, ProductUncheckedCreateWithoutCollectionsInput>
  }

  export type CollectionUpsertWithoutProductsInput = {
    update: XOR<CollectionUpdateWithoutProductsInput, CollectionUncheckedUpdateWithoutProductsInput>
    create: XOR<CollectionCreateWithoutProductsInput, CollectionUncheckedCreateWithoutProductsInput>
    where?: CollectionWhereInput
  }

  export type CollectionUpdateToOneWithWhereWithoutProductsInput = {
    where?: CollectionWhereInput
    data: XOR<CollectionUpdateWithoutProductsInput, CollectionUncheckedUpdateWithoutProductsInput>
  }

  export type CollectionUpdateWithoutProductsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
  }

  export type CollectionUncheckedUpdateWithoutProductsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
  }

  export type ProductUpsertWithoutCollectionsInput = {
    update: XOR<ProductUpdateWithoutCollectionsInput, ProductUncheckedUpdateWithoutCollectionsInput>
    create: XOR<ProductCreateWithoutCollectionsInput, ProductUncheckedCreateWithoutCollectionsInput>
    where?: ProductWhereInput
  }

  export type ProductUpdateToOneWithWhereWithoutCollectionsInput = {
    where?: ProductWhereInput
    data: XOR<ProductUpdateWithoutCollectionsInput, ProductUncheckedUpdateWithoutCollectionsInput>
  }

  export type ProductUpdateWithoutCollectionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    productCode?: NullableStringFieldUpdateOperationsInput | string | null
    showType?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    category?: CategoryUpdateOneWithoutProductsNestedInput
    brand?: BrandUpdateOneWithoutProductsNestedInput
    variants?: ProductVariantUpdateManyWithoutProductNestedInput
    images?: ProductImageUpdateManyWithoutProductNestedInput
    comments?: CommentUpdateManyWithoutProductNestedInput
    promotions?: PromotionUpdateManyWithoutProductNestedInput
    allocationItems?: BranchAllocationItemUpdateManyWithoutProductNestedInput
  }

  export type ProductUncheckedUpdateWithoutCollectionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    categoryId?: NullableStringFieldUpdateOperationsInput | string | null
    brandId?: NullableStringFieldUpdateOperationsInput | string | null
    productCode?: NullableStringFieldUpdateOperationsInput | string | null
    showType?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    variants?: ProductVariantUncheckedUpdateManyWithoutProductNestedInput
    images?: ProductImageUncheckedUpdateManyWithoutProductNestedInput
    comments?: CommentUncheckedUpdateManyWithoutProductNestedInput
    promotions?: PromotionUncheckedUpdateManyWithoutProductNestedInput
    allocationItems?: BranchAllocationItemUncheckedUpdateManyWithoutProductNestedInput
  }

  export type CategoryCreateWithoutProductsInput = {
    id?: string
    title: string
    type?: number
    imageUrl?: string | null
    iconUrl?: string | null
    metaTag?: string | null
    description?: string | null
    parent?: CategoryCreateNestedOneWithoutChildrenInput
    children?: CategoryCreateNestedManyWithoutParentInput
    promotions?: PromotionCreateNestedManyWithoutCategoryInput
  }

  export type CategoryUncheckedCreateWithoutProductsInput = {
    id?: string
    title: string
    type?: number
    imageUrl?: string | null
    iconUrl?: string | null
    metaTag?: string | null
    description?: string | null
    parentId?: string | null
    children?: CategoryUncheckedCreateNestedManyWithoutParentInput
    promotions?: PromotionUncheckedCreateNestedManyWithoutCategoryInput
  }

  export type CategoryCreateOrConnectWithoutProductsInput = {
    where: CategoryWhereUniqueInput
    create: XOR<CategoryCreateWithoutProductsInput, CategoryUncheckedCreateWithoutProductsInput>
  }

  export type BrandCreateWithoutProductsInput = {
    id?: string
    title: string
    promotions?: PromotionCreateNestedManyWithoutBrandInput
  }

  export type BrandUncheckedCreateWithoutProductsInput = {
    id?: string
    title: string
    promotions?: PromotionUncheckedCreateNestedManyWithoutBrandInput
  }

  export type BrandCreateOrConnectWithoutProductsInput = {
    where: BrandWhereUniqueInput
    create: XOR<BrandCreateWithoutProductsInput, BrandUncheckedCreateWithoutProductsInput>
  }

  export type ProductVariantCreateWithoutProductInput = {
    id?: string
    title: string
    sku?: string | null
    rashWeightGrams: Decimal | DecimalJsLike | number | string
    defaultWagePercent: Decimal | DecimalJsLike | number | string
    qty?: number
    isPreOrder?: boolean
    isActive?: boolean
    image?: ProductImageCreateNestedOneWithoutVariantsInput
    orderItems?: OrderItemCreateNestedManyWithoutProductVariantInput
  }

  export type ProductVariantUncheckedCreateWithoutProductInput = {
    id?: string
    title: string
    sku?: string | null
    rashWeightGrams: Decimal | DecimalJsLike | number | string
    defaultWagePercent: Decimal | DecimalJsLike | number | string
    qty?: number
    isPreOrder?: boolean
    isActive?: boolean
    imageId?: string | null
    orderItems?: OrderItemUncheckedCreateNestedManyWithoutProductVariantInput
  }

  export type ProductVariantCreateOrConnectWithoutProductInput = {
    where: ProductVariantWhereUniqueInput
    create: XOR<ProductVariantCreateWithoutProductInput, ProductVariantUncheckedCreateWithoutProductInput>
  }

  export type ProductVariantCreateManyProductInputEnvelope = {
    data: ProductVariantCreateManyProductInput | ProductVariantCreateManyProductInput[]
    skipDuplicates?: boolean
  }

  export type ProductImageCreateWithoutProductInput = {
    id?: string
    url: string
    sortOrder?: number
    role?: $Enums.ProductImageRole
    variants?: ProductVariantCreateNestedManyWithoutImageInput
  }

  export type ProductImageUncheckedCreateWithoutProductInput = {
    id?: string
    url: string
    sortOrder?: number
    role?: $Enums.ProductImageRole
    variants?: ProductVariantUncheckedCreateNestedManyWithoutImageInput
  }

  export type ProductImageCreateOrConnectWithoutProductInput = {
    where: ProductImageWhereUniqueInput
    create: XOR<ProductImageCreateWithoutProductInput, ProductImageUncheckedCreateWithoutProductInput>
  }

  export type ProductImageCreateManyProductInputEnvelope = {
    data: ProductImageCreateManyProductInput | ProductImageCreateManyProductInput[]
    skipDuplicates?: boolean
  }

  export type CollectionProductCreateWithoutProductInput = {
    collection: CollectionCreateNestedOneWithoutProductsInput
  }

  export type CollectionProductUncheckedCreateWithoutProductInput = {
    collectionId: string
  }

  export type CollectionProductCreateOrConnectWithoutProductInput = {
    where: CollectionProductWhereUniqueInput
    create: XOR<CollectionProductCreateWithoutProductInput, CollectionProductUncheckedCreateWithoutProductInput>
  }

  export type CollectionProductCreateManyProductInputEnvelope = {
    data: CollectionProductCreateManyProductInput | CollectionProductCreateManyProductInput[]
    skipDuplicates?: boolean
  }

  export type CommentCreateWithoutProductInput = {
    id?: string
    body: string
    status?: $Enums.CommentStatus
    createdAt?: Date | string
    updatedAt?: Date | string
    customer: CustomerCreateNestedOneWithoutCommentsInput
    replyTo?: CommentCreateNestedOneWithoutRepliesInput
    replies?: CommentCreateNestedManyWithoutReplyToInput
  }

  export type CommentUncheckedCreateWithoutProductInput = {
    id?: string
    customerId: string
    body: string
    status?: $Enums.CommentStatus
    replyToId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    replies?: CommentUncheckedCreateNestedManyWithoutReplyToInput
  }

  export type CommentCreateOrConnectWithoutProductInput = {
    where: CommentWhereUniqueInput
    create: XOR<CommentCreateWithoutProductInput, CommentUncheckedCreateWithoutProductInput>
  }

  export type CommentCreateManyProductInputEnvelope = {
    data: CommentCreateManyProductInput | CommentCreateManyProductInput[]
    skipDuplicates?: boolean
  }

  export type PromotionCreateWithoutProductInput = {
    id?: string
    title: string
    description?: string | null
    scope?: $Enums.PromotionScope
    usage?: $Enums.PromotionUsage
    discountPercent: Decimal | DecimalJsLike | number | string
    isActive?: boolean
    platform?: number
    startsAt?: Date | string | null
    endsAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    category?: CategoryCreateNestedOneWithoutPromotionsInput
    customer?: CustomerCreateNestedOneWithoutPromotionsInput
    brand?: BrandCreateNestedOneWithoutPromotionsInput
  }

  export type PromotionUncheckedCreateWithoutProductInput = {
    id?: string
    title: string
    description?: string | null
    scope?: $Enums.PromotionScope
    usage?: $Enums.PromotionUsage
    discountPercent: Decimal | DecimalJsLike | number | string
    isActive?: boolean
    platform?: number
    startsAt?: Date | string | null
    endsAt?: Date | string | null
    categoryId?: string | null
    customerId?: string | null
    brandId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type PromotionCreateOrConnectWithoutProductInput = {
    where: PromotionWhereUniqueInput
    create: XOR<PromotionCreateWithoutProductInput, PromotionUncheckedCreateWithoutProductInput>
  }

  export type PromotionCreateManyProductInputEnvelope = {
    data: PromotionCreateManyProductInput | PromotionCreateManyProductInput[]
    skipDuplicates?: boolean
  }

  export type BranchAllocationItemCreateWithoutProductInput = {
    id?: string
    weightGrams?: Decimal | DecimalJsLike | number | string | null
    allocation: BranchAllocationCreateNestedOneWithoutItemsInput
  }

  export type BranchAllocationItemUncheckedCreateWithoutProductInput = {
    id?: string
    allocationId: string
    weightGrams?: Decimal | DecimalJsLike | number | string | null
  }

  export type BranchAllocationItemCreateOrConnectWithoutProductInput = {
    where: BranchAllocationItemWhereUniqueInput
    create: XOR<BranchAllocationItemCreateWithoutProductInput, BranchAllocationItemUncheckedCreateWithoutProductInput>
  }

  export type BranchAllocationItemCreateManyProductInputEnvelope = {
    data: BranchAllocationItemCreateManyProductInput | BranchAllocationItemCreateManyProductInput[]
    skipDuplicates?: boolean
  }

  export type CategoryUpsertWithoutProductsInput = {
    update: XOR<CategoryUpdateWithoutProductsInput, CategoryUncheckedUpdateWithoutProductsInput>
    create: XOR<CategoryCreateWithoutProductsInput, CategoryUncheckedCreateWithoutProductsInput>
    where?: CategoryWhereInput
  }

  export type CategoryUpdateToOneWithWhereWithoutProductsInput = {
    where?: CategoryWhereInput
    data: XOR<CategoryUpdateWithoutProductsInput, CategoryUncheckedUpdateWithoutProductsInput>
  }

  export type CategoryUpdateWithoutProductsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    type?: IntFieldUpdateOperationsInput | number
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    iconUrl?: NullableStringFieldUpdateOperationsInput | string | null
    metaTag?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    parent?: CategoryUpdateOneWithoutChildrenNestedInput
    children?: CategoryUpdateManyWithoutParentNestedInput
    promotions?: PromotionUpdateManyWithoutCategoryNestedInput
  }

  export type CategoryUncheckedUpdateWithoutProductsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    type?: IntFieldUpdateOperationsInput | number
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    iconUrl?: NullableStringFieldUpdateOperationsInput | string | null
    metaTag?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    parentId?: NullableStringFieldUpdateOperationsInput | string | null
    children?: CategoryUncheckedUpdateManyWithoutParentNestedInput
    promotions?: PromotionUncheckedUpdateManyWithoutCategoryNestedInput
  }

  export type BrandUpsertWithoutProductsInput = {
    update: XOR<BrandUpdateWithoutProductsInput, BrandUncheckedUpdateWithoutProductsInput>
    create: XOR<BrandCreateWithoutProductsInput, BrandUncheckedCreateWithoutProductsInput>
    where?: BrandWhereInput
  }

  export type BrandUpdateToOneWithWhereWithoutProductsInput = {
    where?: BrandWhereInput
    data: XOR<BrandUpdateWithoutProductsInput, BrandUncheckedUpdateWithoutProductsInput>
  }

  export type BrandUpdateWithoutProductsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    promotions?: PromotionUpdateManyWithoutBrandNestedInput
  }

  export type BrandUncheckedUpdateWithoutProductsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    promotions?: PromotionUncheckedUpdateManyWithoutBrandNestedInput
  }

  export type ProductVariantUpsertWithWhereUniqueWithoutProductInput = {
    where: ProductVariantWhereUniqueInput
    update: XOR<ProductVariantUpdateWithoutProductInput, ProductVariantUncheckedUpdateWithoutProductInput>
    create: XOR<ProductVariantCreateWithoutProductInput, ProductVariantUncheckedCreateWithoutProductInput>
  }

  export type ProductVariantUpdateWithWhereUniqueWithoutProductInput = {
    where: ProductVariantWhereUniqueInput
    data: XOR<ProductVariantUpdateWithoutProductInput, ProductVariantUncheckedUpdateWithoutProductInput>
  }

  export type ProductVariantUpdateManyWithWhereWithoutProductInput = {
    where: ProductVariantScalarWhereInput
    data: XOR<ProductVariantUpdateManyMutationInput, ProductVariantUncheckedUpdateManyWithoutProductInput>
  }

  export type ProductVariantScalarWhereInput = {
    AND?: ProductVariantScalarWhereInput | ProductVariantScalarWhereInput[]
    OR?: ProductVariantScalarWhereInput[]
    NOT?: ProductVariantScalarWhereInput | ProductVariantScalarWhereInput[]
    id?: StringFilter<"ProductVariant"> | string
    productId?: StringFilter<"ProductVariant"> | string
    title?: StringFilter<"ProductVariant"> | string
    sku?: StringNullableFilter<"ProductVariant"> | string | null
    rashWeightGrams?: DecimalFilter<"ProductVariant"> | Decimal | DecimalJsLike | number | string
    defaultWagePercent?: DecimalFilter<"ProductVariant"> | Decimal | DecimalJsLike | number | string
    qty?: IntFilter<"ProductVariant"> | number
    isPreOrder?: BoolFilter<"ProductVariant"> | boolean
    isActive?: BoolFilter<"ProductVariant"> | boolean
    imageId?: StringNullableFilter<"ProductVariant"> | string | null
  }

  export type ProductImageUpsertWithWhereUniqueWithoutProductInput = {
    where: ProductImageWhereUniqueInput
    update: XOR<ProductImageUpdateWithoutProductInput, ProductImageUncheckedUpdateWithoutProductInput>
    create: XOR<ProductImageCreateWithoutProductInput, ProductImageUncheckedCreateWithoutProductInput>
  }

  export type ProductImageUpdateWithWhereUniqueWithoutProductInput = {
    where: ProductImageWhereUniqueInput
    data: XOR<ProductImageUpdateWithoutProductInput, ProductImageUncheckedUpdateWithoutProductInput>
  }

  export type ProductImageUpdateManyWithWhereWithoutProductInput = {
    where: ProductImageScalarWhereInput
    data: XOR<ProductImageUpdateManyMutationInput, ProductImageUncheckedUpdateManyWithoutProductInput>
  }

  export type ProductImageScalarWhereInput = {
    AND?: ProductImageScalarWhereInput | ProductImageScalarWhereInput[]
    OR?: ProductImageScalarWhereInput[]
    NOT?: ProductImageScalarWhereInput | ProductImageScalarWhereInput[]
    id?: StringFilter<"ProductImage"> | string
    productId?: StringFilter<"ProductImage"> | string
    url?: StringFilter<"ProductImage"> | string
    sortOrder?: IntFilter<"ProductImage"> | number
    role?: EnumProductImageRoleFilter<"ProductImage"> | $Enums.ProductImageRole
  }

  export type CollectionProductUpsertWithWhereUniqueWithoutProductInput = {
    where: CollectionProductWhereUniqueInput
    update: XOR<CollectionProductUpdateWithoutProductInput, CollectionProductUncheckedUpdateWithoutProductInput>
    create: XOR<CollectionProductCreateWithoutProductInput, CollectionProductUncheckedCreateWithoutProductInput>
  }

  export type CollectionProductUpdateWithWhereUniqueWithoutProductInput = {
    where: CollectionProductWhereUniqueInput
    data: XOR<CollectionProductUpdateWithoutProductInput, CollectionProductUncheckedUpdateWithoutProductInput>
  }

  export type CollectionProductUpdateManyWithWhereWithoutProductInput = {
    where: CollectionProductScalarWhereInput
    data: XOR<CollectionProductUpdateManyMutationInput, CollectionProductUncheckedUpdateManyWithoutProductInput>
  }

  export type CommentUpsertWithWhereUniqueWithoutProductInput = {
    where: CommentWhereUniqueInput
    update: XOR<CommentUpdateWithoutProductInput, CommentUncheckedUpdateWithoutProductInput>
    create: XOR<CommentCreateWithoutProductInput, CommentUncheckedCreateWithoutProductInput>
  }

  export type CommentUpdateWithWhereUniqueWithoutProductInput = {
    where: CommentWhereUniqueInput
    data: XOR<CommentUpdateWithoutProductInput, CommentUncheckedUpdateWithoutProductInput>
  }

  export type CommentUpdateManyWithWhereWithoutProductInput = {
    where: CommentScalarWhereInput
    data: XOR<CommentUpdateManyMutationInput, CommentUncheckedUpdateManyWithoutProductInput>
  }

  export type PromotionUpsertWithWhereUniqueWithoutProductInput = {
    where: PromotionWhereUniqueInput
    update: XOR<PromotionUpdateWithoutProductInput, PromotionUncheckedUpdateWithoutProductInput>
    create: XOR<PromotionCreateWithoutProductInput, PromotionUncheckedCreateWithoutProductInput>
  }

  export type PromotionUpdateWithWhereUniqueWithoutProductInput = {
    where: PromotionWhereUniqueInput
    data: XOR<PromotionUpdateWithoutProductInput, PromotionUncheckedUpdateWithoutProductInput>
  }

  export type PromotionUpdateManyWithWhereWithoutProductInput = {
    where: PromotionScalarWhereInput
    data: XOR<PromotionUpdateManyMutationInput, PromotionUncheckedUpdateManyWithoutProductInput>
  }

  export type BranchAllocationItemUpsertWithWhereUniqueWithoutProductInput = {
    where: BranchAllocationItemWhereUniqueInput
    update: XOR<BranchAllocationItemUpdateWithoutProductInput, BranchAllocationItemUncheckedUpdateWithoutProductInput>
    create: XOR<BranchAllocationItemCreateWithoutProductInput, BranchAllocationItemUncheckedCreateWithoutProductInput>
  }

  export type BranchAllocationItemUpdateWithWhereUniqueWithoutProductInput = {
    where: BranchAllocationItemWhereUniqueInput
    data: XOR<BranchAllocationItemUpdateWithoutProductInput, BranchAllocationItemUncheckedUpdateWithoutProductInput>
  }

  export type BranchAllocationItemUpdateManyWithWhereWithoutProductInput = {
    where: BranchAllocationItemScalarWhereInput
    data: XOR<BranchAllocationItemUpdateManyMutationInput, BranchAllocationItemUncheckedUpdateManyWithoutProductInput>
  }

  export type BranchAllocationItemScalarWhereInput = {
    AND?: BranchAllocationItemScalarWhereInput | BranchAllocationItemScalarWhereInput[]
    OR?: BranchAllocationItemScalarWhereInput[]
    NOT?: BranchAllocationItemScalarWhereInput | BranchAllocationItemScalarWhereInput[]
    id?: StringFilter<"BranchAllocationItem"> | string
    allocationId?: StringFilter<"BranchAllocationItem"> | string
    productId?: StringFilter<"BranchAllocationItem"> | string
    weightGrams?: DecimalNullableFilter<"BranchAllocationItem"> | Decimal | DecimalJsLike | number | string | null
  }

  export type ProductCreateWithoutImagesInput = {
    id?: string
    title: string
    description?: string | null
    productCode?: string | null
    showType?: number
    isActive?: boolean
    createdAt?: Date | string
    category?: CategoryCreateNestedOneWithoutProductsInput
    brand?: BrandCreateNestedOneWithoutProductsInput
    variants?: ProductVariantCreateNestedManyWithoutProductInput
    collections?: CollectionProductCreateNestedManyWithoutProductInput
    comments?: CommentCreateNestedManyWithoutProductInput
    promotions?: PromotionCreateNestedManyWithoutProductInput
    allocationItems?: BranchAllocationItemCreateNestedManyWithoutProductInput
  }

  export type ProductUncheckedCreateWithoutImagesInput = {
    id?: string
    title: string
    description?: string | null
    categoryId?: string | null
    brandId?: string | null
    productCode?: string | null
    showType?: number
    isActive?: boolean
    createdAt?: Date | string
    variants?: ProductVariantUncheckedCreateNestedManyWithoutProductInput
    collections?: CollectionProductUncheckedCreateNestedManyWithoutProductInput
    comments?: CommentUncheckedCreateNestedManyWithoutProductInput
    promotions?: PromotionUncheckedCreateNestedManyWithoutProductInput
    allocationItems?: BranchAllocationItemUncheckedCreateNestedManyWithoutProductInput
  }

  export type ProductCreateOrConnectWithoutImagesInput = {
    where: ProductWhereUniqueInput
    create: XOR<ProductCreateWithoutImagesInput, ProductUncheckedCreateWithoutImagesInput>
  }

  export type ProductVariantCreateWithoutImageInput = {
    id?: string
    title: string
    sku?: string | null
    rashWeightGrams: Decimal | DecimalJsLike | number | string
    defaultWagePercent: Decimal | DecimalJsLike | number | string
    qty?: number
    isPreOrder?: boolean
    isActive?: boolean
    product: ProductCreateNestedOneWithoutVariantsInput
    orderItems?: OrderItemCreateNestedManyWithoutProductVariantInput
  }

  export type ProductVariantUncheckedCreateWithoutImageInput = {
    id?: string
    productId: string
    title: string
    sku?: string | null
    rashWeightGrams: Decimal | DecimalJsLike | number | string
    defaultWagePercent: Decimal | DecimalJsLike | number | string
    qty?: number
    isPreOrder?: boolean
    isActive?: boolean
    orderItems?: OrderItemUncheckedCreateNestedManyWithoutProductVariantInput
  }

  export type ProductVariantCreateOrConnectWithoutImageInput = {
    where: ProductVariantWhereUniqueInput
    create: XOR<ProductVariantCreateWithoutImageInput, ProductVariantUncheckedCreateWithoutImageInput>
  }

  export type ProductVariantCreateManyImageInputEnvelope = {
    data: ProductVariantCreateManyImageInput | ProductVariantCreateManyImageInput[]
    skipDuplicates?: boolean
  }

  export type ProductUpsertWithoutImagesInput = {
    update: XOR<ProductUpdateWithoutImagesInput, ProductUncheckedUpdateWithoutImagesInput>
    create: XOR<ProductCreateWithoutImagesInput, ProductUncheckedCreateWithoutImagesInput>
    where?: ProductWhereInput
  }

  export type ProductUpdateToOneWithWhereWithoutImagesInput = {
    where?: ProductWhereInput
    data: XOR<ProductUpdateWithoutImagesInput, ProductUncheckedUpdateWithoutImagesInput>
  }

  export type ProductUpdateWithoutImagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    productCode?: NullableStringFieldUpdateOperationsInput | string | null
    showType?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    category?: CategoryUpdateOneWithoutProductsNestedInput
    brand?: BrandUpdateOneWithoutProductsNestedInput
    variants?: ProductVariantUpdateManyWithoutProductNestedInput
    collections?: CollectionProductUpdateManyWithoutProductNestedInput
    comments?: CommentUpdateManyWithoutProductNestedInput
    promotions?: PromotionUpdateManyWithoutProductNestedInput
    allocationItems?: BranchAllocationItemUpdateManyWithoutProductNestedInput
  }

  export type ProductUncheckedUpdateWithoutImagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    categoryId?: NullableStringFieldUpdateOperationsInput | string | null
    brandId?: NullableStringFieldUpdateOperationsInput | string | null
    productCode?: NullableStringFieldUpdateOperationsInput | string | null
    showType?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    variants?: ProductVariantUncheckedUpdateManyWithoutProductNestedInput
    collections?: CollectionProductUncheckedUpdateManyWithoutProductNestedInput
    comments?: CommentUncheckedUpdateManyWithoutProductNestedInput
    promotions?: PromotionUncheckedUpdateManyWithoutProductNestedInput
    allocationItems?: BranchAllocationItemUncheckedUpdateManyWithoutProductNestedInput
  }

  export type ProductVariantUpsertWithWhereUniqueWithoutImageInput = {
    where: ProductVariantWhereUniqueInput
    update: XOR<ProductVariantUpdateWithoutImageInput, ProductVariantUncheckedUpdateWithoutImageInput>
    create: XOR<ProductVariantCreateWithoutImageInput, ProductVariantUncheckedCreateWithoutImageInput>
  }

  export type ProductVariantUpdateWithWhereUniqueWithoutImageInput = {
    where: ProductVariantWhereUniqueInput
    data: XOR<ProductVariantUpdateWithoutImageInput, ProductVariantUncheckedUpdateWithoutImageInput>
  }

  export type ProductVariantUpdateManyWithWhereWithoutImageInput = {
    where: ProductVariantScalarWhereInput
    data: XOR<ProductVariantUpdateManyMutationInput, ProductVariantUncheckedUpdateManyWithoutImageInput>
  }

  export type ProductCreateWithoutVariantsInput = {
    id?: string
    title: string
    description?: string | null
    productCode?: string | null
    showType?: number
    isActive?: boolean
    createdAt?: Date | string
    category?: CategoryCreateNestedOneWithoutProductsInput
    brand?: BrandCreateNestedOneWithoutProductsInput
    images?: ProductImageCreateNestedManyWithoutProductInput
    collections?: CollectionProductCreateNestedManyWithoutProductInput
    comments?: CommentCreateNestedManyWithoutProductInput
    promotions?: PromotionCreateNestedManyWithoutProductInput
    allocationItems?: BranchAllocationItemCreateNestedManyWithoutProductInput
  }

  export type ProductUncheckedCreateWithoutVariantsInput = {
    id?: string
    title: string
    description?: string | null
    categoryId?: string | null
    brandId?: string | null
    productCode?: string | null
    showType?: number
    isActive?: boolean
    createdAt?: Date | string
    images?: ProductImageUncheckedCreateNestedManyWithoutProductInput
    collections?: CollectionProductUncheckedCreateNestedManyWithoutProductInput
    comments?: CommentUncheckedCreateNestedManyWithoutProductInput
    promotions?: PromotionUncheckedCreateNestedManyWithoutProductInput
    allocationItems?: BranchAllocationItemUncheckedCreateNestedManyWithoutProductInput
  }

  export type ProductCreateOrConnectWithoutVariantsInput = {
    where: ProductWhereUniqueInput
    create: XOR<ProductCreateWithoutVariantsInput, ProductUncheckedCreateWithoutVariantsInput>
  }

  export type ProductImageCreateWithoutVariantsInput = {
    id?: string
    url: string
    sortOrder?: number
    role?: $Enums.ProductImageRole
    product: ProductCreateNestedOneWithoutImagesInput
  }

  export type ProductImageUncheckedCreateWithoutVariantsInput = {
    id?: string
    productId: string
    url: string
    sortOrder?: number
    role?: $Enums.ProductImageRole
  }

  export type ProductImageCreateOrConnectWithoutVariantsInput = {
    where: ProductImageWhereUniqueInput
    create: XOR<ProductImageCreateWithoutVariantsInput, ProductImageUncheckedCreateWithoutVariantsInput>
  }

  export type OrderItemCreateWithoutProductVariantInput = {
    id?: string
    quantity: number
    rashWeightGramsSnapshot: Decimal | DecimalJsLike | number | string
    wagePercentSnapshot: Decimal | DecimalJsLike | number | string
    discountPercentSnapshot?: Decimal | DecimalJsLike | number | string
    computedWeightGrams: Decimal | DecimalJsLike | number | string
    flatRialCharge?: Decimal | DecimalJsLike | number | string
    order: OrderCreateNestedOneWithoutItemsInput
  }

  export type OrderItemUncheckedCreateWithoutProductVariantInput = {
    id?: string
    orderId: string
    quantity: number
    rashWeightGramsSnapshot: Decimal | DecimalJsLike | number | string
    wagePercentSnapshot: Decimal | DecimalJsLike | number | string
    discountPercentSnapshot?: Decimal | DecimalJsLike | number | string
    computedWeightGrams: Decimal | DecimalJsLike | number | string
    flatRialCharge?: Decimal | DecimalJsLike | number | string
  }

  export type OrderItemCreateOrConnectWithoutProductVariantInput = {
    where: OrderItemWhereUniqueInput
    create: XOR<OrderItemCreateWithoutProductVariantInput, OrderItemUncheckedCreateWithoutProductVariantInput>
  }

  export type OrderItemCreateManyProductVariantInputEnvelope = {
    data: OrderItemCreateManyProductVariantInput | OrderItemCreateManyProductVariantInput[]
    skipDuplicates?: boolean
  }

  export type ProductUpsertWithoutVariantsInput = {
    update: XOR<ProductUpdateWithoutVariantsInput, ProductUncheckedUpdateWithoutVariantsInput>
    create: XOR<ProductCreateWithoutVariantsInput, ProductUncheckedCreateWithoutVariantsInput>
    where?: ProductWhereInput
  }

  export type ProductUpdateToOneWithWhereWithoutVariantsInput = {
    where?: ProductWhereInput
    data: XOR<ProductUpdateWithoutVariantsInput, ProductUncheckedUpdateWithoutVariantsInput>
  }

  export type ProductUpdateWithoutVariantsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    productCode?: NullableStringFieldUpdateOperationsInput | string | null
    showType?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    category?: CategoryUpdateOneWithoutProductsNestedInput
    brand?: BrandUpdateOneWithoutProductsNestedInput
    images?: ProductImageUpdateManyWithoutProductNestedInput
    collections?: CollectionProductUpdateManyWithoutProductNestedInput
    comments?: CommentUpdateManyWithoutProductNestedInput
    promotions?: PromotionUpdateManyWithoutProductNestedInput
    allocationItems?: BranchAllocationItemUpdateManyWithoutProductNestedInput
  }

  export type ProductUncheckedUpdateWithoutVariantsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    categoryId?: NullableStringFieldUpdateOperationsInput | string | null
    brandId?: NullableStringFieldUpdateOperationsInput | string | null
    productCode?: NullableStringFieldUpdateOperationsInput | string | null
    showType?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    images?: ProductImageUncheckedUpdateManyWithoutProductNestedInput
    collections?: CollectionProductUncheckedUpdateManyWithoutProductNestedInput
    comments?: CommentUncheckedUpdateManyWithoutProductNestedInput
    promotions?: PromotionUncheckedUpdateManyWithoutProductNestedInput
    allocationItems?: BranchAllocationItemUncheckedUpdateManyWithoutProductNestedInput
  }

  export type ProductImageUpsertWithoutVariantsInput = {
    update: XOR<ProductImageUpdateWithoutVariantsInput, ProductImageUncheckedUpdateWithoutVariantsInput>
    create: XOR<ProductImageCreateWithoutVariantsInput, ProductImageUncheckedCreateWithoutVariantsInput>
    where?: ProductImageWhereInput
  }

  export type ProductImageUpdateToOneWithWhereWithoutVariantsInput = {
    where?: ProductImageWhereInput
    data: XOR<ProductImageUpdateWithoutVariantsInput, ProductImageUncheckedUpdateWithoutVariantsInput>
  }

  export type ProductImageUpdateWithoutVariantsInput = {
    id?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    sortOrder?: IntFieldUpdateOperationsInput | number
    role?: EnumProductImageRoleFieldUpdateOperationsInput | $Enums.ProductImageRole
    product?: ProductUpdateOneRequiredWithoutImagesNestedInput
  }

  export type ProductImageUncheckedUpdateWithoutVariantsInput = {
    id?: StringFieldUpdateOperationsInput | string
    productId?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    sortOrder?: IntFieldUpdateOperationsInput | number
    role?: EnumProductImageRoleFieldUpdateOperationsInput | $Enums.ProductImageRole
  }

  export type OrderItemUpsertWithWhereUniqueWithoutProductVariantInput = {
    where: OrderItemWhereUniqueInput
    update: XOR<OrderItemUpdateWithoutProductVariantInput, OrderItemUncheckedUpdateWithoutProductVariantInput>
    create: XOR<OrderItemCreateWithoutProductVariantInput, OrderItemUncheckedCreateWithoutProductVariantInput>
  }

  export type OrderItemUpdateWithWhereUniqueWithoutProductVariantInput = {
    where: OrderItemWhereUniqueInput
    data: XOR<OrderItemUpdateWithoutProductVariantInput, OrderItemUncheckedUpdateWithoutProductVariantInput>
  }

  export type OrderItemUpdateManyWithWhereWithoutProductVariantInput = {
    where: OrderItemScalarWhereInput
    data: XOR<OrderItemUpdateManyMutationInput, OrderItemUncheckedUpdateManyWithoutProductVariantInput>
  }

  export type OrderItemScalarWhereInput = {
    AND?: OrderItemScalarWhereInput | OrderItemScalarWhereInput[]
    OR?: OrderItemScalarWhereInput[]
    NOT?: OrderItemScalarWhereInput | OrderItemScalarWhereInput[]
    id?: StringFilter<"OrderItem"> | string
    orderId?: StringFilter<"OrderItem"> | string
    productVariantId?: StringFilter<"OrderItem"> | string
    quantity?: IntFilter<"OrderItem"> | number
    rashWeightGramsSnapshot?: DecimalFilter<"OrderItem"> | Decimal | DecimalJsLike | number | string
    wagePercentSnapshot?: DecimalFilter<"OrderItem"> | Decimal | DecimalJsLike | number | string
    discountPercentSnapshot?: DecimalFilter<"OrderItem"> | Decimal | DecimalJsLike | number | string
    computedWeightGrams?: DecimalFilter<"OrderItem"> | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFilter<"OrderItem"> | Decimal | DecimalJsLike | number | string
  }

  export type CustomerCreateWithoutOrdersInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    city?: CityCreateNestedOneWithoutCustomersInput
    referredByAgent?: AdminUserCreateNestedOneWithoutReferredCustomersInput
    salesExpertTradingFor?: SalesExpertProfileCreateNestedOneWithoutTradingCustomerInput
    avatarFile?: UploadedFileCreateNestedOneWithoutCustomerAvatarsInput
    addresses?: CustomerAddressCreateNestedManyWithoutCustomerInput
    preOrders?: PreOrderCreateNestedManyWithoutCustomerInput
    ledgerEntries?: LedgerEntryCreateNestedManyWithoutCustomerInput
    walletBonuses?: WalletBonusCreateNestedManyWithoutCustomerInput
    comments?: CommentCreateNestedManyWithoutCustomerInput
    promotions?: PromotionCreateNestedManyWithoutCustomerInput
    notifications?: NotificationRecipientCreateNestedManyWithoutCustomerInput
    activityLogs?: CustomerActivityLogCreateNestedManyWithoutCustomerInput
    otpChallenges?: CustomerOtpCreateNestedManyWithoutCustomerInput
  }

  export type CustomerUncheckedCreateWithoutOrdersInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    cityId?: string | null
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    referredByAgentId?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    avatarFileId?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    salesExpertTradingFor?: SalesExpertProfileUncheckedCreateNestedOneWithoutTradingCustomerInput
    addresses?: CustomerAddressUncheckedCreateNestedManyWithoutCustomerInput
    preOrders?: PreOrderUncheckedCreateNestedManyWithoutCustomerInput
    ledgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutCustomerInput
    walletBonuses?: WalletBonusUncheckedCreateNestedManyWithoutCustomerInput
    comments?: CommentUncheckedCreateNestedManyWithoutCustomerInput
    promotions?: PromotionUncheckedCreateNestedManyWithoutCustomerInput
    notifications?: NotificationRecipientUncheckedCreateNestedManyWithoutCustomerInput
    activityLogs?: CustomerActivityLogUncheckedCreateNestedManyWithoutCustomerInput
    otpChallenges?: CustomerOtpUncheckedCreateNestedManyWithoutCustomerInput
  }

  export type CustomerCreateOrConnectWithoutOrdersInput = {
    where: CustomerWhereUniqueInput
    create: XOR<CustomerCreateWithoutOrdersInput, CustomerUncheckedCreateWithoutOrdersInput>
  }

  export type BranchCreateWithoutOrdersInput = {
    id?: string
    name: string
    address?: string | null
    phone?: string | null
    isActive?: boolean
    city?: CityCreateNestedOneWithoutBranchesInput
    adminUsers?: AdminUserCreateNestedManyWithoutBranchInput
    allocations?: BranchAllocationCreateNestedManyWithoutBranchInput
  }

  export type BranchUncheckedCreateWithoutOrdersInput = {
    id?: string
    name: string
    address?: string | null
    phone?: string | null
    isActive?: boolean
    cityId?: string | null
    adminUsers?: AdminUserUncheckedCreateNestedManyWithoutBranchInput
    allocations?: BranchAllocationUncheckedCreateNestedManyWithoutBranchInput
  }

  export type BranchCreateOrConnectWithoutOrdersInput = {
    where: BranchWhereUniqueInput
    create: XOR<BranchCreateWithoutOrdersInput, BranchUncheckedCreateWithoutOrdersInput>
  }

  export type OrderItemCreateWithoutOrderInput = {
    id?: string
    quantity: number
    rashWeightGramsSnapshot: Decimal | DecimalJsLike | number | string
    wagePercentSnapshot: Decimal | DecimalJsLike | number | string
    discountPercentSnapshot?: Decimal | DecimalJsLike | number | string
    computedWeightGrams: Decimal | DecimalJsLike | number | string
    flatRialCharge?: Decimal | DecimalJsLike | number | string
    productVariant: ProductVariantCreateNestedOneWithoutOrderItemsInput
  }

  export type OrderItemUncheckedCreateWithoutOrderInput = {
    id?: string
    productVariantId: string
    quantity: number
    rashWeightGramsSnapshot: Decimal | DecimalJsLike | number | string
    wagePercentSnapshot: Decimal | DecimalJsLike | number | string
    discountPercentSnapshot?: Decimal | DecimalJsLike | number | string
    computedWeightGrams: Decimal | DecimalJsLike | number | string
    flatRialCharge?: Decimal | DecimalJsLike | number | string
  }

  export type OrderItemCreateOrConnectWithoutOrderInput = {
    where: OrderItemWhereUniqueInput
    create: XOR<OrderItemCreateWithoutOrderInput, OrderItemUncheckedCreateWithoutOrderInput>
  }

  export type OrderItemCreateManyOrderInputEnvelope = {
    data: OrderItemCreateManyOrderInput | OrderItemCreateManyOrderInput[]
    skipDuplicates?: boolean
  }

  export type OrderStatusEventCreateWithoutOrderInput = {
    id?: string
    fromStatus?: $Enums.OrderStatus | null
    toStatus: $Enums.OrderStatus
    note?: string | null
    createdAt?: Date | string
    actorAdminUser?: AdminUserCreateNestedOneWithoutOrderStatusEventsInput
  }

  export type OrderStatusEventUncheckedCreateWithoutOrderInput = {
    id?: string
    fromStatus?: $Enums.OrderStatus | null
    toStatus: $Enums.OrderStatus
    note?: string | null
    actorAdminUserId?: string | null
    createdAt?: Date | string
  }

  export type OrderStatusEventCreateOrConnectWithoutOrderInput = {
    where: OrderStatusEventWhereUniqueInput
    create: XOR<OrderStatusEventCreateWithoutOrderInput, OrderStatusEventUncheckedCreateWithoutOrderInput>
  }

  export type OrderStatusEventCreateManyOrderInputEnvelope = {
    data: OrderStatusEventCreateManyOrderInput | OrderStatusEventCreateManyOrderInput[]
    skipDuplicates?: boolean
  }

  export type LedgerEntryCreateWithoutOrderInput = {
    id?: string
    currency: $Enums.LedgerCurrency
    direction: $Enums.LedgerDirection
    sourceType: $Enums.LedgerSourceType
    amount: Decimal | DecimalJsLike | number | string
    karatPerMille?: number | null
    pricePerGramRialAtEntry?: Decimal | DecimalJsLike | number | string | null
    confirmed?: boolean
    confirmedAt?: Date | string | null
    labName?: string | null
    hallmark?: string | null
    accountName?: string | null
    bankName?: string | null
    transferTo?: string | null
    originalValue?: Decimal | DecimalJsLike | number | string | null
    priceRial?: Decimal | DecimalJsLike | number | string | null
    receivedAt?: Date | string | null
    note?: string | null
    createdAt?: Date | string
    customer: CustomerCreateNestedOneWithoutLedgerEntriesInput
    postedByAdminUser?: AdminUserCreateNestedOneWithoutPostedLedgerEntriesInput
  }

  export type LedgerEntryUncheckedCreateWithoutOrderInput = {
    id?: string
    customerId: string
    currency: $Enums.LedgerCurrency
    direction: $Enums.LedgerDirection
    sourceType: $Enums.LedgerSourceType
    amount: Decimal | DecimalJsLike | number | string
    karatPerMille?: number | null
    pricePerGramRialAtEntry?: Decimal | DecimalJsLike | number | string | null
    confirmed?: boolean
    confirmedAt?: Date | string | null
    postedByAdminUserId?: string | null
    labName?: string | null
    hallmark?: string | null
    accountName?: string | null
    bankName?: string | null
    transferTo?: string | null
    originalValue?: Decimal | DecimalJsLike | number | string | null
    priceRial?: Decimal | DecimalJsLike | number | string | null
    receivedAt?: Date | string | null
    note?: string | null
    createdAt?: Date | string
  }

  export type LedgerEntryCreateOrConnectWithoutOrderInput = {
    where: LedgerEntryWhereUniqueInput
    create: XOR<LedgerEntryCreateWithoutOrderInput, LedgerEntryUncheckedCreateWithoutOrderInput>
  }

  export type LedgerEntryCreateManyOrderInputEnvelope = {
    data: LedgerEntryCreateManyOrderInput | LedgerEntryCreateManyOrderInput[]
    skipDuplicates?: boolean
  }

  export type PreOrderCreateWithoutConvertedOrderInput = {
    id?: string
    status?: $Enums.PreOrderStatus
    designImageUrl?: string | null
    colorName?: string | null
    sizeSpec?: string | null
    stoneColor?: string | null
    minaColor?: string | null
    estimatedWeightGrams?: Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: Decimal | DecimalJsLike | number | string | null
    description?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    customer: CustomerCreateNestedOneWithoutPreOrdersInput
    city?: CityCreateNestedOneWithoutPreOrdersInput
    workshop?: WorkshopCreateNestedOneWithoutPreOrdersInput
    statusEvents?: PreOrderStatusEventCreateNestedManyWithoutPreOrderInput
  }

  export type PreOrderUncheckedCreateWithoutConvertedOrderInput = {
    id?: string
    customerId: string
    cityId?: string | null
    workshopId?: string | null
    status?: $Enums.PreOrderStatus
    designImageUrl?: string | null
    colorName?: string | null
    sizeSpec?: string | null
    stoneColor?: string | null
    minaColor?: string | null
    estimatedWeightGrams?: Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: Decimal | DecimalJsLike | number | string | null
    description?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    statusEvents?: PreOrderStatusEventUncheckedCreateNestedManyWithoutPreOrderInput
  }

  export type PreOrderCreateOrConnectWithoutConvertedOrderInput = {
    where: PreOrderWhereUniqueInput
    create: XOR<PreOrderCreateWithoutConvertedOrderInput, PreOrderUncheckedCreateWithoutConvertedOrderInput>
  }

  export type CustomerUpsertWithoutOrdersInput = {
    update: XOR<CustomerUpdateWithoutOrdersInput, CustomerUncheckedUpdateWithoutOrdersInput>
    create: XOR<CustomerCreateWithoutOrdersInput, CustomerUncheckedCreateWithoutOrdersInput>
    where?: CustomerWhereInput
  }

  export type CustomerUpdateToOneWithWhereWithoutOrdersInput = {
    where?: CustomerWhereInput
    data: XOR<CustomerUpdateWithoutOrdersInput, CustomerUncheckedUpdateWithoutOrdersInput>
  }

  export type CustomerUpdateWithoutOrdersInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutCustomersNestedInput
    referredByAgent?: AdminUserUpdateOneWithoutReferredCustomersNestedInput
    salesExpertTradingFor?: SalesExpertProfileUpdateOneWithoutTradingCustomerNestedInput
    avatarFile?: UploadedFileUpdateOneWithoutCustomerAvatarsNestedInput
    addresses?: CustomerAddressUpdateManyWithoutCustomerNestedInput
    preOrders?: PreOrderUpdateManyWithoutCustomerNestedInput
    ledgerEntries?: LedgerEntryUpdateManyWithoutCustomerNestedInput
    walletBonuses?: WalletBonusUpdateManyWithoutCustomerNestedInput
    comments?: CommentUpdateManyWithoutCustomerNestedInput
    promotions?: PromotionUpdateManyWithoutCustomerNestedInput
    notifications?: NotificationRecipientUpdateManyWithoutCustomerNestedInput
    activityLogs?: CustomerActivityLogUpdateManyWithoutCustomerNestedInput
    otpChallenges?: CustomerOtpUpdateManyWithoutCustomerNestedInput
  }

  export type CustomerUncheckedUpdateWithoutOrdersInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredByAgentId?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    salesExpertTradingFor?: SalesExpertProfileUncheckedUpdateOneWithoutTradingCustomerNestedInput
    addresses?: CustomerAddressUncheckedUpdateManyWithoutCustomerNestedInput
    preOrders?: PreOrderUncheckedUpdateManyWithoutCustomerNestedInput
    ledgerEntries?: LedgerEntryUncheckedUpdateManyWithoutCustomerNestedInput
    walletBonuses?: WalletBonusUncheckedUpdateManyWithoutCustomerNestedInput
    comments?: CommentUncheckedUpdateManyWithoutCustomerNestedInput
    promotions?: PromotionUncheckedUpdateManyWithoutCustomerNestedInput
    notifications?: NotificationRecipientUncheckedUpdateManyWithoutCustomerNestedInput
    activityLogs?: CustomerActivityLogUncheckedUpdateManyWithoutCustomerNestedInput
    otpChallenges?: CustomerOtpUncheckedUpdateManyWithoutCustomerNestedInput
  }

  export type BranchUpsertWithoutOrdersInput = {
    update: XOR<BranchUpdateWithoutOrdersInput, BranchUncheckedUpdateWithoutOrdersInput>
    create: XOR<BranchCreateWithoutOrdersInput, BranchUncheckedCreateWithoutOrdersInput>
    where?: BranchWhereInput
  }

  export type BranchUpdateToOneWithWhereWithoutOrdersInput = {
    where?: BranchWhereInput
    data: XOR<BranchUpdateWithoutOrdersInput, BranchUncheckedUpdateWithoutOrdersInput>
  }

  export type BranchUpdateWithoutOrdersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    city?: CityUpdateOneWithoutBranchesNestedInput
    adminUsers?: AdminUserUpdateManyWithoutBranchNestedInput
    allocations?: BranchAllocationUpdateManyWithoutBranchNestedInput
  }

  export type BranchUncheckedUpdateWithoutOrdersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    adminUsers?: AdminUserUncheckedUpdateManyWithoutBranchNestedInput
    allocations?: BranchAllocationUncheckedUpdateManyWithoutBranchNestedInput
  }

  export type OrderItemUpsertWithWhereUniqueWithoutOrderInput = {
    where: OrderItemWhereUniqueInput
    update: XOR<OrderItemUpdateWithoutOrderInput, OrderItemUncheckedUpdateWithoutOrderInput>
    create: XOR<OrderItemCreateWithoutOrderInput, OrderItemUncheckedCreateWithoutOrderInput>
  }

  export type OrderItemUpdateWithWhereUniqueWithoutOrderInput = {
    where: OrderItemWhereUniqueInput
    data: XOR<OrderItemUpdateWithoutOrderInput, OrderItemUncheckedUpdateWithoutOrderInput>
  }

  export type OrderItemUpdateManyWithWhereWithoutOrderInput = {
    where: OrderItemScalarWhereInput
    data: XOR<OrderItemUpdateManyMutationInput, OrderItemUncheckedUpdateManyWithoutOrderInput>
  }

  export type OrderStatusEventUpsertWithWhereUniqueWithoutOrderInput = {
    where: OrderStatusEventWhereUniqueInput
    update: XOR<OrderStatusEventUpdateWithoutOrderInput, OrderStatusEventUncheckedUpdateWithoutOrderInput>
    create: XOR<OrderStatusEventCreateWithoutOrderInput, OrderStatusEventUncheckedCreateWithoutOrderInput>
  }

  export type OrderStatusEventUpdateWithWhereUniqueWithoutOrderInput = {
    where: OrderStatusEventWhereUniqueInput
    data: XOR<OrderStatusEventUpdateWithoutOrderInput, OrderStatusEventUncheckedUpdateWithoutOrderInput>
  }

  export type OrderStatusEventUpdateManyWithWhereWithoutOrderInput = {
    where: OrderStatusEventScalarWhereInput
    data: XOR<OrderStatusEventUpdateManyMutationInput, OrderStatusEventUncheckedUpdateManyWithoutOrderInput>
  }

  export type LedgerEntryUpsertWithWhereUniqueWithoutOrderInput = {
    where: LedgerEntryWhereUniqueInput
    update: XOR<LedgerEntryUpdateWithoutOrderInput, LedgerEntryUncheckedUpdateWithoutOrderInput>
    create: XOR<LedgerEntryCreateWithoutOrderInput, LedgerEntryUncheckedCreateWithoutOrderInput>
  }

  export type LedgerEntryUpdateWithWhereUniqueWithoutOrderInput = {
    where: LedgerEntryWhereUniqueInput
    data: XOR<LedgerEntryUpdateWithoutOrderInput, LedgerEntryUncheckedUpdateWithoutOrderInput>
  }

  export type LedgerEntryUpdateManyWithWhereWithoutOrderInput = {
    where: LedgerEntryScalarWhereInput
    data: XOR<LedgerEntryUpdateManyMutationInput, LedgerEntryUncheckedUpdateManyWithoutOrderInput>
  }

  export type PreOrderUpsertWithoutConvertedOrderInput = {
    update: XOR<PreOrderUpdateWithoutConvertedOrderInput, PreOrderUncheckedUpdateWithoutConvertedOrderInput>
    create: XOR<PreOrderCreateWithoutConvertedOrderInput, PreOrderUncheckedCreateWithoutConvertedOrderInput>
    where?: PreOrderWhereInput
  }

  export type PreOrderUpdateToOneWithWhereWithoutConvertedOrderInput = {
    where?: PreOrderWhereInput
    data: XOR<PreOrderUpdateWithoutConvertedOrderInput, PreOrderUncheckedUpdateWithoutConvertedOrderInput>
  }

  export type PreOrderUpdateWithoutConvertedOrderInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: EnumPreOrderStatusFieldUpdateOperationsInput | $Enums.PreOrderStatus
    designImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    colorName?: NullableStringFieldUpdateOperationsInput | string | null
    sizeSpec?: NullableStringFieldUpdateOperationsInput | string | null
    stoneColor?: NullableStringFieldUpdateOperationsInput | string | null
    minaColor?: NullableStringFieldUpdateOperationsInput | string | null
    estimatedWeightGrams?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    customer?: CustomerUpdateOneRequiredWithoutPreOrdersNestedInput
    city?: CityUpdateOneWithoutPreOrdersNestedInput
    workshop?: WorkshopUpdateOneWithoutPreOrdersNestedInput
    statusEvents?: PreOrderStatusEventUpdateManyWithoutPreOrderNestedInput
  }

  export type PreOrderUncheckedUpdateWithoutConvertedOrderInput = {
    id?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    workshopId?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPreOrderStatusFieldUpdateOperationsInput | $Enums.PreOrderStatus
    designImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    colorName?: NullableStringFieldUpdateOperationsInput | string | null
    sizeSpec?: NullableStringFieldUpdateOperationsInput | string | null
    stoneColor?: NullableStringFieldUpdateOperationsInput | string | null
    minaColor?: NullableStringFieldUpdateOperationsInput | string | null
    estimatedWeightGrams?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    statusEvents?: PreOrderStatusEventUncheckedUpdateManyWithoutPreOrderNestedInput
  }

  export type OrderCreateWithoutItemsInput = {
    id?: string
    orderNumber: string
    channel?: $Enums.OrderChannel
    status?: $Enums.OrderStatus
    totalGoldWeightGrams: Decimal | DecimalJsLike | number | string
    wageWeightGrams: Decimal | DecimalJsLike | number | string
    flatRialCharge?: Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: boolean
    deliveredAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    customer: CustomerCreateNestedOneWithoutOrdersInput
    branch?: BranchCreateNestedOneWithoutOrdersInput
    statusEvents?: OrderStatusEventCreateNestedManyWithoutOrderInput
    ledgerEntries?: LedgerEntryCreateNestedManyWithoutOrderInput
    convertedFromPreOrder?: PreOrderCreateNestedOneWithoutConvertedOrderInput
  }

  export type OrderUncheckedCreateWithoutItemsInput = {
    id?: string
    orderNumber: string
    customerId: string
    branchId?: string | null
    channel?: $Enums.OrderChannel
    status?: $Enums.OrderStatus
    totalGoldWeightGrams: Decimal | DecimalJsLike | number | string
    wageWeightGrams: Decimal | DecimalJsLike | number | string
    flatRialCharge?: Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: boolean
    deliveredAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    statusEvents?: OrderStatusEventUncheckedCreateNestedManyWithoutOrderInput
    ledgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutOrderInput
    convertedFromPreOrder?: PreOrderUncheckedCreateNestedOneWithoutConvertedOrderInput
  }

  export type OrderCreateOrConnectWithoutItemsInput = {
    where: OrderWhereUniqueInput
    create: XOR<OrderCreateWithoutItemsInput, OrderUncheckedCreateWithoutItemsInput>
  }

  export type ProductVariantCreateWithoutOrderItemsInput = {
    id?: string
    title: string
    sku?: string | null
    rashWeightGrams: Decimal | DecimalJsLike | number | string
    defaultWagePercent: Decimal | DecimalJsLike | number | string
    qty?: number
    isPreOrder?: boolean
    isActive?: boolean
    product: ProductCreateNestedOneWithoutVariantsInput
    image?: ProductImageCreateNestedOneWithoutVariantsInput
  }

  export type ProductVariantUncheckedCreateWithoutOrderItemsInput = {
    id?: string
    productId: string
    title: string
    sku?: string | null
    rashWeightGrams: Decimal | DecimalJsLike | number | string
    defaultWagePercent: Decimal | DecimalJsLike | number | string
    qty?: number
    isPreOrder?: boolean
    isActive?: boolean
    imageId?: string | null
  }

  export type ProductVariantCreateOrConnectWithoutOrderItemsInput = {
    where: ProductVariantWhereUniqueInput
    create: XOR<ProductVariantCreateWithoutOrderItemsInput, ProductVariantUncheckedCreateWithoutOrderItemsInput>
  }

  export type OrderUpsertWithoutItemsInput = {
    update: XOR<OrderUpdateWithoutItemsInput, OrderUncheckedUpdateWithoutItemsInput>
    create: XOR<OrderCreateWithoutItemsInput, OrderUncheckedCreateWithoutItemsInput>
    where?: OrderWhereInput
  }

  export type OrderUpdateToOneWithWhereWithoutItemsInput = {
    where?: OrderWhereInput
    data: XOR<OrderUpdateWithoutItemsInput, OrderUncheckedUpdateWithoutItemsInput>
  }

  export type OrderUpdateWithoutItemsInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderNumber?: StringFieldUpdateOperationsInput | string
    channel?: EnumOrderChannelFieldUpdateOperationsInput | $Enums.OrderChannel
    status?: EnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus
    totalGoldWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    wageWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: BoolFieldUpdateOperationsInput | boolean
    deliveredAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    customer?: CustomerUpdateOneRequiredWithoutOrdersNestedInput
    branch?: BranchUpdateOneWithoutOrdersNestedInput
    statusEvents?: OrderStatusEventUpdateManyWithoutOrderNestedInput
    ledgerEntries?: LedgerEntryUpdateManyWithoutOrderNestedInput
    convertedFromPreOrder?: PreOrderUpdateOneWithoutConvertedOrderNestedInput
  }

  export type OrderUncheckedUpdateWithoutItemsInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderNumber?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    branchId?: NullableStringFieldUpdateOperationsInput | string | null
    channel?: EnumOrderChannelFieldUpdateOperationsInput | $Enums.OrderChannel
    status?: EnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus
    totalGoldWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    wageWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: BoolFieldUpdateOperationsInput | boolean
    deliveredAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    statusEvents?: OrderStatusEventUncheckedUpdateManyWithoutOrderNestedInput
    ledgerEntries?: LedgerEntryUncheckedUpdateManyWithoutOrderNestedInput
    convertedFromPreOrder?: PreOrderUncheckedUpdateOneWithoutConvertedOrderNestedInput
  }

  export type ProductVariantUpsertWithoutOrderItemsInput = {
    update: XOR<ProductVariantUpdateWithoutOrderItemsInput, ProductVariantUncheckedUpdateWithoutOrderItemsInput>
    create: XOR<ProductVariantCreateWithoutOrderItemsInput, ProductVariantUncheckedCreateWithoutOrderItemsInput>
    where?: ProductVariantWhereInput
  }

  export type ProductVariantUpdateToOneWithWhereWithoutOrderItemsInput = {
    where?: ProductVariantWhereInput
    data: XOR<ProductVariantUpdateWithoutOrderItemsInput, ProductVariantUncheckedUpdateWithoutOrderItemsInput>
  }

  export type ProductVariantUpdateWithoutOrderItemsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    sku?: NullableStringFieldUpdateOperationsInput | string | null
    rashWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    defaultWagePercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    qty?: IntFieldUpdateOperationsInput | number
    isPreOrder?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    product?: ProductUpdateOneRequiredWithoutVariantsNestedInput
    image?: ProductImageUpdateOneWithoutVariantsNestedInput
  }

  export type ProductVariantUncheckedUpdateWithoutOrderItemsInput = {
    id?: StringFieldUpdateOperationsInput | string
    productId?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    sku?: NullableStringFieldUpdateOperationsInput | string | null
    rashWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    defaultWagePercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    qty?: IntFieldUpdateOperationsInput | number
    isPreOrder?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    imageId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type OrderCreateWithoutStatusEventsInput = {
    id?: string
    orderNumber: string
    channel?: $Enums.OrderChannel
    status?: $Enums.OrderStatus
    totalGoldWeightGrams: Decimal | DecimalJsLike | number | string
    wageWeightGrams: Decimal | DecimalJsLike | number | string
    flatRialCharge?: Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: boolean
    deliveredAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    customer: CustomerCreateNestedOneWithoutOrdersInput
    branch?: BranchCreateNestedOneWithoutOrdersInput
    items?: OrderItemCreateNestedManyWithoutOrderInput
    ledgerEntries?: LedgerEntryCreateNestedManyWithoutOrderInput
    convertedFromPreOrder?: PreOrderCreateNestedOneWithoutConvertedOrderInput
  }

  export type OrderUncheckedCreateWithoutStatusEventsInput = {
    id?: string
    orderNumber: string
    customerId: string
    branchId?: string | null
    channel?: $Enums.OrderChannel
    status?: $Enums.OrderStatus
    totalGoldWeightGrams: Decimal | DecimalJsLike | number | string
    wageWeightGrams: Decimal | DecimalJsLike | number | string
    flatRialCharge?: Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: boolean
    deliveredAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    items?: OrderItemUncheckedCreateNestedManyWithoutOrderInput
    ledgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutOrderInput
    convertedFromPreOrder?: PreOrderUncheckedCreateNestedOneWithoutConvertedOrderInput
  }

  export type OrderCreateOrConnectWithoutStatusEventsInput = {
    where: OrderWhereUniqueInput
    create: XOR<OrderCreateWithoutStatusEventsInput, OrderUncheckedCreateWithoutStatusEventsInput>
  }

  export type AdminUserCreateWithoutOrderStatusEventsInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    userType?: UserTypeCreateNestedOneWithoutAdminUsersInput
    branch?: BranchCreateNestedOneWithoutAdminUsersInput
    avatarFile?: UploadedFileCreateNestedOneWithoutAdminUserAvatarsInput
    referredCustomers?: CustomerCreateNestedManyWithoutReferredByAgentInput
    supervisedWorkshops?: WorkshopCreateNestedManyWithoutSupervisorInput
    branchAllocations?: BranchAllocationCreateNestedManyWithoutAllocatorAdminUserInput
    postedLedgerEntries?: LedgerEntryCreateNestedManyWithoutPostedByAdminUserInput
    preOrderStatusEvents?: PreOrderStatusEventCreateNestedManyWithoutActorAdminUserInput
    sentSmsMessages?: SmsMessageCreateNestedManyWithoutSentByAdminUserInput
    sentNotifications?: NotificationCreateNestedManyWithoutSentByAdminUserInput
    uploadedFiles?: UploadedFileCreateNestedManyWithoutUploadedByAdminUserInput
    salesExpertProfile?: SalesExpertProfileCreateNestedOneWithoutAdminUserInput
    sessions?: AdminSessionCreateNestedManyWithoutAdminUserInput
  }

  export type AdminUserUncheckedCreateWithoutOrderStatusEventsInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    userTypeId?: number | null
    branchId?: string | null
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    avatarFileId?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    referredCustomers?: CustomerUncheckedCreateNestedManyWithoutReferredByAgentInput
    supervisedWorkshops?: WorkshopUncheckedCreateNestedManyWithoutSupervisorInput
    branchAllocations?: BranchAllocationUncheckedCreateNestedManyWithoutAllocatorAdminUserInput
    postedLedgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutPostedByAdminUserInput
    preOrderStatusEvents?: PreOrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput
    sentSmsMessages?: SmsMessageUncheckedCreateNestedManyWithoutSentByAdminUserInput
    sentNotifications?: NotificationUncheckedCreateNestedManyWithoutSentByAdminUserInput
    uploadedFiles?: UploadedFileUncheckedCreateNestedManyWithoutUploadedByAdminUserInput
    salesExpertProfile?: SalesExpertProfileUncheckedCreateNestedOneWithoutAdminUserInput
    sessions?: AdminSessionUncheckedCreateNestedManyWithoutAdminUserInput
  }

  export type AdminUserCreateOrConnectWithoutOrderStatusEventsInput = {
    where: AdminUserWhereUniqueInput
    create: XOR<AdminUserCreateWithoutOrderStatusEventsInput, AdminUserUncheckedCreateWithoutOrderStatusEventsInput>
  }

  export type OrderUpsertWithoutStatusEventsInput = {
    update: XOR<OrderUpdateWithoutStatusEventsInput, OrderUncheckedUpdateWithoutStatusEventsInput>
    create: XOR<OrderCreateWithoutStatusEventsInput, OrderUncheckedCreateWithoutStatusEventsInput>
    where?: OrderWhereInput
  }

  export type OrderUpdateToOneWithWhereWithoutStatusEventsInput = {
    where?: OrderWhereInput
    data: XOR<OrderUpdateWithoutStatusEventsInput, OrderUncheckedUpdateWithoutStatusEventsInput>
  }

  export type OrderUpdateWithoutStatusEventsInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderNumber?: StringFieldUpdateOperationsInput | string
    channel?: EnumOrderChannelFieldUpdateOperationsInput | $Enums.OrderChannel
    status?: EnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus
    totalGoldWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    wageWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: BoolFieldUpdateOperationsInput | boolean
    deliveredAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    customer?: CustomerUpdateOneRequiredWithoutOrdersNestedInput
    branch?: BranchUpdateOneWithoutOrdersNestedInput
    items?: OrderItemUpdateManyWithoutOrderNestedInput
    ledgerEntries?: LedgerEntryUpdateManyWithoutOrderNestedInput
    convertedFromPreOrder?: PreOrderUpdateOneWithoutConvertedOrderNestedInput
  }

  export type OrderUncheckedUpdateWithoutStatusEventsInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderNumber?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    branchId?: NullableStringFieldUpdateOperationsInput | string | null
    channel?: EnumOrderChannelFieldUpdateOperationsInput | $Enums.OrderChannel
    status?: EnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus
    totalGoldWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    wageWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: BoolFieldUpdateOperationsInput | boolean
    deliveredAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    items?: OrderItemUncheckedUpdateManyWithoutOrderNestedInput
    ledgerEntries?: LedgerEntryUncheckedUpdateManyWithoutOrderNestedInput
    convertedFromPreOrder?: PreOrderUncheckedUpdateOneWithoutConvertedOrderNestedInput
  }

  export type AdminUserUpsertWithoutOrderStatusEventsInput = {
    update: XOR<AdminUserUpdateWithoutOrderStatusEventsInput, AdminUserUncheckedUpdateWithoutOrderStatusEventsInput>
    create: XOR<AdminUserCreateWithoutOrderStatusEventsInput, AdminUserUncheckedCreateWithoutOrderStatusEventsInput>
    where?: AdminUserWhereInput
  }

  export type AdminUserUpdateToOneWithWhereWithoutOrderStatusEventsInput = {
    where?: AdminUserWhereInput
    data: XOR<AdminUserUpdateWithoutOrderStatusEventsInput, AdminUserUncheckedUpdateWithoutOrderStatusEventsInput>
  }

  export type AdminUserUpdateWithoutOrderStatusEventsInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    userType?: UserTypeUpdateOneWithoutAdminUsersNestedInput
    branch?: BranchUpdateOneWithoutAdminUsersNestedInput
    avatarFile?: UploadedFileUpdateOneWithoutAdminUserAvatarsNestedInput
    referredCustomers?: CustomerUpdateManyWithoutReferredByAgentNestedInput
    supervisedWorkshops?: WorkshopUpdateManyWithoutSupervisorNestedInput
    branchAllocations?: BranchAllocationUpdateManyWithoutAllocatorAdminUserNestedInput
    postedLedgerEntries?: LedgerEntryUpdateManyWithoutPostedByAdminUserNestedInput
    preOrderStatusEvents?: PreOrderStatusEventUpdateManyWithoutActorAdminUserNestedInput
    sentSmsMessages?: SmsMessageUpdateManyWithoutSentByAdminUserNestedInput
    sentNotifications?: NotificationUpdateManyWithoutSentByAdminUserNestedInput
    uploadedFiles?: UploadedFileUpdateManyWithoutUploadedByAdminUserNestedInput
    salesExpertProfile?: SalesExpertProfileUpdateOneWithoutAdminUserNestedInput
    sessions?: AdminSessionUpdateManyWithoutAdminUserNestedInput
  }

  export type AdminUserUncheckedUpdateWithoutOrderStatusEventsInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    userTypeId?: NullableIntFieldUpdateOperationsInput | number | null
    branchId?: NullableStringFieldUpdateOperationsInput | string | null
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredCustomers?: CustomerUncheckedUpdateManyWithoutReferredByAgentNestedInput
    supervisedWorkshops?: WorkshopUncheckedUpdateManyWithoutSupervisorNestedInput
    branchAllocations?: BranchAllocationUncheckedUpdateManyWithoutAllocatorAdminUserNestedInput
    postedLedgerEntries?: LedgerEntryUncheckedUpdateManyWithoutPostedByAdminUserNestedInput
    preOrderStatusEvents?: PreOrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput
    sentSmsMessages?: SmsMessageUncheckedUpdateManyWithoutSentByAdminUserNestedInput
    sentNotifications?: NotificationUncheckedUpdateManyWithoutSentByAdminUserNestedInput
    uploadedFiles?: UploadedFileUncheckedUpdateManyWithoutUploadedByAdminUserNestedInput
    salesExpertProfile?: SalesExpertProfileUncheckedUpdateOneWithoutAdminUserNestedInput
    sessions?: AdminSessionUncheckedUpdateManyWithoutAdminUserNestedInput
  }

  export type CustomerCreateWithoutPreOrdersInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    city?: CityCreateNestedOneWithoutCustomersInput
    referredByAgent?: AdminUserCreateNestedOneWithoutReferredCustomersInput
    salesExpertTradingFor?: SalesExpertProfileCreateNestedOneWithoutTradingCustomerInput
    avatarFile?: UploadedFileCreateNestedOneWithoutCustomerAvatarsInput
    addresses?: CustomerAddressCreateNestedManyWithoutCustomerInput
    orders?: OrderCreateNestedManyWithoutCustomerInput
    ledgerEntries?: LedgerEntryCreateNestedManyWithoutCustomerInput
    walletBonuses?: WalletBonusCreateNestedManyWithoutCustomerInput
    comments?: CommentCreateNestedManyWithoutCustomerInput
    promotions?: PromotionCreateNestedManyWithoutCustomerInput
    notifications?: NotificationRecipientCreateNestedManyWithoutCustomerInput
    activityLogs?: CustomerActivityLogCreateNestedManyWithoutCustomerInput
    otpChallenges?: CustomerOtpCreateNestedManyWithoutCustomerInput
  }

  export type CustomerUncheckedCreateWithoutPreOrdersInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    cityId?: string | null
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    referredByAgentId?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    avatarFileId?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    salesExpertTradingFor?: SalesExpertProfileUncheckedCreateNestedOneWithoutTradingCustomerInput
    addresses?: CustomerAddressUncheckedCreateNestedManyWithoutCustomerInput
    orders?: OrderUncheckedCreateNestedManyWithoutCustomerInput
    ledgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutCustomerInput
    walletBonuses?: WalletBonusUncheckedCreateNestedManyWithoutCustomerInput
    comments?: CommentUncheckedCreateNestedManyWithoutCustomerInput
    promotions?: PromotionUncheckedCreateNestedManyWithoutCustomerInput
    notifications?: NotificationRecipientUncheckedCreateNestedManyWithoutCustomerInput
    activityLogs?: CustomerActivityLogUncheckedCreateNestedManyWithoutCustomerInput
    otpChallenges?: CustomerOtpUncheckedCreateNestedManyWithoutCustomerInput
  }

  export type CustomerCreateOrConnectWithoutPreOrdersInput = {
    where: CustomerWhereUniqueInput
    create: XOR<CustomerCreateWithoutPreOrdersInput, CustomerUncheckedCreateWithoutPreOrdersInput>
  }

  export type CityCreateWithoutPreOrdersInput = {
    id?: string
    name: string
    province?: string | null
    percent?: Decimal | DecimalJsLike | number | string | null
    percentAux?: Decimal | DecimalJsLike | number | string | null
    customers?: CustomerCreateNestedManyWithoutCityInput
    addresses?: CustomerAddressCreateNestedManyWithoutCityInput
    branches?: BranchCreateNestedManyWithoutCityInput
    salesExpertProfiles?: SalesExpertProfileCreateNestedManyWithoutCityInput
  }

  export type CityUncheckedCreateWithoutPreOrdersInput = {
    id?: string
    name: string
    province?: string | null
    percent?: Decimal | DecimalJsLike | number | string | null
    percentAux?: Decimal | DecimalJsLike | number | string | null
    customers?: CustomerUncheckedCreateNestedManyWithoutCityInput
    addresses?: CustomerAddressUncheckedCreateNestedManyWithoutCityInput
    branches?: BranchUncheckedCreateNestedManyWithoutCityInput
    salesExpertProfiles?: SalesExpertProfileUncheckedCreateNestedManyWithoutCityInput
  }

  export type CityCreateOrConnectWithoutPreOrdersInput = {
    where: CityWhereUniqueInput
    create: XOR<CityCreateWithoutPreOrdersInput, CityUncheckedCreateWithoutPreOrdersInput>
  }

  export type WorkshopCreateWithoutPreOrdersInput = {
    id?: string
    name: string
    address?: string | null
    phone?: string | null
    isActive?: boolean
    supervisor?: AdminUserCreateNestedOneWithoutSupervisedWorkshopsInput
  }

  export type WorkshopUncheckedCreateWithoutPreOrdersInput = {
    id?: string
    name: string
    address?: string | null
    phone?: string | null
    supervisorId?: string | null
    isActive?: boolean
  }

  export type WorkshopCreateOrConnectWithoutPreOrdersInput = {
    where: WorkshopWhereUniqueInput
    create: XOR<WorkshopCreateWithoutPreOrdersInput, WorkshopUncheckedCreateWithoutPreOrdersInput>
  }

  export type OrderCreateWithoutConvertedFromPreOrderInput = {
    id?: string
    orderNumber: string
    channel?: $Enums.OrderChannel
    status?: $Enums.OrderStatus
    totalGoldWeightGrams: Decimal | DecimalJsLike | number | string
    wageWeightGrams: Decimal | DecimalJsLike | number | string
    flatRialCharge?: Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: boolean
    deliveredAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    customer: CustomerCreateNestedOneWithoutOrdersInput
    branch?: BranchCreateNestedOneWithoutOrdersInput
    items?: OrderItemCreateNestedManyWithoutOrderInput
    statusEvents?: OrderStatusEventCreateNestedManyWithoutOrderInput
    ledgerEntries?: LedgerEntryCreateNestedManyWithoutOrderInput
  }

  export type OrderUncheckedCreateWithoutConvertedFromPreOrderInput = {
    id?: string
    orderNumber: string
    customerId: string
    branchId?: string | null
    channel?: $Enums.OrderChannel
    status?: $Enums.OrderStatus
    totalGoldWeightGrams: Decimal | DecimalJsLike | number | string
    wageWeightGrams: Decimal | DecimalJsLike | number | string
    flatRialCharge?: Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: boolean
    deliveredAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    items?: OrderItemUncheckedCreateNestedManyWithoutOrderInput
    statusEvents?: OrderStatusEventUncheckedCreateNestedManyWithoutOrderInput
    ledgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutOrderInput
  }

  export type OrderCreateOrConnectWithoutConvertedFromPreOrderInput = {
    where: OrderWhereUniqueInput
    create: XOR<OrderCreateWithoutConvertedFromPreOrderInput, OrderUncheckedCreateWithoutConvertedFromPreOrderInput>
  }

  export type PreOrderStatusEventCreateWithoutPreOrderInput = {
    id?: string
    changes: JsonNullValueInput | InputJsonValue
    ipAddress?: string | null
    createdAt?: Date | string
    actorAdminUser?: AdminUserCreateNestedOneWithoutPreOrderStatusEventsInput
  }

  export type PreOrderStatusEventUncheckedCreateWithoutPreOrderInput = {
    id?: string
    changes: JsonNullValueInput | InputJsonValue
    actorAdminUserId?: string | null
    ipAddress?: string | null
    createdAt?: Date | string
  }

  export type PreOrderStatusEventCreateOrConnectWithoutPreOrderInput = {
    where: PreOrderStatusEventWhereUniqueInput
    create: XOR<PreOrderStatusEventCreateWithoutPreOrderInput, PreOrderStatusEventUncheckedCreateWithoutPreOrderInput>
  }

  export type PreOrderStatusEventCreateManyPreOrderInputEnvelope = {
    data: PreOrderStatusEventCreateManyPreOrderInput | PreOrderStatusEventCreateManyPreOrderInput[]
    skipDuplicates?: boolean
  }

  export type CustomerUpsertWithoutPreOrdersInput = {
    update: XOR<CustomerUpdateWithoutPreOrdersInput, CustomerUncheckedUpdateWithoutPreOrdersInput>
    create: XOR<CustomerCreateWithoutPreOrdersInput, CustomerUncheckedCreateWithoutPreOrdersInput>
    where?: CustomerWhereInput
  }

  export type CustomerUpdateToOneWithWhereWithoutPreOrdersInput = {
    where?: CustomerWhereInput
    data: XOR<CustomerUpdateWithoutPreOrdersInput, CustomerUncheckedUpdateWithoutPreOrdersInput>
  }

  export type CustomerUpdateWithoutPreOrdersInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutCustomersNestedInput
    referredByAgent?: AdminUserUpdateOneWithoutReferredCustomersNestedInput
    salesExpertTradingFor?: SalesExpertProfileUpdateOneWithoutTradingCustomerNestedInput
    avatarFile?: UploadedFileUpdateOneWithoutCustomerAvatarsNestedInput
    addresses?: CustomerAddressUpdateManyWithoutCustomerNestedInput
    orders?: OrderUpdateManyWithoutCustomerNestedInput
    ledgerEntries?: LedgerEntryUpdateManyWithoutCustomerNestedInput
    walletBonuses?: WalletBonusUpdateManyWithoutCustomerNestedInput
    comments?: CommentUpdateManyWithoutCustomerNestedInput
    promotions?: PromotionUpdateManyWithoutCustomerNestedInput
    notifications?: NotificationRecipientUpdateManyWithoutCustomerNestedInput
    activityLogs?: CustomerActivityLogUpdateManyWithoutCustomerNestedInput
    otpChallenges?: CustomerOtpUpdateManyWithoutCustomerNestedInput
  }

  export type CustomerUncheckedUpdateWithoutPreOrdersInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredByAgentId?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    salesExpertTradingFor?: SalesExpertProfileUncheckedUpdateOneWithoutTradingCustomerNestedInput
    addresses?: CustomerAddressUncheckedUpdateManyWithoutCustomerNestedInput
    orders?: OrderUncheckedUpdateManyWithoutCustomerNestedInput
    ledgerEntries?: LedgerEntryUncheckedUpdateManyWithoutCustomerNestedInput
    walletBonuses?: WalletBonusUncheckedUpdateManyWithoutCustomerNestedInput
    comments?: CommentUncheckedUpdateManyWithoutCustomerNestedInput
    promotions?: PromotionUncheckedUpdateManyWithoutCustomerNestedInput
    notifications?: NotificationRecipientUncheckedUpdateManyWithoutCustomerNestedInput
    activityLogs?: CustomerActivityLogUncheckedUpdateManyWithoutCustomerNestedInput
    otpChallenges?: CustomerOtpUncheckedUpdateManyWithoutCustomerNestedInput
  }

  export type CityUpsertWithoutPreOrdersInput = {
    update: XOR<CityUpdateWithoutPreOrdersInput, CityUncheckedUpdateWithoutPreOrdersInput>
    create: XOR<CityCreateWithoutPreOrdersInput, CityUncheckedCreateWithoutPreOrdersInput>
    where?: CityWhereInput
  }

  export type CityUpdateToOneWithWhereWithoutPreOrdersInput = {
    where?: CityWhereInput
    data: XOR<CityUpdateWithoutPreOrdersInput, CityUncheckedUpdateWithoutPreOrdersInput>
  }

  export type CityUpdateWithoutPreOrdersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    province?: NullableStringFieldUpdateOperationsInput | string | null
    percent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    percentAux?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    customers?: CustomerUpdateManyWithoutCityNestedInput
    addresses?: CustomerAddressUpdateManyWithoutCityNestedInput
    branches?: BranchUpdateManyWithoutCityNestedInput
    salesExpertProfiles?: SalesExpertProfileUpdateManyWithoutCityNestedInput
  }

  export type CityUncheckedUpdateWithoutPreOrdersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    province?: NullableStringFieldUpdateOperationsInput | string | null
    percent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    percentAux?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    customers?: CustomerUncheckedUpdateManyWithoutCityNestedInput
    addresses?: CustomerAddressUncheckedUpdateManyWithoutCityNestedInput
    branches?: BranchUncheckedUpdateManyWithoutCityNestedInput
    salesExpertProfiles?: SalesExpertProfileUncheckedUpdateManyWithoutCityNestedInput
  }

  export type WorkshopUpsertWithoutPreOrdersInput = {
    update: XOR<WorkshopUpdateWithoutPreOrdersInput, WorkshopUncheckedUpdateWithoutPreOrdersInput>
    create: XOR<WorkshopCreateWithoutPreOrdersInput, WorkshopUncheckedCreateWithoutPreOrdersInput>
    where?: WorkshopWhereInput
  }

  export type WorkshopUpdateToOneWithWhereWithoutPreOrdersInput = {
    where?: WorkshopWhereInput
    data: XOR<WorkshopUpdateWithoutPreOrdersInput, WorkshopUncheckedUpdateWithoutPreOrdersInput>
  }

  export type WorkshopUpdateWithoutPreOrdersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    supervisor?: AdminUserUpdateOneWithoutSupervisedWorkshopsNestedInput
  }

  export type WorkshopUncheckedUpdateWithoutPreOrdersInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    supervisorId?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
  }

  export type OrderUpsertWithoutConvertedFromPreOrderInput = {
    update: XOR<OrderUpdateWithoutConvertedFromPreOrderInput, OrderUncheckedUpdateWithoutConvertedFromPreOrderInput>
    create: XOR<OrderCreateWithoutConvertedFromPreOrderInput, OrderUncheckedCreateWithoutConvertedFromPreOrderInput>
    where?: OrderWhereInput
  }

  export type OrderUpdateToOneWithWhereWithoutConvertedFromPreOrderInput = {
    where?: OrderWhereInput
    data: XOR<OrderUpdateWithoutConvertedFromPreOrderInput, OrderUncheckedUpdateWithoutConvertedFromPreOrderInput>
  }

  export type OrderUpdateWithoutConvertedFromPreOrderInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderNumber?: StringFieldUpdateOperationsInput | string
    channel?: EnumOrderChannelFieldUpdateOperationsInput | $Enums.OrderChannel
    status?: EnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus
    totalGoldWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    wageWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: BoolFieldUpdateOperationsInput | boolean
    deliveredAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    customer?: CustomerUpdateOneRequiredWithoutOrdersNestedInput
    branch?: BranchUpdateOneWithoutOrdersNestedInput
    items?: OrderItemUpdateManyWithoutOrderNestedInput
    statusEvents?: OrderStatusEventUpdateManyWithoutOrderNestedInput
    ledgerEntries?: LedgerEntryUpdateManyWithoutOrderNestedInput
  }

  export type OrderUncheckedUpdateWithoutConvertedFromPreOrderInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderNumber?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    branchId?: NullableStringFieldUpdateOperationsInput | string | null
    channel?: EnumOrderChannelFieldUpdateOperationsInput | $Enums.OrderChannel
    status?: EnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus
    totalGoldWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    wageWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: BoolFieldUpdateOperationsInput | boolean
    deliveredAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    items?: OrderItemUncheckedUpdateManyWithoutOrderNestedInput
    statusEvents?: OrderStatusEventUncheckedUpdateManyWithoutOrderNestedInput
    ledgerEntries?: LedgerEntryUncheckedUpdateManyWithoutOrderNestedInput
  }

  export type PreOrderStatusEventUpsertWithWhereUniqueWithoutPreOrderInput = {
    where: PreOrderStatusEventWhereUniqueInput
    update: XOR<PreOrderStatusEventUpdateWithoutPreOrderInput, PreOrderStatusEventUncheckedUpdateWithoutPreOrderInput>
    create: XOR<PreOrderStatusEventCreateWithoutPreOrderInput, PreOrderStatusEventUncheckedCreateWithoutPreOrderInput>
  }

  export type PreOrderStatusEventUpdateWithWhereUniqueWithoutPreOrderInput = {
    where: PreOrderStatusEventWhereUniqueInput
    data: XOR<PreOrderStatusEventUpdateWithoutPreOrderInput, PreOrderStatusEventUncheckedUpdateWithoutPreOrderInput>
  }

  export type PreOrderStatusEventUpdateManyWithWhereWithoutPreOrderInput = {
    where: PreOrderStatusEventScalarWhereInput
    data: XOR<PreOrderStatusEventUpdateManyMutationInput, PreOrderStatusEventUncheckedUpdateManyWithoutPreOrderInput>
  }

  export type PreOrderCreateWithoutStatusEventsInput = {
    id?: string
    status?: $Enums.PreOrderStatus
    designImageUrl?: string | null
    colorName?: string | null
    sizeSpec?: string | null
    stoneColor?: string | null
    minaColor?: string | null
    estimatedWeightGrams?: Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: Decimal | DecimalJsLike | number | string | null
    description?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    customer: CustomerCreateNestedOneWithoutPreOrdersInput
    city?: CityCreateNestedOneWithoutPreOrdersInput
    workshop?: WorkshopCreateNestedOneWithoutPreOrdersInput
    convertedOrder?: OrderCreateNestedOneWithoutConvertedFromPreOrderInput
  }

  export type PreOrderUncheckedCreateWithoutStatusEventsInput = {
    id?: string
    customerId: string
    cityId?: string | null
    workshopId?: string | null
    status?: $Enums.PreOrderStatus
    designImageUrl?: string | null
    colorName?: string | null
    sizeSpec?: string | null
    stoneColor?: string | null
    minaColor?: string | null
    estimatedWeightGrams?: Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: Decimal | DecimalJsLike | number | string | null
    description?: string | null
    convertedOrderId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type PreOrderCreateOrConnectWithoutStatusEventsInput = {
    where: PreOrderWhereUniqueInput
    create: XOR<PreOrderCreateWithoutStatusEventsInput, PreOrderUncheckedCreateWithoutStatusEventsInput>
  }

  export type AdminUserCreateWithoutPreOrderStatusEventsInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    userType?: UserTypeCreateNestedOneWithoutAdminUsersInput
    branch?: BranchCreateNestedOneWithoutAdminUsersInput
    avatarFile?: UploadedFileCreateNestedOneWithoutAdminUserAvatarsInput
    referredCustomers?: CustomerCreateNestedManyWithoutReferredByAgentInput
    supervisedWorkshops?: WorkshopCreateNestedManyWithoutSupervisorInput
    branchAllocations?: BranchAllocationCreateNestedManyWithoutAllocatorAdminUserInput
    postedLedgerEntries?: LedgerEntryCreateNestedManyWithoutPostedByAdminUserInput
    orderStatusEvents?: OrderStatusEventCreateNestedManyWithoutActorAdminUserInput
    sentSmsMessages?: SmsMessageCreateNestedManyWithoutSentByAdminUserInput
    sentNotifications?: NotificationCreateNestedManyWithoutSentByAdminUserInput
    uploadedFiles?: UploadedFileCreateNestedManyWithoutUploadedByAdminUserInput
    salesExpertProfile?: SalesExpertProfileCreateNestedOneWithoutAdminUserInput
    sessions?: AdminSessionCreateNestedManyWithoutAdminUserInput
  }

  export type AdminUserUncheckedCreateWithoutPreOrderStatusEventsInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    userTypeId?: number | null
    branchId?: string | null
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    avatarFileId?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    referredCustomers?: CustomerUncheckedCreateNestedManyWithoutReferredByAgentInput
    supervisedWorkshops?: WorkshopUncheckedCreateNestedManyWithoutSupervisorInput
    branchAllocations?: BranchAllocationUncheckedCreateNestedManyWithoutAllocatorAdminUserInput
    postedLedgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutPostedByAdminUserInput
    orderStatusEvents?: OrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput
    sentSmsMessages?: SmsMessageUncheckedCreateNestedManyWithoutSentByAdminUserInput
    sentNotifications?: NotificationUncheckedCreateNestedManyWithoutSentByAdminUserInput
    uploadedFiles?: UploadedFileUncheckedCreateNestedManyWithoutUploadedByAdminUserInput
    salesExpertProfile?: SalesExpertProfileUncheckedCreateNestedOneWithoutAdminUserInput
    sessions?: AdminSessionUncheckedCreateNestedManyWithoutAdminUserInput
  }

  export type AdminUserCreateOrConnectWithoutPreOrderStatusEventsInput = {
    where: AdminUserWhereUniqueInput
    create: XOR<AdminUserCreateWithoutPreOrderStatusEventsInput, AdminUserUncheckedCreateWithoutPreOrderStatusEventsInput>
  }

  export type PreOrderUpsertWithoutStatusEventsInput = {
    update: XOR<PreOrderUpdateWithoutStatusEventsInput, PreOrderUncheckedUpdateWithoutStatusEventsInput>
    create: XOR<PreOrderCreateWithoutStatusEventsInput, PreOrderUncheckedCreateWithoutStatusEventsInput>
    where?: PreOrderWhereInput
  }

  export type PreOrderUpdateToOneWithWhereWithoutStatusEventsInput = {
    where?: PreOrderWhereInput
    data: XOR<PreOrderUpdateWithoutStatusEventsInput, PreOrderUncheckedUpdateWithoutStatusEventsInput>
  }

  export type PreOrderUpdateWithoutStatusEventsInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: EnumPreOrderStatusFieldUpdateOperationsInput | $Enums.PreOrderStatus
    designImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    colorName?: NullableStringFieldUpdateOperationsInput | string | null
    sizeSpec?: NullableStringFieldUpdateOperationsInput | string | null
    stoneColor?: NullableStringFieldUpdateOperationsInput | string | null
    minaColor?: NullableStringFieldUpdateOperationsInput | string | null
    estimatedWeightGrams?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    customer?: CustomerUpdateOneRequiredWithoutPreOrdersNestedInput
    city?: CityUpdateOneWithoutPreOrdersNestedInput
    workshop?: WorkshopUpdateOneWithoutPreOrdersNestedInput
    convertedOrder?: OrderUpdateOneWithoutConvertedFromPreOrderNestedInput
  }

  export type PreOrderUncheckedUpdateWithoutStatusEventsInput = {
    id?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    workshopId?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPreOrderStatusFieldUpdateOperationsInput | $Enums.PreOrderStatus
    designImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    colorName?: NullableStringFieldUpdateOperationsInput | string | null
    sizeSpec?: NullableStringFieldUpdateOperationsInput | string | null
    stoneColor?: NullableStringFieldUpdateOperationsInput | string | null
    minaColor?: NullableStringFieldUpdateOperationsInput | string | null
    estimatedWeightGrams?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    convertedOrderId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AdminUserUpsertWithoutPreOrderStatusEventsInput = {
    update: XOR<AdminUserUpdateWithoutPreOrderStatusEventsInput, AdminUserUncheckedUpdateWithoutPreOrderStatusEventsInput>
    create: XOR<AdminUserCreateWithoutPreOrderStatusEventsInput, AdminUserUncheckedCreateWithoutPreOrderStatusEventsInput>
    where?: AdminUserWhereInput
  }

  export type AdminUserUpdateToOneWithWhereWithoutPreOrderStatusEventsInput = {
    where?: AdminUserWhereInput
    data: XOR<AdminUserUpdateWithoutPreOrderStatusEventsInput, AdminUserUncheckedUpdateWithoutPreOrderStatusEventsInput>
  }

  export type AdminUserUpdateWithoutPreOrderStatusEventsInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    userType?: UserTypeUpdateOneWithoutAdminUsersNestedInput
    branch?: BranchUpdateOneWithoutAdminUsersNestedInput
    avatarFile?: UploadedFileUpdateOneWithoutAdminUserAvatarsNestedInput
    referredCustomers?: CustomerUpdateManyWithoutReferredByAgentNestedInput
    supervisedWorkshops?: WorkshopUpdateManyWithoutSupervisorNestedInput
    branchAllocations?: BranchAllocationUpdateManyWithoutAllocatorAdminUserNestedInput
    postedLedgerEntries?: LedgerEntryUpdateManyWithoutPostedByAdminUserNestedInput
    orderStatusEvents?: OrderStatusEventUpdateManyWithoutActorAdminUserNestedInput
    sentSmsMessages?: SmsMessageUpdateManyWithoutSentByAdminUserNestedInput
    sentNotifications?: NotificationUpdateManyWithoutSentByAdminUserNestedInput
    uploadedFiles?: UploadedFileUpdateManyWithoutUploadedByAdminUserNestedInput
    salesExpertProfile?: SalesExpertProfileUpdateOneWithoutAdminUserNestedInput
    sessions?: AdminSessionUpdateManyWithoutAdminUserNestedInput
  }

  export type AdminUserUncheckedUpdateWithoutPreOrderStatusEventsInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    userTypeId?: NullableIntFieldUpdateOperationsInput | number | null
    branchId?: NullableStringFieldUpdateOperationsInput | string | null
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredCustomers?: CustomerUncheckedUpdateManyWithoutReferredByAgentNestedInput
    supervisedWorkshops?: WorkshopUncheckedUpdateManyWithoutSupervisorNestedInput
    branchAllocations?: BranchAllocationUncheckedUpdateManyWithoutAllocatorAdminUserNestedInput
    postedLedgerEntries?: LedgerEntryUncheckedUpdateManyWithoutPostedByAdminUserNestedInput
    orderStatusEvents?: OrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput
    sentSmsMessages?: SmsMessageUncheckedUpdateManyWithoutSentByAdminUserNestedInput
    sentNotifications?: NotificationUncheckedUpdateManyWithoutSentByAdminUserNestedInput
    uploadedFiles?: UploadedFileUncheckedUpdateManyWithoutUploadedByAdminUserNestedInput
    salesExpertProfile?: SalesExpertProfileUncheckedUpdateOneWithoutAdminUserNestedInput
    sessions?: AdminSessionUncheckedUpdateManyWithoutAdminUserNestedInput
  }

  export type CustomerCreateWithoutLedgerEntriesInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    city?: CityCreateNestedOneWithoutCustomersInput
    referredByAgent?: AdminUserCreateNestedOneWithoutReferredCustomersInput
    salesExpertTradingFor?: SalesExpertProfileCreateNestedOneWithoutTradingCustomerInput
    avatarFile?: UploadedFileCreateNestedOneWithoutCustomerAvatarsInput
    addresses?: CustomerAddressCreateNestedManyWithoutCustomerInput
    orders?: OrderCreateNestedManyWithoutCustomerInput
    preOrders?: PreOrderCreateNestedManyWithoutCustomerInput
    walletBonuses?: WalletBonusCreateNestedManyWithoutCustomerInput
    comments?: CommentCreateNestedManyWithoutCustomerInput
    promotions?: PromotionCreateNestedManyWithoutCustomerInput
    notifications?: NotificationRecipientCreateNestedManyWithoutCustomerInput
    activityLogs?: CustomerActivityLogCreateNestedManyWithoutCustomerInput
    otpChallenges?: CustomerOtpCreateNestedManyWithoutCustomerInput
  }

  export type CustomerUncheckedCreateWithoutLedgerEntriesInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    cityId?: string | null
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    referredByAgentId?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    avatarFileId?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    salesExpertTradingFor?: SalesExpertProfileUncheckedCreateNestedOneWithoutTradingCustomerInput
    addresses?: CustomerAddressUncheckedCreateNestedManyWithoutCustomerInput
    orders?: OrderUncheckedCreateNestedManyWithoutCustomerInput
    preOrders?: PreOrderUncheckedCreateNestedManyWithoutCustomerInput
    walletBonuses?: WalletBonusUncheckedCreateNestedManyWithoutCustomerInput
    comments?: CommentUncheckedCreateNestedManyWithoutCustomerInput
    promotions?: PromotionUncheckedCreateNestedManyWithoutCustomerInput
    notifications?: NotificationRecipientUncheckedCreateNestedManyWithoutCustomerInput
    activityLogs?: CustomerActivityLogUncheckedCreateNestedManyWithoutCustomerInput
    otpChallenges?: CustomerOtpUncheckedCreateNestedManyWithoutCustomerInput
  }

  export type CustomerCreateOrConnectWithoutLedgerEntriesInput = {
    where: CustomerWhereUniqueInput
    create: XOR<CustomerCreateWithoutLedgerEntriesInput, CustomerUncheckedCreateWithoutLedgerEntriesInput>
  }

  export type OrderCreateWithoutLedgerEntriesInput = {
    id?: string
    orderNumber: string
    channel?: $Enums.OrderChannel
    status?: $Enums.OrderStatus
    totalGoldWeightGrams: Decimal | DecimalJsLike | number | string
    wageWeightGrams: Decimal | DecimalJsLike | number | string
    flatRialCharge?: Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: boolean
    deliveredAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    customer: CustomerCreateNestedOneWithoutOrdersInput
    branch?: BranchCreateNestedOneWithoutOrdersInput
    items?: OrderItemCreateNestedManyWithoutOrderInput
    statusEvents?: OrderStatusEventCreateNestedManyWithoutOrderInput
    convertedFromPreOrder?: PreOrderCreateNestedOneWithoutConvertedOrderInput
  }

  export type OrderUncheckedCreateWithoutLedgerEntriesInput = {
    id?: string
    orderNumber: string
    customerId: string
    branchId?: string | null
    channel?: $Enums.OrderChannel
    status?: $Enums.OrderStatus
    totalGoldWeightGrams: Decimal | DecimalJsLike | number | string
    wageWeightGrams: Decimal | DecimalJsLike | number | string
    flatRialCharge?: Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: boolean
    deliveredAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
    items?: OrderItemUncheckedCreateNestedManyWithoutOrderInput
    statusEvents?: OrderStatusEventUncheckedCreateNestedManyWithoutOrderInput
    convertedFromPreOrder?: PreOrderUncheckedCreateNestedOneWithoutConvertedOrderInput
  }

  export type OrderCreateOrConnectWithoutLedgerEntriesInput = {
    where: OrderWhereUniqueInput
    create: XOR<OrderCreateWithoutLedgerEntriesInput, OrderUncheckedCreateWithoutLedgerEntriesInput>
  }

  export type AdminUserCreateWithoutPostedLedgerEntriesInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    userType?: UserTypeCreateNestedOneWithoutAdminUsersInput
    branch?: BranchCreateNestedOneWithoutAdminUsersInput
    avatarFile?: UploadedFileCreateNestedOneWithoutAdminUserAvatarsInput
    referredCustomers?: CustomerCreateNestedManyWithoutReferredByAgentInput
    supervisedWorkshops?: WorkshopCreateNestedManyWithoutSupervisorInput
    branchAllocations?: BranchAllocationCreateNestedManyWithoutAllocatorAdminUserInput
    orderStatusEvents?: OrderStatusEventCreateNestedManyWithoutActorAdminUserInput
    preOrderStatusEvents?: PreOrderStatusEventCreateNestedManyWithoutActorAdminUserInput
    sentSmsMessages?: SmsMessageCreateNestedManyWithoutSentByAdminUserInput
    sentNotifications?: NotificationCreateNestedManyWithoutSentByAdminUserInput
    uploadedFiles?: UploadedFileCreateNestedManyWithoutUploadedByAdminUserInput
    salesExpertProfile?: SalesExpertProfileCreateNestedOneWithoutAdminUserInput
    sessions?: AdminSessionCreateNestedManyWithoutAdminUserInput
  }

  export type AdminUserUncheckedCreateWithoutPostedLedgerEntriesInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    userTypeId?: number | null
    branchId?: string | null
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    avatarFileId?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    referredCustomers?: CustomerUncheckedCreateNestedManyWithoutReferredByAgentInput
    supervisedWorkshops?: WorkshopUncheckedCreateNestedManyWithoutSupervisorInput
    branchAllocations?: BranchAllocationUncheckedCreateNestedManyWithoutAllocatorAdminUserInput
    orderStatusEvents?: OrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput
    preOrderStatusEvents?: PreOrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput
    sentSmsMessages?: SmsMessageUncheckedCreateNestedManyWithoutSentByAdminUserInput
    sentNotifications?: NotificationUncheckedCreateNestedManyWithoutSentByAdminUserInput
    uploadedFiles?: UploadedFileUncheckedCreateNestedManyWithoutUploadedByAdminUserInput
    salesExpertProfile?: SalesExpertProfileUncheckedCreateNestedOneWithoutAdminUserInput
    sessions?: AdminSessionUncheckedCreateNestedManyWithoutAdminUserInput
  }

  export type AdminUserCreateOrConnectWithoutPostedLedgerEntriesInput = {
    where: AdminUserWhereUniqueInput
    create: XOR<AdminUserCreateWithoutPostedLedgerEntriesInput, AdminUserUncheckedCreateWithoutPostedLedgerEntriesInput>
  }

  export type CustomerUpsertWithoutLedgerEntriesInput = {
    update: XOR<CustomerUpdateWithoutLedgerEntriesInput, CustomerUncheckedUpdateWithoutLedgerEntriesInput>
    create: XOR<CustomerCreateWithoutLedgerEntriesInput, CustomerUncheckedCreateWithoutLedgerEntriesInput>
    where?: CustomerWhereInput
  }

  export type CustomerUpdateToOneWithWhereWithoutLedgerEntriesInput = {
    where?: CustomerWhereInput
    data: XOR<CustomerUpdateWithoutLedgerEntriesInput, CustomerUncheckedUpdateWithoutLedgerEntriesInput>
  }

  export type CustomerUpdateWithoutLedgerEntriesInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutCustomersNestedInput
    referredByAgent?: AdminUserUpdateOneWithoutReferredCustomersNestedInput
    salesExpertTradingFor?: SalesExpertProfileUpdateOneWithoutTradingCustomerNestedInput
    avatarFile?: UploadedFileUpdateOneWithoutCustomerAvatarsNestedInput
    addresses?: CustomerAddressUpdateManyWithoutCustomerNestedInput
    orders?: OrderUpdateManyWithoutCustomerNestedInput
    preOrders?: PreOrderUpdateManyWithoutCustomerNestedInput
    walletBonuses?: WalletBonusUpdateManyWithoutCustomerNestedInput
    comments?: CommentUpdateManyWithoutCustomerNestedInput
    promotions?: PromotionUpdateManyWithoutCustomerNestedInput
    notifications?: NotificationRecipientUpdateManyWithoutCustomerNestedInput
    activityLogs?: CustomerActivityLogUpdateManyWithoutCustomerNestedInput
    otpChallenges?: CustomerOtpUpdateManyWithoutCustomerNestedInput
  }

  export type CustomerUncheckedUpdateWithoutLedgerEntriesInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredByAgentId?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    salesExpertTradingFor?: SalesExpertProfileUncheckedUpdateOneWithoutTradingCustomerNestedInput
    addresses?: CustomerAddressUncheckedUpdateManyWithoutCustomerNestedInput
    orders?: OrderUncheckedUpdateManyWithoutCustomerNestedInput
    preOrders?: PreOrderUncheckedUpdateManyWithoutCustomerNestedInput
    walletBonuses?: WalletBonusUncheckedUpdateManyWithoutCustomerNestedInput
    comments?: CommentUncheckedUpdateManyWithoutCustomerNestedInput
    promotions?: PromotionUncheckedUpdateManyWithoutCustomerNestedInput
    notifications?: NotificationRecipientUncheckedUpdateManyWithoutCustomerNestedInput
    activityLogs?: CustomerActivityLogUncheckedUpdateManyWithoutCustomerNestedInput
    otpChallenges?: CustomerOtpUncheckedUpdateManyWithoutCustomerNestedInput
  }

  export type OrderUpsertWithoutLedgerEntriesInput = {
    update: XOR<OrderUpdateWithoutLedgerEntriesInput, OrderUncheckedUpdateWithoutLedgerEntriesInput>
    create: XOR<OrderCreateWithoutLedgerEntriesInput, OrderUncheckedCreateWithoutLedgerEntriesInput>
    where?: OrderWhereInput
  }

  export type OrderUpdateToOneWithWhereWithoutLedgerEntriesInput = {
    where?: OrderWhereInput
    data: XOR<OrderUpdateWithoutLedgerEntriesInput, OrderUncheckedUpdateWithoutLedgerEntriesInput>
  }

  export type OrderUpdateWithoutLedgerEntriesInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderNumber?: StringFieldUpdateOperationsInput | string
    channel?: EnumOrderChannelFieldUpdateOperationsInput | $Enums.OrderChannel
    status?: EnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus
    totalGoldWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    wageWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: BoolFieldUpdateOperationsInput | boolean
    deliveredAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    customer?: CustomerUpdateOneRequiredWithoutOrdersNestedInput
    branch?: BranchUpdateOneWithoutOrdersNestedInput
    items?: OrderItemUpdateManyWithoutOrderNestedInput
    statusEvents?: OrderStatusEventUpdateManyWithoutOrderNestedInput
    convertedFromPreOrder?: PreOrderUpdateOneWithoutConvertedOrderNestedInput
  }

  export type OrderUncheckedUpdateWithoutLedgerEntriesInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderNumber?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    branchId?: NullableStringFieldUpdateOperationsInput | string | null
    channel?: EnumOrderChannelFieldUpdateOperationsInput | $Enums.OrderChannel
    status?: EnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus
    totalGoldWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    wageWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: BoolFieldUpdateOperationsInput | boolean
    deliveredAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    items?: OrderItemUncheckedUpdateManyWithoutOrderNestedInput
    statusEvents?: OrderStatusEventUncheckedUpdateManyWithoutOrderNestedInput
    convertedFromPreOrder?: PreOrderUncheckedUpdateOneWithoutConvertedOrderNestedInput
  }

  export type AdminUserUpsertWithoutPostedLedgerEntriesInput = {
    update: XOR<AdminUserUpdateWithoutPostedLedgerEntriesInput, AdminUserUncheckedUpdateWithoutPostedLedgerEntriesInput>
    create: XOR<AdminUserCreateWithoutPostedLedgerEntriesInput, AdminUserUncheckedCreateWithoutPostedLedgerEntriesInput>
    where?: AdminUserWhereInput
  }

  export type AdminUserUpdateToOneWithWhereWithoutPostedLedgerEntriesInput = {
    where?: AdminUserWhereInput
    data: XOR<AdminUserUpdateWithoutPostedLedgerEntriesInput, AdminUserUncheckedUpdateWithoutPostedLedgerEntriesInput>
  }

  export type AdminUserUpdateWithoutPostedLedgerEntriesInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    userType?: UserTypeUpdateOneWithoutAdminUsersNestedInput
    branch?: BranchUpdateOneWithoutAdminUsersNestedInput
    avatarFile?: UploadedFileUpdateOneWithoutAdminUserAvatarsNestedInput
    referredCustomers?: CustomerUpdateManyWithoutReferredByAgentNestedInput
    supervisedWorkshops?: WorkshopUpdateManyWithoutSupervisorNestedInput
    branchAllocations?: BranchAllocationUpdateManyWithoutAllocatorAdminUserNestedInput
    orderStatusEvents?: OrderStatusEventUpdateManyWithoutActorAdminUserNestedInput
    preOrderStatusEvents?: PreOrderStatusEventUpdateManyWithoutActorAdminUserNestedInput
    sentSmsMessages?: SmsMessageUpdateManyWithoutSentByAdminUserNestedInput
    sentNotifications?: NotificationUpdateManyWithoutSentByAdminUserNestedInput
    uploadedFiles?: UploadedFileUpdateManyWithoutUploadedByAdminUserNestedInput
    salesExpertProfile?: SalesExpertProfileUpdateOneWithoutAdminUserNestedInput
    sessions?: AdminSessionUpdateManyWithoutAdminUserNestedInput
  }

  export type AdminUserUncheckedUpdateWithoutPostedLedgerEntriesInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    userTypeId?: NullableIntFieldUpdateOperationsInput | number | null
    branchId?: NullableStringFieldUpdateOperationsInput | string | null
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredCustomers?: CustomerUncheckedUpdateManyWithoutReferredByAgentNestedInput
    supervisedWorkshops?: WorkshopUncheckedUpdateManyWithoutSupervisorNestedInput
    branchAllocations?: BranchAllocationUncheckedUpdateManyWithoutAllocatorAdminUserNestedInput
    orderStatusEvents?: OrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput
    preOrderStatusEvents?: PreOrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput
    sentSmsMessages?: SmsMessageUncheckedUpdateManyWithoutSentByAdminUserNestedInput
    sentNotifications?: NotificationUncheckedUpdateManyWithoutSentByAdminUserNestedInput
    uploadedFiles?: UploadedFileUncheckedUpdateManyWithoutUploadedByAdminUserNestedInput
    salesExpertProfile?: SalesExpertProfileUncheckedUpdateOneWithoutAdminUserNestedInput
    sessions?: AdminSessionUncheckedUpdateManyWithoutAdminUserNestedInput
  }

  export type CustomerCreateWithoutWalletBonusesInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    city?: CityCreateNestedOneWithoutCustomersInput
    referredByAgent?: AdminUserCreateNestedOneWithoutReferredCustomersInput
    salesExpertTradingFor?: SalesExpertProfileCreateNestedOneWithoutTradingCustomerInput
    avatarFile?: UploadedFileCreateNestedOneWithoutCustomerAvatarsInput
    addresses?: CustomerAddressCreateNestedManyWithoutCustomerInput
    orders?: OrderCreateNestedManyWithoutCustomerInput
    preOrders?: PreOrderCreateNestedManyWithoutCustomerInput
    ledgerEntries?: LedgerEntryCreateNestedManyWithoutCustomerInput
    comments?: CommentCreateNestedManyWithoutCustomerInput
    promotions?: PromotionCreateNestedManyWithoutCustomerInput
    notifications?: NotificationRecipientCreateNestedManyWithoutCustomerInput
    activityLogs?: CustomerActivityLogCreateNestedManyWithoutCustomerInput
    otpChallenges?: CustomerOtpCreateNestedManyWithoutCustomerInput
  }

  export type CustomerUncheckedCreateWithoutWalletBonusesInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    cityId?: string | null
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    referredByAgentId?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    avatarFileId?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    salesExpertTradingFor?: SalesExpertProfileUncheckedCreateNestedOneWithoutTradingCustomerInput
    addresses?: CustomerAddressUncheckedCreateNestedManyWithoutCustomerInput
    orders?: OrderUncheckedCreateNestedManyWithoutCustomerInput
    preOrders?: PreOrderUncheckedCreateNestedManyWithoutCustomerInput
    ledgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutCustomerInput
    comments?: CommentUncheckedCreateNestedManyWithoutCustomerInput
    promotions?: PromotionUncheckedCreateNestedManyWithoutCustomerInput
    notifications?: NotificationRecipientUncheckedCreateNestedManyWithoutCustomerInput
    activityLogs?: CustomerActivityLogUncheckedCreateNestedManyWithoutCustomerInput
    otpChallenges?: CustomerOtpUncheckedCreateNestedManyWithoutCustomerInput
  }

  export type CustomerCreateOrConnectWithoutWalletBonusesInput = {
    where: CustomerWhereUniqueInput
    create: XOR<CustomerCreateWithoutWalletBonusesInput, CustomerUncheckedCreateWithoutWalletBonusesInput>
  }

  export type CustomerUpsertWithoutWalletBonusesInput = {
    update: XOR<CustomerUpdateWithoutWalletBonusesInput, CustomerUncheckedUpdateWithoutWalletBonusesInput>
    create: XOR<CustomerCreateWithoutWalletBonusesInput, CustomerUncheckedCreateWithoutWalletBonusesInput>
    where?: CustomerWhereInput
  }

  export type CustomerUpdateToOneWithWhereWithoutWalletBonusesInput = {
    where?: CustomerWhereInput
    data: XOR<CustomerUpdateWithoutWalletBonusesInput, CustomerUncheckedUpdateWithoutWalletBonusesInput>
  }

  export type CustomerUpdateWithoutWalletBonusesInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutCustomersNestedInput
    referredByAgent?: AdminUserUpdateOneWithoutReferredCustomersNestedInput
    salesExpertTradingFor?: SalesExpertProfileUpdateOneWithoutTradingCustomerNestedInput
    avatarFile?: UploadedFileUpdateOneWithoutCustomerAvatarsNestedInput
    addresses?: CustomerAddressUpdateManyWithoutCustomerNestedInput
    orders?: OrderUpdateManyWithoutCustomerNestedInput
    preOrders?: PreOrderUpdateManyWithoutCustomerNestedInput
    ledgerEntries?: LedgerEntryUpdateManyWithoutCustomerNestedInput
    comments?: CommentUpdateManyWithoutCustomerNestedInput
    promotions?: PromotionUpdateManyWithoutCustomerNestedInput
    notifications?: NotificationRecipientUpdateManyWithoutCustomerNestedInput
    activityLogs?: CustomerActivityLogUpdateManyWithoutCustomerNestedInput
    otpChallenges?: CustomerOtpUpdateManyWithoutCustomerNestedInput
  }

  export type CustomerUncheckedUpdateWithoutWalletBonusesInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredByAgentId?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    salesExpertTradingFor?: SalesExpertProfileUncheckedUpdateOneWithoutTradingCustomerNestedInput
    addresses?: CustomerAddressUncheckedUpdateManyWithoutCustomerNestedInput
    orders?: OrderUncheckedUpdateManyWithoutCustomerNestedInput
    preOrders?: PreOrderUncheckedUpdateManyWithoutCustomerNestedInput
    ledgerEntries?: LedgerEntryUncheckedUpdateManyWithoutCustomerNestedInput
    comments?: CommentUncheckedUpdateManyWithoutCustomerNestedInput
    promotions?: PromotionUncheckedUpdateManyWithoutCustomerNestedInput
    notifications?: NotificationRecipientUncheckedUpdateManyWithoutCustomerNestedInput
    activityLogs?: CustomerActivityLogUncheckedUpdateManyWithoutCustomerNestedInput
    otpChallenges?: CustomerOtpUncheckedUpdateManyWithoutCustomerNestedInput
  }

  export type PermissionCreateWithoutUserTypeInput = {
    rid: string
  }

  export type PermissionUncheckedCreateWithoutUserTypeInput = {
    rid: string
  }

  export type PermissionCreateOrConnectWithoutUserTypeInput = {
    where: PermissionWhereUniqueInput
    create: XOR<PermissionCreateWithoutUserTypeInput, PermissionUncheckedCreateWithoutUserTypeInput>
  }

  export type PermissionCreateManyUserTypeInputEnvelope = {
    data: PermissionCreateManyUserTypeInput | PermissionCreateManyUserTypeInput[]
    skipDuplicates?: boolean
  }

  export type AdminUserCreateWithoutUserTypeInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    branch?: BranchCreateNestedOneWithoutAdminUsersInput
    avatarFile?: UploadedFileCreateNestedOneWithoutAdminUserAvatarsInput
    referredCustomers?: CustomerCreateNestedManyWithoutReferredByAgentInput
    supervisedWorkshops?: WorkshopCreateNestedManyWithoutSupervisorInput
    branchAllocations?: BranchAllocationCreateNestedManyWithoutAllocatorAdminUserInput
    postedLedgerEntries?: LedgerEntryCreateNestedManyWithoutPostedByAdminUserInput
    orderStatusEvents?: OrderStatusEventCreateNestedManyWithoutActorAdminUserInput
    preOrderStatusEvents?: PreOrderStatusEventCreateNestedManyWithoutActorAdminUserInput
    sentSmsMessages?: SmsMessageCreateNestedManyWithoutSentByAdminUserInput
    sentNotifications?: NotificationCreateNestedManyWithoutSentByAdminUserInput
    uploadedFiles?: UploadedFileCreateNestedManyWithoutUploadedByAdminUserInput
    salesExpertProfile?: SalesExpertProfileCreateNestedOneWithoutAdminUserInput
    sessions?: AdminSessionCreateNestedManyWithoutAdminUserInput
  }

  export type AdminUserUncheckedCreateWithoutUserTypeInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    branchId?: string | null
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    avatarFileId?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    referredCustomers?: CustomerUncheckedCreateNestedManyWithoutReferredByAgentInput
    supervisedWorkshops?: WorkshopUncheckedCreateNestedManyWithoutSupervisorInput
    branchAllocations?: BranchAllocationUncheckedCreateNestedManyWithoutAllocatorAdminUserInput
    postedLedgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutPostedByAdminUserInput
    orderStatusEvents?: OrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput
    preOrderStatusEvents?: PreOrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput
    sentSmsMessages?: SmsMessageUncheckedCreateNestedManyWithoutSentByAdminUserInput
    sentNotifications?: NotificationUncheckedCreateNestedManyWithoutSentByAdminUserInput
    uploadedFiles?: UploadedFileUncheckedCreateNestedManyWithoutUploadedByAdminUserInput
    salesExpertProfile?: SalesExpertProfileUncheckedCreateNestedOneWithoutAdminUserInput
    sessions?: AdminSessionUncheckedCreateNestedManyWithoutAdminUserInput
  }

  export type AdminUserCreateOrConnectWithoutUserTypeInput = {
    where: AdminUserWhereUniqueInput
    create: XOR<AdminUserCreateWithoutUserTypeInput, AdminUserUncheckedCreateWithoutUserTypeInput>
  }

  export type AdminUserCreateManyUserTypeInputEnvelope = {
    data: AdminUserCreateManyUserTypeInput | AdminUserCreateManyUserTypeInput[]
    skipDuplicates?: boolean
  }

  export type PermissionUpsertWithWhereUniqueWithoutUserTypeInput = {
    where: PermissionWhereUniqueInput
    update: XOR<PermissionUpdateWithoutUserTypeInput, PermissionUncheckedUpdateWithoutUserTypeInput>
    create: XOR<PermissionCreateWithoutUserTypeInput, PermissionUncheckedCreateWithoutUserTypeInput>
  }

  export type PermissionUpdateWithWhereUniqueWithoutUserTypeInput = {
    where: PermissionWhereUniqueInput
    data: XOR<PermissionUpdateWithoutUserTypeInput, PermissionUncheckedUpdateWithoutUserTypeInput>
  }

  export type PermissionUpdateManyWithWhereWithoutUserTypeInput = {
    where: PermissionScalarWhereInput
    data: XOR<PermissionUpdateManyMutationInput, PermissionUncheckedUpdateManyWithoutUserTypeInput>
  }

  export type PermissionScalarWhereInput = {
    AND?: PermissionScalarWhereInput | PermissionScalarWhereInput[]
    OR?: PermissionScalarWhereInput[]
    NOT?: PermissionScalarWhereInput | PermissionScalarWhereInput[]
    rid?: StringFilter<"Permission"> | string
    userTypeId?: IntFilter<"Permission"> | number
  }

  export type AdminUserUpsertWithWhereUniqueWithoutUserTypeInput = {
    where: AdminUserWhereUniqueInput
    update: XOR<AdminUserUpdateWithoutUserTypeInput, AdminUserUncheckedUpdateWithoutUserTypeInput>
    create: XOR<AdminUserCreateWithoutUserTypeInput, AdminUserUncheckedCreateWithoutUserTypeInput>
  }

  export type AdminUserUpdateWithWhereUniqueWithoutUserTypeInput = {
    where: AdminUserWhereUniqueInput
    data: XOR<AdminUserUpdateWithoutUserTypeInput, AdminUserUncheckedUpdateWithoutUserTypeInput>
  }

  export type AdminUserUpdateManyWithWhereWithoutUserTypeInput = {
    where: AdminUserScalarWhereInput
    data: XOR<AdminUserUpdateManyMutationInput, AdminUserUncheckedUpdateManyWithoutUserTypeInput>
  }

  export type UserTypeCreateWithoutPermissionsInput = {
    id: number
    title: string
    isActive?: boolean
    createdAt?: Date | string
    adminUsers?: AdminUserCreateNestedManyWithoutUserTypeInput
  }

  export type UserTypeUncheckedCreateWithoutPermissionsInput = {
    id: number
    title: string
    isActive?: boolean
    createdAt?: Date | string
    adminUsers?: AdminUserUncheckedCreateNestedManyWithoutUserTypeInput
  }

  export type UserTypeCreateOrConnectWithoutPermissionsInput = {
    where: UserTypeWhereUniqueInput
    create: XOR<UserTypeCreateWithoutPermissionsInput, UserTypeUncheckedCreateWithoutPermissionsInput>
  }

  export type UserTypeUpsertWithoutPermissionsInput = {
    update: XOR<UserTypeUpdateWithoutPermissionsInput, UserTypeUncheckedUpdateWithoutPermissionsInput>
    create: XOR<UserTypeCreateWithoutPermissionsInput, UserTypeUncheckedCreateWithoutPermissionsInput>
    where?: UserTypeWhereInput
  }

  export type UserTypeUpdateToOneWithWhereWithoutPermissionsInput = {
    where?: UserTypeWhereInput
    data: XOR<UserTypeUpdateWithoutPermissionsInput, UserTypeUncheckedUpdateWithoutPermissionsInput>
  }

  export type UserTypeUpdateWithoutPermissionsInput = {
    id?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    adminUsers?: AdminUserUpdateManyWithoutUserTypeNestedInput
  }

  export type UserTypeUncheckedUpdateWithoutPermissionsInput = {
    id?: IntFieldUpdateOperationsInput | number
    title?: StringFieldUpdateOperationsInput | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    adminUsers?: AdminUserUncheckedUpdateManyWithoutUserTypeNestedInput
  }

  export type ProductCreateWithoutCommentsInput = {
    id?: string
    title: string
    description?: string | null
    productCode?: string | null
    showType?: number
    isActive?: boolean
    createdAt?: Date | string
    category?: CategoryCreateNestedOneWithoutProductsInput
    brand?: BrandCreateNestedOneWithoutProductsInput
    variants?: ProductVariantCreateNestedManyWithoutProductInput
    images?: ProductImageCreateNestedManyWithoutProductInput
    collections?: CollectionProductCreateNestedManyWithoutProductInput
    promotions?: PromotionCreateNestedManyWithoutProductInput
    allocationItems?: BranchAllocationItemCreateNestedManyWithoutProductInput
  }

  export type ProductUncheckedCreateWithoutCommentsInput = {
    id?: string
    title: string
    description?: string | null
    categoryId?: string | null
    brandId?: string | null
    productCode?: string | null
    showType?: number
    isActive?: boolean
    createdAt?: Date | string
    variants?: ProductVariantUncheckedCreateNestedManyWithoutProductInput
    images?: ProductImageUncheckedCreateNestedManyWithoutProductInput
    collections?: CollectionProductUncheckedCreateNestedManyWithoutProductInput
    promotions?: PromotionUncheckedCreateNestedManyWithoutProductInput
    allocationItems?: BranchAllocationItemUncheckedCreateNestedManyWithoutProductInput
  }

  export type ProductCreateOrConnectWithoutCommentsInput = {
    where: ProductWhereUniqueInput
    create: XOR<ProductCreateWithoutCommentsInput, ProductUncheckedCreateWithoutCommentsInput>
  }

  export type CustomerCreateWithoutCommentsInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    city?: CityCreateNestedOneWithoutCustomersInput
    referredByAgent?: AdminUserCreateNestedOneWithoutReferredCustomersInput
    salesExpertTradingFor?: SalesExpertProfileCreateNestedOneWithoutTradingCustomerInput
    avatarFile?: UploadedFileCreateNestedOneWithoutCustomerAvatarsInput
    addresses?: CustomerAddressCreateNestedManyWithoutCustomerInput
    orders?: OrderCreateNestedManyWithoutCustomerInput
    preOrders?: PreOrderCreateNestedManyWithoutCustomerInput
    ledgerEntries?: LedgerEntryCreateNestedManyWithoutCustomerInput
    walletBonuses?: WalletBonusCreateNestedManyWithoutCustomerInput
    promotions?: PromotionCreateNestedManyWithoutCustomerInput
    notifications?: NotificationRecipientCreateNestedManyWithoutCustomerInput
    activityLogs?: CustomerActivityLogCreateNestedManyWithoutCustomerInput
    otpChallenges?: CustomerOtpCreateNestedManyWithoutCustomerInput
  }

  export type CustomerUncheckedCreateWithoutCommentsInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    cityId?: string | null
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    referredByAgentId?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    avatarFileId?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    salesExpertTradingFor?: SalesExpertProfileUncheckedCreateNestedOneWithoutTradingCustomerInput
    addresses?: CustomerAddressUncheckedCreateNestedManyWithoutCustomerInput
    orders?: OrderUncheckedCreateNestedManyWithoutCustomerInput
    preOrders?: PreOrderUncheckedCreateNestedManyWithoutCustomerInput
    ledgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutCustomerInput
    walletBonuses?: WalletBonusUncheckedCreateNestedManyWithoutCustomerInput
    promotions?: PromotionUncheckedCreateNestedManyWithoutCustomerInput
    notifications?: NotificationRecipientUncheckedCreateNestedManyWithoutCustomerInput
    activityLogs?: CustomerActivityLogUncheckedCreateNestedManyWithoutCustomerInput
    otpChallenges?: CustomerOtpUncheckedCreateNestedManyWithoutCustomerInput
  }

  export type CustomerCreateOrConnectWithoutCommentsInput = {
    where: CustomerWhereUniqueInput
    create: XOR<CustomerCreateWithoutCommentsInput, CustomerUncheckedCreateWithoutCommentsInput>
  }

  export type CommentCreateWithoutRepliesInput = {
    id?: string
    body: string
    status?: $Enums.CommentStatus
    createdAt?: Date | string
    updatedAt?: Date | string
    product: ProductCreateNestedOneWithoutCommentsInput
    customer: CustomerCreateNestedOneWithoutCommentsInput
    replyTo?: CommentCreateNestedOneWithoutRepliesInput
  }

  export type CommentUncheckedCreateWithoutRepliesInput = {
    id?: string
    productId: string
    customerId: string
    body: string
    status?: $Enums.CommentStatus
    replyToId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type CommentCreateOrConnectWithoutRepliesInput = {
    where: CommentWhereUniqueInput
    create: XOR<CommentCreateWithoutRepliesInput, CommentUncheckedCreateWithoutRepliesInput>
  }

  export type CommentCreateWithoutReplyToInput = {
    id?: string
    body: string
    status?: $Enums.CommentStatus
    createdAt?: Date | string
    updatedAt?: Date | string
    product: ProductCreateNestedOneWithoutCommentsInput
    customer: CustomerCreateNestedOneWithoutCommentsInput
    replies?: CommentCreateNestedManyWithoutReplyToInput
  }

  export type CommentUncheckedCreateWithoutReplyToInput = {
    id?: string
    productId: string
    customerId: string
    body: string
    status?: $Enums.CommentStatus
    createdAt?: Date | string
    updatedAt?: Date | string
    replies?: CommentUncheckedCreateNestedManyWithoutReplyToInput
  }

  export type CommentCreateOrConnectWithoutReplyToInput = {
    where: CommentWhereUniqueInput
    create: XOR<CommentCreateWithoutReplyToInput, CommentUncheckedCreateWithoutReplyToInput>
  }

  export type CommentCreateManyReplyToInputEnvelope = {
    data: CommentCreateManyReplyToInput | CommentCreateManyReplyToInput[]
    skipDuplicates?: boolean
  }

  export type ProductUpsertWithoutCommentsInput = {
    update: XOR<ProductUpdateWithoutCommentsInput, ProductUncheckedUpdateWithoutCommentsInput>
    create: XOR<ProductCreateWithoutCommentsInput, ProductUncheckedCreateWithoutCommentsInput>
    where?: ProductWhereInput
  }

  export type ProductUpdateToOneWithWhereWithoutCommentsInput = {
    where?: ProductWhereInput
    data: XOR<ProductUpdateWithoutCommentsInput, ProductUncheckedUpdateWithoutCommentsInput>
  }

  export type ProductUpdateWithoutCommentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    productCode?: NullableStringFieldUpdateOperationsInput | string | null
    showType?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    category?: CategoryUpdateOneWithoutProductsNestedInput
    brand?: BrandUpdateOneWithoutProductsNestedInput
    variants?: ProductVariantUpdateManyWithoutProductNestedInput
    images?: ProductImageUpdateManyWithoutProductNestedInput
    collections?: CollectionProductUpdateManyWithoutProductNestedInput
    promotions?: PromotionUpdateManyWithoutProductNestedInput
    allocationItems?: BranchAllocationItemUpdateManyWithoutProductNestedInput
  }

  export type ProductUncheckedUpdateWithoutCommentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    categoryId?: NullableStringFieldUpdateOperationsInput | string | null
    brandId?: NullableStringFieldUpdateOperationsInput | string | null
    productCode?: NullableStringFieldUpdateOperationsInput | string | null
    showType?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    variants?: ProductVariantUncheckedUpdateManyWithoutProductNestedInput
    images?: ProductImageUncheckedUpdateManyWithoutProductNestedInput
    collections?: CollectionProductUncheckedUpdateManyWithoutProductNestedInput
    promotions?: PromotionUncheckedUpdateManyWithoutProductNestedInput
    allocationItems?: BranchAllocationItemUncheckedUpdateManyWithoutProductNestedInput
  }

  export type CustomerUpsertWithoutCommentsInput = {
    update: XOR<CustomerUpdateWithoutCommentsInput, CustomerUncheckedUpdateWithoutCommentsInput>
    create: XOR<CustomerCreateWithoutCommentsInput, CustomerUncheckedCreateWithoutCommentsInput>
    where?: CustomerWhereInput
  }

  export type CustomerUpdateToOneWithWhereWithoutCommentsInput = {
    where?: CustomerWhereInput
    data: XOR<CustomerUpdateWithoutCommentsInput, CustomerUncheckedUpdateWithoutCommentsInput>
  }

  export type CustomerUpdateWithoutCommentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutCustomersNestedInput
    referredByAgent?: AdminUserUpdateOneWithoutReferredCustomersNestedInput
    salesExpertTradingFor?: SalesExpertProfileUpdateOneWithoutTradingCustomerNestedInput
    avatarFile?: UploadedFileUpdateOneWithoutCustomerAvatarsNestedInput
    addresses?: CustomerAddressUpdateManyWithoutCustomerNestedInput
    orders?: OrderUpdateManyWithoutCustomerNestedInput
    preOrders?: PreOrderUpdateManyWithoutCustomerNestedInput
    ledgerEntries?: LedgerEntryUpdateManyWithoutCustomerNestedInput
    walletBonuses?: WalletBonusUpdateManyWithoutCustomerNestedInput
    promotions?: PromotionUpdateManyWithoutCustomerNestedInput
    notifications?: NotificationRecipientUpdateManyWithoutCustomerNestedInput
    activityLogs?: CustomerActivityLogUpdateManyWithoutCustomerNestedInput
    otpChallenges?: CustomerOtpUpdateManyWithoutCustomerNestedInput
  }

  export type CustomerUncheckedUpdateWithoutCommentsInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredByAgentId?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    salesExpertTradingFor?: SalesExpertProfileUncheckedUpdateOneWithoutTradingCustomerNestedInput
    addresses?: CustomerAddressUncheckedUpdateManyWithoutCustomerNestedInput
    orders?: OrderUncheckedUpdateManyWithoutCustomerNestedInput
    preOrders?: PreOrderUncheckedUpdateManyWithoutCustomerNestedInput
    ledgerEntries?: LedgerEntryUncheckedUpdateManyWithoutCustomerNestedInput
    walletBonuses?: WalletBonusUncheckedUpdateManyWithoutCustomerNestedInput
    promotions?: PromotionUncheckedUpdateManyWithoutCustomerNestedInput
    notifications?: NotificationRecipientUncheckedUpdateManyWithoutCustomerNestedInput
    activityLogs?: CustomerActivityLogUncheckedUpdateManyWithoutCustomerNestedInput
    otpChallenges?: CustomerOtpUncheckedUpdateManyWithoutCustomerNestedInput
  }

  export type CommentUpsertWithoutRepliesInput = {
    update: XOR<CommentUpdateWithoutRepliesInput, CommentUncheckedUpdateWithoutRepliesInput>
    create: XOR<CommentCreateWithoutRepliesInput, CommentUncheckedCreateWithoutRepliesInput>
    where?: CommentWhereInput
  }

  export type CommentUpdateToOneWithWhereWithoutRepliesInput = {
    where?: CommentWhereInput
    data: XOR<CommentUpdateWithoutRepliesInput, CommentUncheckedUpdateWithoutRepliesInput>
  }

  export type CommentUpdateWithoutRepliesInput = {
    id?: StringFieldUpdateOperationsInput | string
    body?: StringFieldUpdateOperationsInput | string
    status?: EnumCommentStatusFieldUpdateOperationsInput | $Enums.CommentStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    product?: ProductUpdateOneRequiredWithoutCommentsNestedInput
    customer?: CustomerUpdateOneRequiredWithoutCommentsNestedInput
    replyTo?: CommentUpdateOneWithoutRepliesNestedInput
  }

  export type CommentUncheckedUpdateWithoutRepliesInput = {
    id?: StringFieldUpdateOperationsInput | string
    productId?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    body?: StringFieldUpdateOperationsInput | string
    status?: EnumCommentStatusFieldUpdateOperationsInput | $Enums.CommentStatus
    replyToId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CommentUpsertWithWhereUniqueWithoutReplyToInput = {
    where: CommentWhereUniqueInput
    update: XOR<CommentUpdateWithoutReplyToInput, CommentUncheckedUpdateWithoutReplyToInput>
    create: XOR<CommentCreateWithoutReplyToInput, CommentUncheckedCreateWithoutReplyToInput>
  }

  export type CommentUpdateWithWhereUniqueWithoutReplyToInput = {
    where: CommentWhereUniqueInput
    data: XOR<CommentUpdateWithoutReplyToInput, CommentUncheckedUpdateWithoutReplyToInput>
  }

  export type CommentUpdateManyWithWhereWithoutReplyToInput = {
    where: CommentScalarWhereInput
    data: XOR<CommentUpdateManyMutationInput, CommentUncheckedUpdateManyWithoutReplyToInput>
  }

  export type ProductCreateWithoutPromotionsInput = {
    id?: string
    title: string
    description?: string | null
    productCode?: string | null
    showType?: number
    isActive?: boolean
    createdAt?: Date | string
    category?: CategoryCreateNestedOneWithoutProductsInput
    brand?: BrandCreateNestedOneWithoutProductsInput
    variants?: ProductVariantCreateNestedManyWithoutProductInput
    images?: ProductImageCreateNestedManyWithoutProductInput
    collections?: CollectionProductCreateNestedManyWithoutProductInput
    comments?: CommentCreateNestedManyWithoutProductInput
    allocationItems?: BranchAllocationItemCreateNestedManyWithoutProductInput
  }

  export type ProductUncheckedCreateWithoutPromotionsInput = {
    id?: string
    title: string
    description?: string | null
    categoryId?: string | null
    brandId?: string | null
    productCode?: string | null
    showType?: number
    isActive?: boolean
    createdAt?: Date | string
    variants?: ProductVariantUncheckedCreateNestedManyWithoutProductInput
    images?: ProductImageUncheckedCreateNestedManyWithoutProductInput
    collections?: CollectionProductUncheckedCreateNestedManyWithoutProductInput
    comments?: CommentUncheckedCreateNestedManyWithoutProductInput
    allocationItems?: BranchAllocationItemUncheckedCreateNestedManyWithoutProductInput
  }

  export type ProductCreateOrConnectWithoutPromotionsInput = {
    where: ProductWhereUniqueInput
    create: XOR<ProductCreateWithoutPromotionsInput, ProductUncheckedCreateWithoutPromotionsInput>
  }

  export type CategoryCreateWithoutPromotionsInput = {
    id?: string
    title: string
    type?: number
    imageUrl?: string | null
    iconUrl?: string | null
    metaTag?: string | null
    description?: string | null
    parent?: CategoryCreateNestedOneWithoutChildrenInput
    children?: CategoryCreateNestedManyWithoutParentInput
    products?: ProductCreateNestedManyWithoutCategoryInput
  }

  export type CategoryUncheckedCreateWithoutPromotionsInput = {
    id?: string
    title: string
    type?: number
    imageUrl?: string | null
    iconUrl?: string | null
    metaTag?: string | null
    description?: string | null
    parentId?: string | null
    children?: CategoryUncheckedCreateNestedManyWithoutParentInput
    products?: ProductUncheckedCreateNestedManyWithoutCategoryInput
  }

  export type CategoryCreateOrConnectWithoutPromotionsInput = {
    where: CategoryWhereUniqueInput
    create: XOR<CategoryCreateWithoutPromotionsInput, CategoryUncheckedCreateWithoutPromotionsInput>
  }

  export type CustomerCreateWithoutPromotionsInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    city?: CityCreateNestedOneWithoutCustomersInput
    referredByAgent?: AdminUserCreateNestedOneWithoutReferredCustomersInput
    salesExpertTradingFor?: SalesExpertProfileCreateNestedOneWithoutTradingCustomerInput
    avatarFile?: UploadedFileCreateNestedOneWithoutCustomerAvatarsInput
    addresses?: CustomerAddressCreateNestedManyWithoutCustomerInput
    orders?: OrderCreateNestedManyWithoutCustomerInput
    preOrders?: PreOrderCreateNestedManyWithoutCustomerInput
    ledgerEntries?: LedgerEntryCreateNestedManyWithoutCustomerInput
    walletBonuses?: WalletBonusCreateNestedManyWithoutCustomerInput
    comments?: CommentCreateNestedManyWithoutCustomerInput
    notifications?: NotificationRecipientCreateNestedManyWithoutCustomerInput
    activityLogs?: CustomerActivityLogCreateNestedManyWithoutCustomerInput
    otpChallenges?: CustomerOtpCreateNestedManyWithoutCustomerInput
  }

  export type CustomerUncheckedCreateWithoutPromotionsInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    cityId?: string | null
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    referredByAgentId?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    avatarFileId?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    salesExpertTradingFor?: SalesExpertProfileUncheckedCreateNestedOneWithoutTradingCustomerInput
    addresses?: CustomerAddressUncheckedCreateNestedManyWithoutCustomerInput
    orders?: OrderUncheckedCreateNestedManyWithoutCustomerInput
    preOrders?: PreOrderUncheckedCreateNestedManyWithoutCustomerInput
    ledgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutCustomerInput
    walletBonuses?: WalletBonusUncheckedCreateNestedManyWithoutCustomerInput
    comments?: CommentUncheckedCreateNestedManyWithoutCustomerInput
    notifications?: NotificationRecipientUncheckedCreateNestedManyWithoutCustomerInput
    activityLogs?: CustomerActivityLogUncheckedCreateNestedManyWithoutCustomerInput
    otpChallenges?: CustomerOtpUncheckedCreateNestedManyWithoutCustomerInput
  }

  export type CustomerCreateOrConnectWithoutPromotionsInput = {
    where: CustomerWhereUniqueInput
    create: XOR<CustomerCreateWithoutPromotionsInput, CustomerUncheckedCreateWithoutPromotionsInput>
  }

  export type BrandCreateWithoutPromotionsInput = {
    id?: string
    title: string
    products?: ProductCreateNestedManyWithoutBrandInput
  }

  export type BrandUncheckedCreateWithoutPromotionsInput = {
    id?: string
    title: string
    products?: ProductUncheckedCreateNestedManyWithoutBrandInput
  }

  export type BrandCreateOrConnectWithoutPromotionsInput = {
    where: BrandWhereUniqueInput
    create: XOR<BrandCreateWithoutPromotionsInput, BrandUncheckedCreateWithoutPromotionsInput>
  }

  export type ProductUpsertWithoutPromotionsInput = {
    update: XOR<ProductUpdateWithoutPromotionsInput, ProductUncheckedUpdateWithoutPromotionsInput>
    create: XOR<ProductCreateWithoutPromotionsInput, ProductUncheckedCreateWithoutPromotionsInput>
    where?: ProductWhereInput
  }

  export type ProductUpdateToOneWithWhereWithoutPromotionsInput = {
    where?: ProductWhereInput
    data: XOR<ProductUpdateWithoutPromotionsInput, ProductUncheckedUpdateWithoutPromotionsInput>
  }

  export type ProductUpdateWithoutPromotionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    productCode?: NullableStringFieldUpdateOperationsInput | string | null
    showType?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    category?: CategoryUpdateOneWithoutProductsNestedInput
    brand?: BrandUpdateOneWithoutProductsNestedInput
    variants?: ProductVariantUpdateManyWithoutProductNestedInput
    images?: ProductImageUpdateManyWithoutProductNestedInput
    collections?: CollectionProductUpdateManyWithoutProductNestedInput
    comments?: CommentUpdateManyWithoutProductNestedInput
    allocationItems?: BranchAllocationItemUpdateManyWithoutProductNestedInput
  }

  export type ProductUncheckedUpdateWithoutPromotionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    categoryId?: NullableStringFieldUpdateOperationsInput | string | null
    brandId?: NullableStringFieldUpdateOperationsInput | string | null
    productCode?: NullableStringFieldUpdateOperationsInput | string | null
    showType?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    variants?: ProductVariantUncheckedUpdateManyWithoutProductNestedInput
    images?: ProductImageUncheckedUpdateManyWithoutProductNestedInput
    collections?: CollectionProductUncheckedUpdateManyWithoutProductNestedInput
    comments?: CommentUncheckedUpdateManyWithoutProductNestedInput
    allocationItems?: BranchAllocationItemUncheckedUpdateManyWithoutProductNestedInput
  }

  export type CategoryUpsertWithoutPromotionsInput = {
    update: XOR<CategoryUpdateWithoutPromotionsInput, CategoryUncheckedUpdateWithoutPromotionsInput>
    create: XOR<CategoryCreateWithoutPromotionsInput, CategoryUncheckedCreateWithoutPromotionsInput>
    where?: CategoryWhereInput
  }

  export type CategoryUpdateToOneWithWhereWithoutPromotionsInput = {
    where?: CategoryWhereInput
    data: XOR<CategoryUpdateWithoutPromotionsInput, CategoryUncheckedUpdateWithoutPromotionsInput>
  }

  export type CategoryUpdateWithoutPromotionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    type?: IntFieldUpdateOperationsInput | number
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    iconUrl?: NullableStringFieldUpdateOperationsInput | string | null
    metaTag?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    parent?: CategoryUpdateOneWithoutChildrenNestedInput
    children?: CategoryUpdateManyWithoutParentNestedInput
    products?: ProductUpdateManyWithoutCategoryNestedInput
  }

  export type CategoryUncheckedUpdateWithoutPromotionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    type?: IntFieldUpdateOperationsInput | number
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    iconUrl?: NullableStringFieldUpdateOperationsInput | string | null
    metaTag?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    parentId?: NullableStringFieldUpdateOperationsInput | string | null
    children?: CategoryUncheckedUpdateManyWithoutParentNestedInput
    products?: ProductUncheckedUpdateManyWithoutCategoryNestedInput
  }

  export type CustomerUpsertWithoutPromotionsInput = {
    update: XOR<CustomerUpdateWithoutPromotionsInput, CustomerUncheckedUpdateWithoutPromotionsInput>
    create: XOR<CustomerCreateWithoutPromotionsInput, CustomerUncheckedCreateWithoutPromotionsInput>
    where?: CustomerWhereInput
  }

  export type CustomerUpdateToOneWithWhereWithoutPromotionsInput = {
    where?: CustomerWhereInput
    data: XOR<CustomerUpdateWithoutPromotionsInput, CustomerUncheckedUpdateWithoutPromotionsInput>
  }

  export type CustomerUpdateWithoutPromotionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutCustomersNestedInput
    referredByAgent?: AdminUserUpdateOneWithoutReferredCustomersNestedInput
    salesExpertTradingFor?: SalesExpertProfileUpdateOneWithoutTradingCustomerNestedInput
    avatarFile?: UploadedFileUpdateOneWithoutCustomerAvatarsNestedInput
    addresses?: CustomerAddressUpdateManyWithoutCustomerNestedInput
    orders?: OrderUpdateManyWithoutCustomerNestedInput
    preOrders?: PreOrderUpdateManyWithoutCustomerNestedInput
    ledgerEntries?: LedgerEntryUpdateManyWithoutCustomerNestedInput
    walletBonuses?: WalletBonusUpdateManyWithoutCustomerNestedInput
    comments?: CommentUpdateManyWithoutCustomerNestedInput
    notifications?: NotificationRecipientUpdateManyWithoutCustomerNestedInput
    activityLogs?: CustomerActivityLogUpdateManyWithoutCustomerNestedInput
    otpChallenges?: CustomerOtpUpdateManyWithoutCustomerNestedInput
  }

  export type CustomerUncheckedUpdateWithoutPromotionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredByAgentId?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    salesExpertTradingFor?: SalesExpertProfileUncheckedUpdateOneWithoutTradingCustomerNestedInput
    addresses?: CustomerAddressUncheckedUpdateManyWithoutCustomerNestedInput
    orders?: OrderUncheckedUpdateManyWithoutCustomerNestedInput
    preOrders?: PreOrderUncheckedUpdateManyWithoutCustomerNestedInput
    ledgerEntries?: LedgerEntryUncheckedUpdateManyWithoutCustomerNestedInput
    walletBonuses?: WalletBonusUncheckedUpdateManyWithoutCustomerNestedInput
    comments?: CommentUncheckedUpdateManyWithoutCustomerNestedInput
    notifications?: NotificationRecipientUncheckedUpdateManyWithoutCustomerNestedInput
    activityLogs?: CustomerActivityLogUncheckedUpdateManyWithoutCustomerNestedInput
    otpChallenges?: CustomerOtpUncheckedUpdateManyWithoutCustomerNestedInput
  }

  export type BrandUpsertWithoutPromotionsInput = {
    update: XOR<BrandUpdateWithoutPromotionsInput, BrandUncheckedUpdateWithoutPromotionsInput>
    create: XOR<BrandCreateWithoutPromotionsInput, BrandUncheckedCreateWithoutPromotionsInput>
    where?: BrandWhereInput
  }

  export type BrandUpdateToOneWithWhereWithoutPromotionsInput = {
    where?: BrandWhereInput
    data: XOR<BrandUpdateWithoutPromotionsInput, BrandUncheckedUpdateWithoutPromotionsInput>
  }

  export type BrandUpdateWithoutPromotionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    products?: ProductUpdateManyWithoutBrandNestedInput
  }

  export type BrandUncheckedUpdateWithoutPromotionsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    products?: ProductUncheckedUpdateManyWithoutBrandNestedInput
  }

  export type BranchCreateWithoutAllocationsInput = {
    id?: string
    name: string
    address?: string | null
    phone?: string | null
    isActive?: boolean
    city?: CityCreateNestedOneWithoutBranchesInput
    adminUsers?: AdminUserCreateNestedManyWithoutBranchInput
    orders?: OrderCreateNestedManyWithoutBranchInput
  }

  export type BranchUncheckedCreateWithoutAllocationsInput = {
    id?: string
    name: string
    address?: string | null
    phone?: string | null
    isActive?: boolean
    cityId?: string | null
    adminUsers?: AdminUserUncheckedCreateNestedManyWithoutBranchInput
    orders?: OrderUncheckedCreateNestedManyWithoutBranchInput
  }

  export type BranchCreateOrConnectWithoutAllocationsInput = {
    where: BranchWhereUniqueInput
    create: XOR<BranchCreateWithoutAllocationsInput, BranchUncheckedCreateWithoutAllocationsInput>
  }

  export type AdminUserCreateWithoutBranchAllocationsInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    userType?: UserTypeCreateNestedOneWithoutAdminUsersInput
    branch?: BranchCreateNestedOneWithoutAdminUsersInput
    avatarFile?: UploadedFileCreateNestedOneWithoutAdminUserAvatarsInput
    referredCustomers?: CustomerCreateNestedManyWithoutReferredByAgentInput
    supervisedWorkshops?: WorkshopCreateNestedManyWithoutSupervisorInput
    postedLedgerEntries?: LedgerEntryCreateNestedManyWithoutPostedByAdminUserInput
    orderStatusEvents?: OrderStatusEventCreateNestedManyWithoutActorAdminUserInput
    preOrderStatusEvents?: PreOrderStatusEventCreateNestedManyWithoutActorAdminUserInput
    sentSmsMessages?: SmsMessageCreateNestedManyWithoutSentByAdminUserInput
    sentNotifications?: NotificationCreateNestedManyWithoutSentByAdminUserInput
    uploadedFiles?: UploadedFileCreateNestedManyWithoutUploadedByAdminUserInput
    salesExpertProfile?: SalesExpertProfileCreateNestedOneWithoutAdminUserInput
    sessions?: AdminSessionCreateNestedManyWithoutAdminUserInput
  }

  export type AdminUserUncheckedCreateWithoutBranchAllocationsInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    userTypeId?: number | null
    branchId?: string | null
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    avatarFileId?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    referredCustomers?: CustomerUncheckedCreateNestedManyWithoutReferredByAgentInput
    supervisedWorkshops?: WorkshopUncheckedCreateNestedManyWithoutSupervisorInput
    postedLedgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutPostedByAdminUserInput
    orderStatusEvents?: OrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput
    preOrderStatusEvents?: PreOrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput
    sentSmsMessages?: SmsMessageUncheckedCreateNestedManyWithoutSentByAdminUserInput
    sentNotifications?: NotificationUncheckedCreateNestedManyWithoutSentByAdminUserInput
    uploadedFiles?: UploadedFileUncheckedCreateNestedManyWithoutUploadedByAdminUserInput
    salesExpertProfile?: SalesExpertProfileUncheckedCreateNestedOneWithoutAdminUserInput
    sessions?: AdminSessionUncheckedCreateNestedManyWithoutAdminUserInput
  }

  export type AdminUserCreateOrConnectWithoutBranchAllocationsInput = {
    where: AdminUserWhereUniqueInput
    create: XOR<AdminUserCreateWithoutBranchAllocationsInput, AdminUserUncheckedCreateWithoutBranchAllocationsInput>
  }

  export type BranchAllocationItemCreateWithoutAllocationInput = {
    id?: string
    weightGrams?: Decimal | DecimalJsLike | number | string | null
    product: ProductCreateNestedOneWithoutAllocationItemsInput
  }

  export type BranchAllocationItemUncheckedCreateWithoutAllocationInput = {
    id?: string
    productId: string
    weightGrams?: Decimal | DecimalJsLike | number | string | null
  }

  export type BranchAllocationItemCreateOrConnectWithoutAllocationInput = {
    where: BranchAllocationItemWhereUniqueInput
    create: XOR<BranchAllocationItemCreateWithoutAllocationInput, BranchAllocationItemUncheckedCreateWithoutAllocationInput>
  }

  export type BranchAllocationItemCreateManyAllocationInputEnvelope = {
    data: BranchAllocationItemCreateManyAllocationInput | BranchAllocationItemCreateManyAllocationInput[]
    skipDuplicates?: boolean
  }

  export type BranchUpsertWithoutAllocationsInput = {
    update: XOR<BranchUpdateWithoutAllocationsInput, BranchUncheckedUpdateWithoutAllocationsInput>
    create: XOR<BranchCreateWithoutAllocationsInput, BranchUncheckedCreateWithoutAllocationsInput>
    where?: BranchWhereInput
  }

  export type BranchUpdateToOneWithWhereWithoutAllocationsInput = {
    where?: BranchWhereInput
    data: XOR<BranchUpdateWithoutAllocationsInput, BranchUncheckedUpdateWithoutAllocationsInput>
  }

  export type BranchUpdateWithoutAllocationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    city?: CityUpdateOneWithoutBranchesNestedInput
    adminUsers?: AdminUserUpdateManyWithoutBranchNestedInput
    orders?: OrderUpdateManyWithoutBranchNestedInput
  }

  export type BranchUncheckedUpdateWithoutAllocationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    adminUsers?: AdminUserUncheckedUpdateManyWithoutBranchNestedInput
    orders?: OrderUncheckedUpdateManyWithoutBranchNestedInput
  }

  export type AdminUserUpsertWithoutBranchAllocationsInput = {
    update: XOR<AdminUserUpdateWithoutBranchAllocationsInput, AdminUserUncheckedUpdateWithoutBranchAllocationsInput>
    create: XOR<AdminUserCreateWithoutBranchAllocationsInput, AdminUserUncheckedCreateWithoutBranchAllocationsInput>
    where?: AdminUserWhereInput
  }

  export type AdminUserUpdateToOneWithWhereWithoutBranchAllocationsInput = {
    where?: AdminUserWhereInput
    data: XOR<AdminUserUpdateWithoutBranchAllocationsInput, AdminUserUncheckedUpdateWithoutBranchAllocationsInput>
  }

  export type AdminUserUpdateWithoutBranchAllocationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    userType?: UserTypeUpdateOneWithoutAdminUsersNestedInput
    branch?: BranchUpdateOneWithoutAdminUsersNestedInput
    avatarFile?: UploadedFileUpdateOneWithoutAdminUserAvatarsNestedInput
    referredCustomers?: CustomerUpdateManyWithoutReferredByAgentNestedInput
    supervisedWorkshops?: WorkshopUpdateManyWithoutSupervisorNestedInput
    postedLedgerEntries?: LedgerEntryUpdateManyWithoutPostedByAdminUserNestedInput
    orderStatusEvents?: OrderStatusEventUpdateManyWithoutActorAdminUserNestedInput
    preOrderStatusEvents?: PreOrderStatusEventUpdateManyWithoutActorAdminUserNestedInput
    sentSmsMessages?: SmsMessageUpdateManyWithoutSentByAdminUserNestedInput
    sentNotifications?: NotificationUpdateManyWithoutSentByAdminUserNestedInput
    uploadedFiles?: UploadedFileUpdateManyWithoutUploadedByAdminUserNestedInput
    salesExpertProfile?: SalesExpertProfileUpdateOneWithoutAdminUserNestedInput
    sessions?: AdminSessionUpdateManyWithoutAdminUserNestedInput
  }

  export type AdminUserUncheckedUpdateWithoutBranchAllocationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    userTypeId?: NullableIntFieldUpdateOperationsInput | number | null
    branchId?: NullableStringFieldUpdateOperationsInput | string | null
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredCustomers?: CustomerUncheckedUpdateManyWithoutReferredByAgentNestedInput
    supervisedWorkshops?: WorkshopUncheckedUpdateManyWithoutSupervisorNestedInput
    postedLedgerEntries?: LedgerEntryUncheckedUpdateManyWithoutPostedByAdminUserNestedInput
    orderStatusEvents?: OrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput
    preOrderStatusEvents?: PreOrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput
    sentSmsMessages?: SmsMessageUncheckedUpdateManyWithoutSentByAdminUserNestedInput
    sentNotifications?: NotificationUncheckedUpdateManyWithoutSentByAdminUserNestedInput
    uploadedFiles?: UploadedFileUncheckedUpdateManyWithoutUploadedByAdminUserNestedInput
    salesExpertProfile?: SalesExpertProfileUncheckedUpdateOneWithoutAdminUserNestedInput
    sessions?: AdminSessionUncheckedUpdateManyWithoutAdminUserNestedInput
  }

  export type BranchAllocationItemUpsertWithWhereUniqueWithoutAllocationInput = {
    where: BranchAllocationItemWhereUniqueInput
    update: XOR<BranchAllocationItemUpdateWithoutAllocationInput, BranchAllocationItemUncheckedUpdateWithoutAllocationInput>
    create: XOR<BranchAllocationItemCreateWithoutAllocationInput, BranchAllocationItemUncheckedCreateWithoutAllocationInput>
  }

  export type BranchAllocationItemUpdateWithWhereUniqueWithoutAllocationInput = {
    where: BranchAllocationItemWhereUniqueInput
    data: XOR<BranchAllocationItemUpdateWithoutAllocationInput, BranchAllocationItemUncheckedUpdateWithoutAllocationInput>
  }

  export type BranchAllocationItemUpdateManyWithWhereWithoutAllocationInput = {
    where: BranchAllocationItemScalarWhereInput
    data: XOR<BranchAllocationItemUpdateManyMutationInput, BranchAllocationItemUncheckedUpdateManyWithoutAllocationInput>
  }

  export type BranchAllocationCreateWithoutItemsInput = {
    id?: string
    note?: string | null
    createdAt?: Date | string
    branch: BranchCreateNestedOneWithoutAllocationsInput
    allocatorAdminUser?: AdminUserCreateNestedOneWithoutBranchAllocationsInput
  }

  export type BranchAllocationUncheckedCreateWithoutItemsInput = {
    id?: string
    branchId: string
    allocatorAdminUserId?: string | null
    note?: string | null
    createdAt?: Date | string
  }

  export type BranchAllocationCreateOrConnectWithoutItemsInput = {
    where: BranchAllocationWhereUniqueInput
    create: XOR<BranchAllocationCreateWithoutItemsInput, BranchAllocationUncheckedCreateWithoutItemsInput>
  }

  export type ProductCreateWithoutAllocationItemsInput = {
    id?: string
    title: string
    description?: string | null
    productCode?: string | null
    showType?: number
    isActive?: boolean
    createdAt?: Date | string
    category?: CategoryCreateNestedOneWithoutProductsInput
    brand?: BrandCreateNestedOneWithoutProductsInput
    variants?: ProductVariantCreateNestedManyWithoutProductInput
    images?: ProductImageCreateNestedManyWithoutProductInput
    collections?: CollectionProductCreateNestedManyWithoutProductInput
    comments?: CommentCreateNestedManyWithoutProductInput
    promotions?: PromotionCreateNestedManyWithoutProductInput
  }

  export type ProductUncheckedCreateWithoutAllocationItemsInput = {
    id?: string
    title: string
    description?: string | null
    categoryId?: string | null
    brandId?: string | null
    productCode?: string | null
    showType?: number
    isActive?: boolean
    createdAt?: Date | string
    variants?: ProductVariantUncheckedCreateNestedManyWithoutProductInput
    images?: ProductImageUncheckedCreateNestedManyWithoutProductInput
    collections?: CollectionProductUncheckedCreateNestedManyWithoutProductInput
    comments?: CommentUncheckedCreateNestedManyWithoutProductInput
    promotions?: PromotionUncheckedCreateNestedManyWithoutProductInput
  }

  export type ProductCreateOrConnectWithoutAllocationItemsInput = {
    where: ProductWhereUniqueInput
    create: XOR<ProductCreateWithoutAllocationItemsInput, ProductUncheckedCreateWithoutAllocationItemsInput>
  }

  export type BranchAllocationUpsertWithoutItemsInput = {
    update: XOR<BranchAllocationUpdateWithoutItemsInput, BranchAllocationUncheckedUpdateWithoutItemsInput>
    create: XOR<BranchAllocationCreateWithoutItemsInput, BranchAllocationUncheckedCreateWithoutItemsInput>
    where?: BranchAllocationWhereInput
  }

  export type BranchAllocationUpdateToOneWithWhereWithoutItemsInput = {
    where?: BranchAllocationWhereInput
    data: XOR<BranchAllocationUpdateWithoutItemsInput, BranchAllocationUncheckedUpdateWithoutItemsInput>
  }

  export type BranchAllocationUpdateWithoutItemsInput = {
    id?: StringFieldUpdateOperationsInput | string
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    branch?: BranchUpdateOneRequiredWithoutAllocationsNestedInput
    allocatorAdminUser?: AdminUserUpdateOneWithoutBranchAllocationsNestedInput
  }

  export type BranchAllocationUncheckedUpdateWithoutItemsInput = {
    id?: StringFieldUpdateOperationsInput | string
    branchId?: StringFieldUpdateOperationsInput | string
    allocatorAdminUserId?: NullableStringFieldUpdateOperationsInput | string | null
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProductUpsertWithoutAllocationItemsInput = {
    update: XOR<ProductUpdateWithoutAllocationItemsInput, ProductUncheckedUpdateWithoutAllocationItemsInput>
    create: XOR<ProductCreateWithoutAllocationItemsInput, ProductUncheckedCreateWithoutAllocationItemsInput>
    where?: ProductWhereInput
  }

  export type ProductUpdateToOneWithWhereWithoutAllocationItemsInput = {
    where?: ProductWhereInput
    data: XOR<ProductUpdateWithoutAllocationItemsInput, ProductUncheckedUpdateWithoutAllocationItemsInput>
  }

  export type ProductUpdateWithoutAllocationItemsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    productCode?: NullableStringFieldUpdateOperationsInput | string | null
    showType?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    category?: CategoryUpdateOneWithoutProductsNestedInput
    brand?: BrandUpdateOneWithoutProductsNestedInput
    variants?: ProductVariantUpdateManyWithoutProductNestedInput
    images?: ProductImageUpdateManyWithoutProductNestedInput
    collections?: CollectionProductUpdateManyWithoutProductNestedInput
    comments?: CommentUpdateManyWithoutProductNestedInput
    promotions?: PromotionUpdateManyWithoutProductNestedInput
  }

  export type ProductUncheckedUpdateWithoutAllocationItemsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    categoryId?: NullableStringFieldUpdateOperationsInput | string | null
    brandId?: NullableStringFieldUpdateOperationsInput | string | null
    productCode?: NullableStringFieldUpdateOperationsInput | string | null
    showType?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    variants?: ProductVariantUncheckedUpdateManyWithoutProductNestedInput
    images?: ProductImageUncheckedUpdateManyWithoutProductNestedInput
    collections?: CollectionProductUncheckedUpdateManyWithoutProductNestedInput
    comments?: CommentUncheckedUpdateManyWithoutProductNestedInput
    promotions?: PromotionUncheckedUpdateManyWithoutProductNestedInput
  }

  export type AdminUserCreateWithoutSentSmsMessagesInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    userType?: UserTypeCreateNestedOneWithoutAdminUsersInput
    branch?: BranchCreateNestedOneWithoutAdminUsersInput
    avatarFile?: UploadedFileCreateNestedOneWithoutAdminUserAvatarsInput
    referredCustomers?: CustomerCreateNestedManyWithoutReferredByAgentInput
    supervisedWorkshops?: WorkshopCreateNestedManyWithoutSupervisorInput
    branchAllocations?: BranchAllocationCreateNestedManyWithoutAllocatorAdminUserInput
    postedLedgerEntries?: LedgerEntryCreateNestedManyWithoutPostedByAdminUserInput
    orderStatusEvents?: OrderStatusEventCreateNestedManyWithoutActorAdminUserInput
    preOrderStatusEvents?: PreOrderStatusEventCreateNestedManyWithoutActorAdminUserInput
    sentNotifications?: NotificationCreateNestedManyWithoutSentByAdminUserInput
    uploadedFiles?: UploadedFileCreateNestedManyWithoutUploadedByAdminUserInput
    salesExpertProfile?: SalesExpertProfileCreateNestedOneWithoutAdminUserInput
    sessions?: AdminSessionCreateNestedManyWithoutAdminUserInput
  }

  export type AdminUserUncheckedCreateWithoutSentSmsMessagesInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    userTypeId?: number | null
    branchId?: string | null
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    avatarFileId?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    referredCustomers?: CustomerUncheckedCreateNestedManyWithoutReferredByAgentInput
    supervisedWorkshops?: WorkshopUncheckedCreateNestedManyWithoutSupervisorInput
    branchAllocations?: BranchAllocationUncheckedCreateNestedManyWithoutAllocatorAdminUserInput
    postedLedgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutPostedByAdminUserInput
    orderStatusEvents?: OrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput
    preOrderStatusEvents?: PreOrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput
    sentNotifications?: NotificationUncheckedCreateNestedManyWithoutSentByAdminUserInput
    uploadedFiles?: UploadedFileUncheckedCreateNestedManyWithoutUploadedByAdminUserInput
    salesExpertProfile?: SalesExpertProfileUncheckedCreateNestedOneWithoutAdminUserInput
    sessions?: AdminSessionUncheckedCreateNestedManyWithoutAdminUserInput
  }

  export type AdminUserCreateOrConnectWithoutSentSmsMessagesInput = {
    where: AdminUserWhereUniqueInput
    create: XOR<AdminUserCreateWithoutSentSmsMessagesInput, AdminUserUncheckedCreateWithoutSentSmsMessagesInput>
  }

  export type AdminUserUpsertWithoutSentSmsMessagesInput = {
    update: XOR<AdminUserUpdateWithoutSentSmsMessagesInput, AdminUserUncheckedUpdateWithoutSentSmsMessagesInput>
    create: XOR<AdminUserCreateWithoutSentSmsMessagesInput, AdminUserUncheckedCreateWithoutSentSmsMessagesInput>
    where?: AdminUserWhereInput
  }

  export type AdminUserUpdateToOneWithWhereWithoutSentSmsMessagesInput = {
    where?: AdminUserWhereInput
    data: XOR<AdminUserUpdateWithoutSentSmsMessagesInput, AdminUserUncheckedUpdateWithoutSentSmsMessagesInput>
  }

  export type AdminUserUpdateWithoutSentSmsMessagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    userType?: UserTypeUpdateOneWithoutAdminUsersNestedInput
    branch?: BranchUpdateOneWithoutAdminUsersNestedInput
    avatarFile?: UploadedFileUpdateOneWithoutAdminUserAvatarsNestedInput
    referredCustomers?: CustomerUpdateManyWithoutReferredByAgentNestedInput
    supervisedWorkshops?: WorkshopUpdateManyWithoutSupervisorNestedInput
    branchAllocations?: BranchAllocationUpdateManyWithoutAllocatorAdminUserNestedInput
    postedLedgerEntries?: LedgerEntryUpdateManyWithoutPostedByAdminUserNestedInput
    orderStatusEvents?: OrderStatusEventUpdateManyWithoutActorAdminUserNestedInput
    preOrderStatusEvents?: PreOrderStatusEventUpdateManyWithoutActorAdminUserNestedInput
    sentNotifications?: NotificationUpdateManyWithoutSentByAdminUserNestedInput
    uploadedFiles?: UploadedFileUpdateManyWithoutUploadedByAdminUserNestedInput
    salesExpertProfile?: SalesExpertProfileUpdateOneWithoutAdminUserNestedInput
    sessions?: AdminSessionUpdateManyWithoutAdminUserNestedInput
  }

  export type AdminUserUncheckedUpdateWithoutSentSmsMessagesInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    userTypeId?: NullableIntFieldUpdateOperationsInput | number | null
    branchId?: NullableStringFieldUpdateOperationsInput | string | null
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredCustomers?: CustomerUncheckedUpdateManyWithoutReferredByAgentNestedInput
    supervisedWorkshops?: WorkshopUncheckedUpdateManyWithoutSupervisorNestedInput
    branchAllocations?: BranchAllocationUncheckedUpdateManyWithoutAllocatorAdminUserNestedInput
    postedLedgerEntries?: LedgerEntryUncheckedUpdateManyWithoutPostedByAdminUserNestedInput
    orderStatusEvents?: OrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput
    preOrderStatusEvents?: PreOrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput
    sentNotifications?: NotificationUncheckedUpdateManyWithoutSentByAdminUserNestedInput
    uploadedFiles?: UploadedFileUncheckedUpdateManyWithoutUploadedByAdminUserNestedInput
    salesExpertProfile?: SalesExpertProfileUncheckedUpdateOneWithoutAdminUserNestedInput
    sessions?: AdminSessionUncheckedUpdateManyWithoutAdminUserNestedInput
  }

  export type AdminUserCreateWithoutSentNotificationsInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    userType?: UserTypeCreateNestedOneWithoutAdminUsersInput
    branch?: BranchCreateNestedOneWithoutAdminUsersInput
    avatarFile?: UploadedFileCreateNestedOneWithoutAdminUserAvatarsInput
    referredCustomers?: CustomerCreateNestedManyWithoutReferredByAgentInput
    supervisedWorkshops?: WorkshopCreateNestedManyWithoutSupervisorInput
    branchAllocations?: BranchAllocationCreateNestedManyWithoutAllocatorAdminUserInput
    postedLedgerEntries?: LedgerEntryCreateNestedManyWithoutPostedByAdminUserInput
    orderStatusEvents?: OrderStatusEventCreateNestedManyWithoutActorAdminUserInput
    preOrderStatusEvents?: PreOrderStatusEventCreateNestedManyWithoutActorAdminUserInput
    sentSmsMessages?: SmsMessageCreateNestedManyWithoutSentByAdminUserInput
    uploadedFiles?: UploadedFileCreateNestedManyWithoutUploadedByAdminUserInput
    salesExpertProfile?: SalesExpertProfileCreateNestedOneWithoutAdminUserInput
    sessions?: AdminSessionCreateNestedManyWithoutAdminUserInput
  }

  export type AdminUserUncheckedCreateWithoutSentNotificationsInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    userTypeId?: number | null
    branchId?: string | null
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    avatarFileId?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    referredCustomers?: CustomerUncheckedCreateNestedManyWithoutReferredByAgentInput
    supervisedWorkshops?: WorkshopUncheckedCreateNestedManyWithoutSupervisorInput
    branchAllocations?: BranchAllocationUncheckedCreateNestedManyWithoutAllocatorAdminUserInput
    postedLedgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutPostedByAdminUserInput
    orderStatusEvents?: OrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput
    preOrderStatusEvents?: PreOrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput
    sentSmsMessages?: SmsMessageUncheckedCreateNestedManyWithoutSentByAdminUserInput
    uploadedFiles?: UploadedFileUncheckedCreateNestedManyWithoutUploadedByAdminUserInput
    salesExpertProfile?: SalesExpertProfileUncheckedCreateNestedOneWithoutAdminUserInput
    sessions?: AdminSessionUncheckedCreateNestedManyWithoutAdminUserInput
  }

  export type AdminUserCreateOrConnectWithoutSentNotificationsInput = {
    where: AdminUserWhereUniqueInput
    create: XOR<AdminUserCreateWithoutSentNotificationsInput, AdminUserUncheckedCreateWithoutSentNotificationsInput>
  }

  export type NotificationRecipientCreateWithoutNotificationInput = {
    id?: string
    readAt?: Date | string | null
    customer: CustomerCreateNestedOneWithoutNotificationsInput
  }

  export type NotificationRecipientUncheckedCreateWithoutNotificationInput = {
    id?: string
    customerId: string
    readAt?: Date | string | null
  }

  export type NotificationRecipientCreateOrConnectWithoutNotificationInput = {
    where: NotificationRecipientWhereUniqueInput
    create: XOR<NotificationRecipientCreateWithoutNotificationInput, NotificationRecipientUncheckedCreateWithoutNotificationInput>
  }

  export type NotificationRecipientCreateManyNotificationInputEnvelope = {
    data: NotificationRecipientCreateManyNotificationInput | NotificationRecipientCreateManyNotificationInput[]
    skipDuplicates?: boolean
  }

  export type AdminUserUpsertWithoutSentNotificationsInput = {
    update: XOR<AdminUserUpdateWithoutSentNotificationsInput, AdminUserUncheckedUpdateWithoutSentNotificationsInput>
    create: XOR<AdminUserCreateWithoutSentNotificationsInput, AdminUserUncheckedCreateWithoutSentNotificationsInput>
    where?: AdminUserWhereInput
  }

  export type AdminUserUpdateToOneWithWhereWithoutSentNotificationsInput = {
    where?: AdminUserWhereInput
    data: XOR<AdminUserUpdateWithoutSentNotificationsInput, AdminUserUncheckedUpdateWithoutSentNotificationsInput>
  }

  export type AdminUserUpdateWithoutSentNotificationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    userType?: UserTypeUpdateOneWithoutAdminUsersNestedInput
    branch?: BranchUpdateOneWithoutAdminUsersNestedInput
    avatarFile?: UploadedFileUpdateOneWithoutAdminUserAvatarsNestedInput
    referredCustomers?: CustomerUpdateManyWithoutReferredByAgentNestedInput
    supervisedWorkshops?: WorkshopUpdateManyWithoutSupervisorNestedInput
    branchAllocations?: BranchAllocationUpdateManyWithoutAllocatorAdminUserNestedInput
    postedLedgerEntries?: LedgerEntryUpdateManyWithoutPostedByAdminUserNestedInput
    orderStatusEvents?: OrderStatusEventUpdateManyWithoutActorAdminUserNestedInput
    preOrderStatusEvents?: PreOrderStatusEventUpdateManyWithoutActorAdminUserNestedInput
    sentSmsMessages?: SmsMessageUpdateManyWithoutSentByAdminUserNestedInput
    uploadedFiles?: UploadedFileUpdateManyWithoutUploadedByAdminUserNestedInput
    salesExpertProfile?: SalesExpertProfileUpdateOneWithoutAdminUserNestedInput
    sessions?: AdminSessionUpdateManyWithoutAdminUserNestedInput
  }

  export type AdminUserUncheckedUpdateWithoutSentNotificationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    userTypeId?: NullableIntFieldUpdateOperationsInput | number | null
    branchId?: NullableStringFieldUpdateOperationsInput | string | null
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredCustomers?: CustomerUncheckedUpdateManyWithoutReferredByAgentNestedInput
    supervisedWorkshops?: WorkshopUncheckedUpdateManyWithoutSupervisorNestedInput
    branchAllocations?: BranchAllocationUncheckedUpdateManyWithoutAllocatorAdminUserNestedInput
    postedLedgerEntries?: LedgerEntryUncheckedUpdateManyWithoutPostedByAdminUserNestedInput
    orderStatusEvents?: OrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput
    preOrderStatusEvents?: PreOrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput
    sentSmsMessages?: SmsMessageUncheckedUpdateManyWithoutSentByAdminUserNestedInput
    uploadedFiles?: UploadedFileUncheckedUpdateManyWithoutUploadedByAdminUserNestedInput
    salesExpertProfile?: SalesExpertProfileUncheckedUpdateOneWithoutAdminUserNestedInput
    sessions?: AdminSessionUncheckedUpdateManyWithoutAdminUserNestedInput
  }

  export type NotificationRecipientUpsertWithWhereUniqueWithoutNotificationInput = {
    where: NotificationRecipientWhereUniqueInput
    update: XOR<NotificationRecipientUpdateWithoutNotificationInput, NotificationRecipientUncheckedUpdateWithoutNotificationInput>
    create: XOR<NotificationRecipientCreateWithoutNotificationInput, NotificationRecipientUncheckedCreateWithoutNotificationInput>
  }

  export type NotificationRecipientUpdateWithWhereUniqueWithoutNotificationInput = {
    where: NotificationRecipientWhereUniqueInput
    data: XOR<NotificationRecipientUpdateWithoutNotificationInput, NotificationRecipientUncheckedUpdateWithoutNotificationInput>
  }

  export type NotificationRecipientUpdateManyWithWhereWithoutNotificationInput = {
    where: NotificationRecipientScalarWhereInput
    data: XOR<NotificationRecipientUpdateManyMutationInput, NotificationRecipientUncheckedUpdateManyWithoutNotificationInput>
  }

  export type NotificationCreateWithoutRecipientsInput = {
    id?: string
    title: string
    body: string
    audience?: $Enums.MessageAudience
    createdAt?: Date | string
    sentByAdminUser?: AdminUserCreateNestedOneWithoutSentNotificationsInput
  }

  export type NotificationUncheckedCreateWithoutRecipientsInput = {
    id?: string
    title: string
    body: string
    audience?: $Enums.MessageAudience
    sentByAdminUserId?: string | null
    createdAt?: Date | string
  }

  export type NotificationCreateOrConnectWithoutRecipientsInput = {
    where: NotificationWhereUniqueInput
    create: XOR<NotificationCreateWithoutRecipientsInput, NotificationUncheckedCreateWithoutRecipientsInput>
  }

  export type CustomerCreateWithoutNotificationsInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    city?: CityCreateNestedOneWithoutCustomersInput
    referredByAgent?: AdminUserCreateNestedOneWithoutReferredCustomersInput
    salesExpertTradingFor?: SalesExpertProfileCreateNestedOneWithoutTradingCustomerInput
    avatarFile?: UploadedFileCreateNestedOneWithoutCustomerAvatarsInput
    addresses?: CustomerAddressCreateNestedManyWithoutCustomerInput
    orders?: OrderCreateNestedManyWithoutCustomerInput
    preOrders?: PreOrderCreateNestedManyWithoutCustomerInput
    ledgerEntries?: LedgerEntryCreateNestedManyWithoutCustomerInput
    walletBonuses?: WalletBonusCreateNestedManyWithoutCustomerInput
    comments?: CommentCreateNestedManyWithoutCustomerInput
    promotions?: PromotionCreateNestedManyWithoutCustomerInput
    activityLogs?: CustomerActivityLogCreateNestedManyWithoutCustomerInput
    otpChallenges?: CustomerOtpCreateNestedManyWithoutCustomerInput
  }

  export type CustomerUncheckedCreateWithoutNotificationsInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    cityId?: string | null
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    referredByAgentId?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    avatarFileId?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    salesExpertTradingFor?: SalesExpertProfileUncheckedCreateNestedOneWithoutTradingCustomerInput
    addresses?: CustomerAddressUncheckedCreateNestedManyWithoutCustomerInput
    orders?: OrderUncheckedCreateNestedManyWithoutCustomerInput
    preOrders?: PreOrderUncheckedCreateNestedManyWithoutCustomerInput
    ledgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutCustomerInput
    walletBonuses?: WalletBonusUncheckedCreateNestedManyWithoutCustomerInput
    comments?: CommentUncheckedCreateNestedManyWithoutCustomerInput
    promotions?: PromotionUncheckedCreateNestedManyWithoutCustomerInput
    activityLogs?: CustomerActivityLogUncheckedCreateNestedManyWithoutCustomerInput
    otpChallenges?: CustomerOtpUncheckedCreateNestedManyWithoutCustomerInput
  }

  export type CustomerCreateOrConnectWithoutNotificationsInput = {
    where: CustomerWhereUniqueInput
    create: XOR<CustomerCreateWithoutNotificationsInput, CustomerUncheckedCreateWithoutNotificationsInput>
  }

  export type NotificationUpsertWithoutRecipientsInput = {
    update: XOR<NotificationUpdateWithoutRecipientsInput, NotificationUncheckedUpdateWithoutRecipientsInput>
    create: XOR<NotificationCreateWithoutRecipientsInput, NotificationUncheckedCreateWithoutRecipientsInput>
    where?: NotificationWhereInput
  }

  export type NotificationUpdateToOneWithWhereWithoutRecipientsInput = {
    where?: NotificationWhereInput
    data: XOR<NotificationUpdateWithoutRecipientsInput, NotificationUncheckedUpdateWithoutRecipientsInput>
  }

  export type NotificationUpdateWithoutRecipientsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    body?: StringFieldUpdateOperationsInput | string
    audience?: EnumMessageAudienceFieldUpdateOperationsInput | $Enums.MessageAudience
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    sentByAdminUser?: AdminUserUpdateOneWithoutSentNotificationsNestedInput
  }

  export type NotificationUncheckedUpdateWithoutRecipientsInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    body?: StringFieldUpdateOperationsInput | string
    audience?: EnumMessageAudienceFieldUpdateOperationsInput | $Enums.MessageAudience
    sentByAdminUserId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CustomerUpsertWithoutNotificationsInput = {
    update: XOR<CustomerUpdateWithoutNotificationsInput, CustomerUncheckedUpdateWithoutNotificationsInput>
    create: XOR<CustomerCreateWithoutNotificationsInput, CustomerUncheckedCreateWithoutNotificationsInput>
    where?: CustomerWhereInput
  }

  export type CustomerUpdateToOneWithWhereWithoutNotificationsInput = {
    where?: CustomerWhereInput
    data: XOR<CustomerUpdateWithoutNotificationsInput, CustomerUncheckedUpdateWithoutNotificationsInput>
  }

  export type CustomerUpdateWithoutNotificationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutCustomersNestedInput
    referredByAgent?: AdminUserUpdateOneWithoutReferredCustomersNestedInput
    salesExpertTradingFor?: SalesExpertProfileUpdateOneWithoutTradingCustomerNestedInput
    avatarFile?: UploadedFileUpdateOneWithoutCustomerAvatarsNestedInput
    addresses?: CustomerAddressUpdateManyWithoutCustomerNestedInput
    orders?: OrderUpdateManyWithoutCustomerNestedInput
    preOrders?: PreOrderUpdateManyWithoutCustomerNestedInput
    ledgerEntries?: LedgerEntryUpdateManyWithoutCustomerNestedInput
    walletBonuses?: WalletBonusUpdateManyWithoutCustomerNestedInput
    comments?: CommentUpdateManyWithoutCustomerNestedInput
    promotions?: PromotionUpdateManyWithoutCustomerNestedInput
    activityLogs?: CustomerActivityLogUpdateManyWithoutCustomerNestedInput
    otpChallenges?: CustomerOtpUpdateManyWithoutCustomerNestedInput
  }

  export type CustomerUncheckedUpdateWithoutNotificationsInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredByAgentId?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    salesExpertTradingFor?: SalesExpertProfileUncheckedUpdateOneWithoutTradingCustomerNestedInput
    addresses?: CustomerAddressUncheckedUpdateManyWithoutCustomerNestedInput
    orders?: OrderUncheckedUpdateManyWithoutCustomerNestedInput
    preOrders?: PreOrderUncheckedUpdateManyWithoutCustomerNestedInput
    ledgerEntries?: LedgerEntryUncheckedUpdateManyWithoutCustomerNestedInput
    walletBonuses?: WalletBonusUncheckedUpdateManyWithoutCustomerNestedInput
    comments?: CommentUncheckedUpdateManyWithoutCustomerNestedInput
    promotions?: PromotionUncheckedUpdateManyWithoutCustomerNestedInput
    activityLogs?: CustomerActivityLogUncheckedUpdateManyWithoutCustomerNestedInput
    otpChallenges?: CustomerOtpUncheckedUpdateManyWithoutCustomerNestedInput
  }

  export type CustomerCreateWithoutActivityLogsInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    city?: CityCreateNestedOneWithoutCustomersInput
    referredByAgent?: AdminUserCreateNestedOneWithoutReferredCustomersInput
    salesExpertTradingFor?: SalesExpertProfileCreateNestedOneWithoutTradingCustomerInput
    avatarFile?: UploadedFileCreateNestedOneWithoutCustomerAvatarsInput
    addresses?: CustomerAddressCreateNestedManyWithoutCustomerInput
    orders?: OrderCreateNestedManyWithoutCustomerInput
    preOrders?: PreOrderCreateNestedManyWithoutCustomerInput
    ledgerEntries?: LedgerEntryCreateNestedManyWithoutCustomerInput
    walletBonuses?: WalletBonusCreateNestedManyWithoutCustomerInput
    comments?: CommentCreateNestedManyWithoutCustomerInput
    promotions?: PromotionCreateNestedManyWithoutCustomerInput
    notifications?: NotificationRecipientCreateNestedManyWithoutCustomerInput
    otpChallenges?: CustomerOtpCreateNestedManyWithoutCustomerInput
  }

  export type CustomerUncheckedCreateWithoutActivityLogsInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    cityId?: string | null
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    referredByAgentId?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    avatarFileId?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    salesExpertTradingFor?: SalesExpertProfileUncheckedCreateNestedOneWithoutTradingCustomerInput
    addresses?: CustomerAddressUncheckedCreateNestedManyWithoutCustomerInput
    orders?: OrderUncheckedCreateNestedManyWithoutCustomerInput
    preOrders?: PreOrderUncheckedCreateNestedManyWithoutCustomerInput
    ledgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutCustomerInput
    walletBonuses?: WalletBonusUncheckedCreateNestedManyWithoutCustomerInput
    comments?: CommentUncheckedCreateNestedManyWithoutCustomerInput
    promotions?: PromotionUncheckedCreateNestedManyWithoutCustomerInput
    notifications?: NotificationRecipientUncheckedCreateNestedManyWithoutCustomerInput
    otpChallenges?: CustomerOtpUncheckedCreateNestedManyWithoutCustomerInput
  }

  export type CustomerCreateOrConnectWithoutActivityLogsInput = {
    where: CustomerWhereUniqueInput
    create: XOR<CustomerCreateWithoutActivityLogsInput, CustomerUncheckedCreateWithoutActivityLogsInput>
  }

  export type CustomerUpsertWithoutActivityLogsInput = {
    update: XOR<CustomerUpdateWithoutActivityLogsInput, CustomerUncheckedUpdateWithoutActivityLogsInput>
    create: XOR<CustomerCreateWithoutActivityLogsInput, CustomerUncheckedCreateWithoutActivityLogsInput>
    where?: CustomerWhereInput
  }

  export type CustomerUpdateToOneWithWhereWithoutActivityLogsInput = {
    where?: CustomerWhereInput
    data: XOR<CustomerUpdateWithoutActivityLogsInput, CustomerUncheckedUpdateWithoutActivityLogsInput>
  }

  export type CustomerUpdateWithoutActivityLogsInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutCustomersNestedInput
    referredByAgent?: AdminUserUpdateOneWithoutReferredCustomersNestedInput
    salesExpertTradingFor?: SalesExpertProfileUpdateOneWithoutTradingCustomerNestedInput
    avatarFile?: UploadedFileUpdateOneWithoutCustomerAvatarsNestedInput
    addresses?: CustomerAddressUpdateManyWithoutCustomerNestedInput
    orders?: OrderUpdateManyWithoutCustomerNestedInput
    preOrders?: PreOrderUpdateManyWithoutCustomerNestedInput
    ledgerEntries?: LedgerEntryUpdateManyWithoutCustomerNestedInput
    walletBonuses?: WalletBonusUpdateManyWithoutCustomerNestedInput
    comments?: CommentUpdateManyWithoutCustomerNestedInput
    promotions?: PromotionUpdateManyWithoutCustomerNestedInput
    notifications?: NotificationRecipientUpdateManyWithoutCustomerNestedInput
    otpChallenges?: CustomerOtpUpdateManyWithoutCustomerNestedInput
  }

  export type CustomerUncheckedUpdateWithoutActivityLogsInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredByAgentId?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    salesExpertTradingFor?: SalesExpertProfileUncheckedUpdateOneWithoutTradingCustomerNestedInput
    addresses?: CustomerAddressUncheckedUpdateManyWithoutCustomerNestedInput
    orders?: OrderUncheckedUpdateManyWithoutCustomerNestedInput
    preOrders?: PreOrderUncheckedUpdateManyWithoutCustomerNestedInput
    ledgerEntries?: LedgerEntryUncheckedUpdateManyWithoutCustomerNestedInput
    walletBonuses?: WalletBonusUncheckedUpdateManyWithoutCustomerNestedInput
    comments?: CommentUncheckedUpdateManyWithoutCustomerNestedInput
    promotions?: PromotionUncheckedUpdateManyWithoutCustomerNestedInput
    notifications?: NotificationRecipientUncheckedUpdateManyWithoutCustomerNestedInput
    otpChallenges?: CustomerOtpUncheckedUpdateManyWithoutCustomerNestedInput
  }

  export type AdminUserCreateWithoutUploadedFilesInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    userType?: UserTypeCreateNestedOneWithoutAdminUsersInput
    branch?: BranchCreateNestedOneWithoutAdminUsersInput
    avatarFile?: UploadedFileCreateNestedOneWithoutAdminUserAvatarsInput
    referredCustomers?: CustomerCreateNestedManyWithoutReferredByAgentInput
    supervisedWorkshops?: WorkshopCreateNestedManyWithoutSupervisorInput
    branchAllocations?: BranchAllocationCreateNestedManyWithoutAllocatorAdminUserInput
    postedLedgerEntries?: LedgerEntryCreateNestedManyWithoutPostedByAdminUserInput
    orderStatusEvents?: OrderStatusEventCreateNestedManyWithoutActorAdminUserInput
    preOrderStatusEvents?: PreOrderStatusEventCreateNestedManyWithoutActorAdminUserInput
    sentSmsMessages?: SmsMessageCreateNestedManyWithoutSentByAdminUserInput
    sentNotifications?: NotificationCreateNestedManyWithoutSentByAdminUserInput
    salesExpertProfile?: SalesExpertProfileCreateNestedOneWithoutAdminUserInput
    sessions?: AdminSessionCreateNestedManyWithoutAdminUserInput
  }

  export type AdminUserUncheckedCreateWithoutUploadedFilesInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    userTypeId?: number | null
    branchId?: string | null
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    avatarFileId?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    referredCustomers?: CustomerUncheckedCreateNestedManyWithoutReferredByAgentInput
    supervisedWorkshops?: WorkshopUncheckedCreateNestedManyWithoutSupervisorInput
    branchAllocations?: BranchAllocationUncheckedCreateNestedManyWithoutAllocatorAdminUserInput
    postedLedgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutPostedByAdminUserInput
    orderStatusEvents?: OrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput
    preOrderStatusEvents?: PreOrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput
    sentSmsMessages?: SmsMessageUncheckedCreateNestedManyWithoutSentByAdminUserInput
    sentNotifications?: NotificationUncheckedCreateNestedManyWithoutSentByAdminUserInput
    salesExpertProfile?: SalesExpertProfileUncheckedCreateNestedOneWithoutAdminUserInput
    sessions?: AdminSessionUncheckedCreateNestedManyWithoutAdminUserInput
  }

  export type AdminUserCreateOrConnectWithoutUploadedFilesInput = {
    where: AdminUserWhereUniqueInput
    create: XOR<AdminUserCreateWithoutUploadedFilesInput, AdminUserUncheckedCreateWithoutUploadedFilesInput>
  }

  export type CustomerCreateWithoutAvatarFileInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    city?: CityCreateNestedOneWithoutCustomersInput
    referredByAgent?: AdminUserCreateNestedOneWithoutReferredCustomersInput
    salesExpertTradingFor?: SalesExpertProfileCreateNestedOneWithoutTradingCustomerInput
    addresses?: CustomerAddressCreateNestedManyWithoutCustomerInput
    orders?: OrderCreateNestedManyWithoutCustomerInput
    preOrders?: PreOrderCreateNestedManyWithoutCustomerInput
    ledgerEntries?: LedgerEntryCreateNestedManyWithoutCustomerInput
    walletBonuses?: WalletBonusCreateNestedManyWithoutCustomerInput
    comments?: CommentCreateNestedManyWithoutCustomerInput
    promotions?: PromotionCreateNestedManyWithoutCustomerInput
    notifications?: NotificationRecipientCreateNestedManyWithoutCustomerInput
    activityLogs?: CustomerActivityLogCreateNestedManyWithoutCustomerInput
    otpChallenges?: CustomerOtpCreateNestedManyWithoutCustomerInput
  }

  export type CustomerUncheckedCreateWithoutAvatarFileInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    cityId?: string | null
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    referredByAgentId?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    salesExpertTradingFor?: SalesExpertProfileUncheckedCreateNestedOneWithoutTradingCustomerInput
    addresses?: CustomerAddressUncheckedCreateNestedManyWithoutCustomerInput
    orders?: OrderUncheckedCreateNestedManyWithoutCustomerInput
    preOrders?: PreOrderUncheckedCreateNestedManyWithoutCustomerInput
    ledgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutCustomerInput
    walletBonuses?: WalletBonusUncheckedCreateNestedManyWithoutCustomerInput
    comments?: CommentUncheckedCreateNestedManyWithoutCustomerInput
    promotions?: PromotionUncheckedCreateNestedManyWithoutCustomerInput
    notifications?: NotificationRecipientUncheckedCreateNestedManyWithoutCustomerInput
    activityLogs?: CustomerActivityLogUncheckedCreateNestedManyWithoutCustomerInput
    otpChallenges?: CustomerOtpUncheckedCreateNestedManyWithoutCustomerInput
  }

  export type CustomerCreateOrConnectWithoutAvatarFileInput = {
    where: CustomerWhereUniqueInput
    create: XOR<CustomerCreateWithoutAvatarFileInput, CustomerUncheckedCreateWithoutAvatarFileInput>
  }

  export type CustomerCreateManyAvatarFileInputEnvelope = {
    data: CustomerCreateManyAvatarFileInput | CustomerCreateManyAvatarFileInput[]
    skipDuplicates?: boolean
  }

  export type AdminUserCreateWithoutAvatarFileInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    userType?: UserTypeCreateNestedOneWithoutAdminUsersInput
    branch?: BranchCreateNestedOneWithoutAdminUsersInput
    referredCustomers?: CustomerCreateNestedManyWithoutReferredByAgentInput
    supervisedWorkshops?: WorkshopCreateNestedManyWithoutSupervisorInput
    branchAllocations?: BranchAllocationCreateNestedManyWithoutAllocatorAdminUserInput
    postedLedgerEntries?: LedgerEntryCreateNestedManyWithoutPostedByAdminUserInput
    orderStatusEvents?: OrderStatusEventCreateNestedManyWithoutActorAdminUserInput
    preOrderStatusEvents?: PreOrderStatusEventCreateNestedManyWithoutActorAdminUserInput
    sentSmsMessages?: SmsMessageCreateNestedManyWithoutSentByAdminUserInput
    sentNotifications?: NotificationCreateNestedManyWithoutSentByAdminUserInput
    uploadedFiles?: UploadedFileCreateNestedManyWithoutUploadedByAdminUserInput
    salesExpertProfile?: SalesExpertProfileCreateNestedOneWithoutAdminUserInput
    sessions?: AdminSessionCreateNestedManyWithoutAdminUserInput
  }

  export type AdminUserUncheckedCreateWithoutAvatarFileInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    userTypeId?: number | null
    branchId?: string | null
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
    referredCustomers?: CustomerUncheckedCreateNestedManyWithoutReferredByAgentInput
    supervisedWorkshops?: WorkshopUncheckedCreateNestedManyWithoutSupervisorInput
    branchAllocations?: BranchAllocationUncheckedCreateNestedManyWithoutAllocatorAdminUserInput
    postedLedgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutPostedByAdminUserInput
    orderStatusEvents?: OrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput
    preOrderStatusEvents?: PreOrderStatusEventUncheckedCreateNestedManyWithoutActorAdminUserInput
    sentSmsMessages?: SmsMessageUncheckedCreateNestedManyWithoutSentByAdminUserInput
    sentNotifications?: NotificationUncheckedCreateNestedManyWithoutSentByAdminUserInput
    uploadedFiles?: UploadedFileUncheckedCreateNestedManyWithoutUploadedByAdminUserInput
    salesExpertProfile?: SalesExpertProfileUncheckedCreateNestedOneWithoutAdminUserInput
    sessions?: AdminSessionUncheckedCreateNestedManyWithoutAdminUserInput
  }

  export type AdminUserCreateOrConnectWithoutAvatarFileInput = {
    where: AdminUserWhereUniqueInput
    create: XOR<AdminUserCreateWithoutAvatarFileInput, AdminUserUncheckedCreateWithoutAvatarFileInput>
  }

  export type AdminUserCreateManyAvatarFileInputEnvelope = {
    data: AdminUserCreateManyAvatarFileInput | AdminUserCreateManyAvatarFileInput[]
    skipDuplicates?: boolean
  }

  export type AdminUserUpsertWithoutUploadedFilesInput = {
    update: XOR<AdminUserUpdateWithoutUploadedFilesInput, AdminUserUncheckedUpdateWithoutUploadedFilesInput>
    create: XOR<AdminUserCreateWithoutUploadedFilesInput, AdminUserUncheckedCreateWithoutUploadedFilesInput>
    where?: AdminUserWhereInput
  }

  export type AdminUserUpdateToOneWithWhereWithoutUploadedFilesInput = {
    where?: AdminUserWhereInput
    data: XOR<AdminUserUpdateWithoutUploadedFilesInput, AdminUserUncheckedUpdateWithoutUploadedFilesInput>
  }

  export type AdminUserUpdateWithoutUploadedFilesInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    userType?: UserTypeUpdateOneWithoutAdminUsersNestedInput
    branch?: BranchUpdateOneWithoutAdminUsersNestedInput
    avatarFile?: UploadedFileUpdateOneWithoutAdminUserAvatarsNestedInput
    referredCustomers?: CustomerUpdateManyWithoutReferredByAgentNestedInput
    supervisedWorkshops?: WorkshopUpdateManyWithoutSupervisorNestedInput
    branchAllocations?: BranchAllocationUpdateManyWithoutAllocatorAdminUserNestedInput
    postedLedgerEntries?: LedgerEntryUpdateManyWithoutPostedByAdminUserNestedInput
    orderStatusEvents?: OrderStatusEventUpdateManyWithoutActorAdminUserNestedInput
    preOrderStatusEvents?: PreOrderStatusEventUpdateManyWithoutActorAdminUserNestedInput
    sentSmsMessages?: SmsMessageUpdateManyWithoutSentByAdminUserNestedInput
    sentNotifications?: NotificationUpdateManyWithoutSentByAdminUserNestedInput
    salesExpertProfile?: SalesExpertProfileUpdateOneWithoutAdminUserNestedInput
    sessions?: AdminSessionUpdateManyWithoutAdminUserNestedInput
  }

  export type AdminUserUncheckedUpdateWithoutUploadedFilesInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    userTypeId?: NullableIntFieldUpdateOperationsInput | number | null
    branchId?: NullableStringFieldUpdateOperationsInput | string | null
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredCustomers?: CustomerUncheckedUpdateManyWithoutReferredByAgentNestedInput
    supervisedWorkshops?: WorkshopUncheckedUpdateManyWithoutSupervisorNestedInput
    branchAllocations?: BranchAllocationUncheckedUpdateManyWithoutAllocatorAdminUserNestedInput
    postedLedgerEntries?: LedgerEntryUncheckedUpdateManyWithoutPostedByAdminUserNestedInput
    orderStatusEvents?: OrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput
    preOrderStatusEvents?: PreOrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput
    sentSmsMessages?: SmsMessageUncheckedUpdateManyWithoutSentByAdminUserNestedInput
    sentNotifications?: NotificationUncheckedUpdateManyWithoutSentByAdminUserNestedInput
    salesExpertProfile?: SalesExpertProfileUncheckedUpdateOneWithoutAdminUserNestedInput
    sessions?: AdminSessionUncheckedUpdateManyWithoutAdminUserNestedInput
  }

  export type CustomerUpsertWithWhereUniqueWithoutAvatarFileInput = {
    where: CustomerWhereUniqueInput
    update: XOR<CustomerUpdateWithoutAvatarFileInput, CustomerUncheckedUpdateWithoutAvatarFileInput>
    create: XOR<CustomerCreateWithoutAvatarFileInput, CustomerUncheckedCreateWithoutAvatarFileInput>
  }

  export type CustomerUpdateWithWhereUniqueWithoutAvatarFileInput = {
    where: CustomerWhereUniqueInput
    data: XOR<CustomerUpdateWithoutAvatarFileInput, CustomerUncheckedUpdateWithoutAvatarFileInput>
  }

  export type CustomerUpdateManyWithWhereWithoutAvatarFileInput = {
    where: CustomerScalarWhereInput
    data: XOR<CustomerUpdateManyMutationInput, CustomerUncheckedUpdateManyWithoutAvatarFileInput>
  }

  export type AdminUserUpsertWithWhereUniqueWithoutAvatarFileInput = {
    where: AdminUserWhereUniqueInput
    update: XOR<AdminUserUpdateWithoutAvatarFileInput, AdminUserUncheckedUpdateWithoutAvatarFileInput>
    create: XOR<AdminUserCreateWithoutAvatarFileInput, AdminUserUncheckedCreateWithoutAvatarFileInput>
  }

  export type AdminUserUpdateWithWhereUniqueWithoutAvatarFileInput = {
    where: AdminUserWhereUniqueInput
    data: XOR<AdminUserUpdateWithoutAvatarFileInput, AdminUserUncheckedUpdateWithoutAvatarFileInput>
  }

  export type AdminUserUpdateManyWithWhereWithoutAvatarFileInput = {
    where: AdminUserScalarWhereInput
    data: XOR<AdminUserUpdateManyMutationInput, AdminUserUncheckedUpdateManyWithoutAvatarFileInput>
  }

  export type CustomerCreateWithoutOtpChallengesInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    city?: CityCreateNestedOneWithoutCustomersInput
    referredByAgent?: AdminUserCreateNestedOneWithoutReferredCustomersInput
    salesExpertTradingFor?: SalesExpertProfileCreateNestedOneWithoutTradingCustomerInput
    avatarFile?: UploadedFileCreateNestedOneWithoutCustomerAvatarsInput
    addresses?: CustomerAddressCreateNestedManyWithoutCustomerInput
    orders?: OrderCreateNestedManyWithoutCustomerInput
    preOrders?: PreOrderCreateNestedManyWithoutCustomerInput
    ledgerEntries?: LedgerEntryCreateNestedManyWithoutCustomerInput
    walletBonuses?: WalletBonusCreateNestedManyWithoutCustomerInput
    comments?: CommentCreateNestedManyWithoutCustomerInput
    promotions?: PromotionCreateNestedManyWithoutCustomerInput
    notifications?: NotificationRecipientCreateNestedManyWithoutCustomerInput
    activityLogs?: CustomerActivityLogCreateNestedManyWithoutCustomerInput
  }

  export type CustomerUncheckedCreateWithoutOtpChallengesInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    cityId?: string | null
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    referredByAgentId?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    avatarFileId?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
    salesExpertTradingFor?: SalesExpertProfileUncheckedCreateNestedOneWithoutTradingCustomerInput
    addresses?: CustomerAddressUncheckedCreateNestedManyWithoutCustomerInput
    orders?: OrderUncheckedCreateNestedManyWithoutCustomerInput
    preOrders?: PreOrderUncheckedCreateNestedManyWithoutCustomerInput
    ledgerEntries?: LedgerEntryUncheckedCreateNestedManyWithoutCustomerInput
    walletBonuses?: WalletBonusUncheckedCreateNestedManyWithoutCustomerInput
    comments?: CommentUncheckedCreateNestedManyWithoutCustomerInput
    promotions?: PromotionUncheckedCreateNestedManyWithoutCustomerInput
    notifications?: NotificationRecipientUncheckedCreateNestedManyWithoutCustomerInput
    activityLogs?: CustomerActivityLogUncheckedCreateNestedManyWithoutCustomerInput
  }

  export type CustomerCreateOrConnectWithoutOtpChallengesInput = {
    where: CustomerWhereUniqueInput
    create: XOR<CustomerCreateWithoutOtpChallengesInput, CustomerUncheckedCreateWithoutOtpChallengesInput>
  }

  export type CustomerUpsertWithoutOtpChallengesInput = {
    update: XOR<CustomerUpdateWithoutOtpChallengesInput, CustomerUncheckedUpdateWithoutOtpChallengesInput>
    create: XOR<CustomerCreateWithoutOtpChallengesInput, CustomerUncheckedCreateWithoutOtpChallengesInput>
    where?: CustomerWhereInput
  }

  export type CustomerUpdateToOneWithWhereWithoutOtpChallengesInput = {
    where?: CustomerWhereInput
    data: XOR<CustomerUpdateWithoutOtpChallengesInput, CustomerUncheckedUpdateWithoutOtpChallengesInput>
  }

  export type CustomerUpdateWithoutOtpChallengesInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutCustomersNestedInput
    referredByAgent?: AdminUserUpdateOneWithoutReferredCustomersNestedInput
    salesExpertTradingFor?: SalesExpertProfileUpdateOneWithoutTradingCustomerNestedInput
    avatarFile?: UploadedFileUpdateOneWithoutCustomerAvatarsNestedInput
    addresses?: CustomerAddressUpdateManyWithoutCustomerNestedInput
    orders?: OrderUpdateManyWithoutCustomerNestedInput
    preOrders?: PreOrderUpdateManyWithoutCustomerNestedInput
    ledgerEntries?: LedgerEntryUpdateManyWithoutCustomerNestedInput
    walletBonuses?: WalletBonusUpdateManyWithoutCustomerNestedInput
    comments?: CommentUpdateManyWithoutCustomerNestedInput
    promotions?: PromotionUpdateManyWithoutCustomerNestedInput
    notifications?: NotificationRecipientUpdateManyWithoutCustomerNestedInput
    activityLogs?: CustomerActivityLogUpdateManyWithoutCustomerNestedInput
  }

  export type CustomerUncheckedUpdateWithoutOtpChallengesInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredByAgentId?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    salesExpertTradingFor?: SalesExpertProfileUncheckedUpdateOneWithoutTradingCustomerNestedInput
    addresses?: CustomerAddressUncheckedUpdateManyWithoutCustomerNestedInput
    orders?: OrderUncheckedUpdateManyWithoutCustomerNestedInput
    preOrders?: PreOrderUncheckedUpdateManyWithoutCustomerNestedInput
    ledgerEntries?: LedgerEntryUncheckedUpdateManyWithoutCustomerNestedInput
    walletBonuses?: WalletBonusUncheckedUpdateManyWithoutCustomerNestedInput
    comments?: CommentUncheckedUpdateManyWithoutCustomerNestedInput
    promotions?: PromotionUncheckedUpdateManyWithoutCustomerNestedInput
    notifications?: NotificationRecipientUncheckedUpdateManyWithoutCustomerNestedInput
    activityLogs?: CustomerActivityLogUncheckedUpdateManyWithoutCustomerNestedInput
  }

  export type CustomerCreateManyCityInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    referredByAgentId?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    avatarFileId?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type CustomerAddressCreateManyCityInput = {
    id?: string
    customerId: string
    addressLine: string
    isDefault?: boolean
  }

  export type BranchCreateManyCityInput = {
    id?: string
    name: string
    address?: string | null
    phone?: string | null
    isActive?: boolean
  }

  export type PreOrderCreateManyCityInput = {
    id?: string
    customerId: string
    workshopId?: string | null
    status?: $Enums.PreOrderStatus
    designImageUrl?: string | null
    colorName?: string | null
    sizeSpec?: string | null
    stoneColor?: string | null
    minaColor?: string | null
    estimatedWeightGrams?: Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: Decimal | DecimalJsLike | number | string | null
    description?: string | null
    convertedOrderId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type SalesExpertProfileCreateManyCityInput = {
    id?: string
    adminUserId: string
    gramLevel?: Decimal | DecimalJsLike | number | string
    phone?: string | null
    nationalCode?: string | null
    tradingCustomerId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type CustomerUpdateWithoutCityInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    referredByAgent?: AdminUserUpdateOneWithoutReferredCustomersNestedInput
    salesExpertTradingFor?: SalesExpertProfileUpdateOneWithoutTradingCustomerNestedInput
    avatarFile?: UploadedFileUpdateOneWithoutCustomerAvatarsNestedInput
    addresses?: CustomerAddressUpdateManyWithoutCustomerNestedInput
    orders?: OrderUpdateManyWithoutCustomerNestedInput
    preOrders?: PreOrderUpdateManyWithoutCustomerNestedInput
    ledgerEntries?: LedgerEntryUpdateManyWithoutCustomerNestedInput
    walletBonuses?: WalletBonusUpdateManyWithoutCustomerNestedInput
    comments?: CommentUpdateManyWithoutCustomerNestedInput
    promotions?: PromotionUpdateManyWithoutCustomerNestedInput
    notifications?: NotificationRecipientUpdateManyWithoutCustomerNestedInput
    activityLogs?: CustomerActivityLogUpdateManyWithoutCustomerNestedInput
    otpChallenges?: CustomerOtpUpdateManyWithoutCustomerNestedInput
  }

  export type CustomerUncheckedUpdateWithoutCityInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredByAgentId?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    salesExpertTradingFor?: SalesExpertProfileUncheckedUpdateOneWithoutTradingCustomerNestedInput
    addresses?: CustomerAddressUncheckedUpdateManyWithoutCustomerNestedInput
    orders?: OrderUncheckedUpdateManyWithoutCustomerNestedInput
    preOrders?: PreOrderUncheckedUpdateManyWithoutCustomerNestedInput
    ledgerEntries?: LedgerEntryUncheckedUpdateManyWithoutCustomerNestedInput
    walletBonuses?: WalletBonusUncheckedUpdateManyWithoutCustomerNestedInput
    comments?: CommentUncheckedUpdateManyWithoutCustomerNestedInput
    promotions?: PromotionUncheckedUpdateManyWithoutCustomerNestedInput
    notifications?: NotificationRecipientUncheckedUpdateManyWithoutCustomerNestedInput
    activityLogs?: CustomerActivityLogUncheckedUpdateManyWithoutCustomerNestedInput
    otpChallenges?: CustomerOtpUncheckedUpdateManyWithoutCustomerNestedInput
  }

  export type CustomerUncheckedUpdateManyWithoutCityInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredByAgentId?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CustomerAddressUpdateWithoutCityInput = {
    id?: StringFieldUpdateOperationsInput | string
    addressLine?: StringFieldUpdateOperationsInput | string
    isDefault?: BoolFieldUpdateOperationsInput | boolean
    customer?: CustomerUpdateOneRequiredWithoutAddressesNestedInput
  }

  export type CustomerAddressUncheckedUpdateWithoutCityInput = {
    id?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    addressLine?: StringFieldUpdateOperationsInput | string
    isDefault?: BoolFieldUpdateOperationsInput | boolean
  }

  export type CustomerAddressUncheckedUpdateManyWithoutCityInput = {
    id?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    addressLine?: StringFieldUpdateOperationsInput | string
    isDefault?: BoolFieldUpdateOperationsInput | boolean
  }

  export type BranchUpdateWithoutCityInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    adminUsers?: AdminUserUpdateManyWithoutBranchNestedInput
    orders?: OrderUpdateManyWithoutBranchNestedInput
    allocations?: BranchAllocationUpdateManyWithoutBranchNestedInput
  }

  export type BranchUncheckedUpdateWithoutCityInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    adminUsers?: AdminUserUncheckedUpdateManyWithoutBranchNestedInput
    orders?: OrderUncheckedUpdateManyWithoutBranchNestedInput
    allocations?: BranchAllocationUncheckedUpdateManyWithoutBranchNestedInput
  }

  export type BranchUncheckedUpdateManyWithoutCityInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
  }

  export type PreOrderUpdateWithoutCityInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: EnumPreOrderStatusFieldUpdateOperationsInput | $Enums.PreOrderStatus
    designImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    colorName?: NullableStringFieldUpdateOperationsInput | string | null
    sizeSpec?: NullableStringFieldUpdateOperationsInput | string | null
    stoneColor?: NullableStringFieldUpdateOperationsInput | string | null
    minaColor?: NullableStringFieldUpdateOperationsInput | string | null
    estimatedWeightGrams?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    customer?: CustomerUpdateOneRequiredWithoutPreOrdersNestedInput
    workshop?: WorkshopUpdateOneWithoutPreOrdersNestedInput
    convertedOrder?: OrderUpdateOneWithoutConvertedFromPreOrderNestedInput
    statusEvents?: PreOrderStatusEventUpdateManyWithoutPreOrderNestedInput
  }

  export type PreOrderUncheckedUpdateWithoutCityInput = {
    id?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    workshopId?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPreOrderStatusFieldUpdateOperationsInput | $Enums.PreOrderStatus
    designImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    colorName?: NullableStringFieldUpdateOperationsInput | string | null
    sizeSpec?: NullableStringFieldUpdateOperationsInput | string | null
    stoneColor?: NullableStringFieldUpdateOperationsInput | string | null
    minaColor?: NullableStringFieldUpdateOperationsInput | string | null
    estimatedWeightGrams?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    convertedOrderId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    statusEvents?: PreOrderStatusEventUncheckedUpdateManyWithoutPreOrderNestedInput
  }

  export type PreOrderUncheckedUpdateManyWithoutCityInput = {
    id?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    workshopId?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPreOrderStatusFieldUpdateOperationsInput | $Enums.PreOrderStatus
    designImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    colorName?: NullableStringFieldUpdateOperationsInput | string | null
    sizeSpec?: NullableStringFieldUpdateOperationsInput | string | null
    stoneColor?: NullableStringFieldUpdateOperationsInput | string | null
    minaColor?: NullableStringFieldUpdateOperationsInput | string | null
    estimatedWeightGrams?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    convertedOrderId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SalesExpertProfileUpdateWithoutCityInput = {
    id?: StringFieldUpdateOperationsInput | string
    gramLevel?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    nationalCode?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    adminUser?: AdminUserUpdateOneRequiredWithoutSalesExpertProfileNestedInput
    tradingCustomer?: CustomerUpdateOneWithoutSalesExpertTradingForNestedInput
  }

  export type SalesExpertProfileUncheckedUpdateWithoutCityInput = {
    id?: StringFieldUpdateOperationsInput | string
    adminUserId?: StringFieldUpdateOperationsInput | string
    gramLevel?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    nationalCode?: NullableStringFieldUpdateOperationsInput | string | null
    tradingCustomerId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SalesExpertProfileUncheckedUpdateManyWithoutCityInput = {
    id?: StringFieldUpdateOperationsInput | string
    adminUserId?: StringFieldUpdateOperationsInput | string
    gramLevel?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    nationalCode?: NullableStringFieldUpdateOperationsInput | string | null
    tradingCustomerId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CustomerCreateManyReferredByAgentInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    cityId?: string | null
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    avatarFileId?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type WorkshopCreateManySupervisorInput = {
    id?: string
    name: string
    address?: string | null
    phone?: string | null
    isActive?: boolean
  }

  export type BranchAllocationCreateManyAllocatorAdminUserInput = {
    id?: string
    branchId: string
    note?: string | null
    createdAt?: Date | string
  }

  export type LedgerEntryCreateManyPostedByAdminUserInput = {
    id?: string
    customerId: string
    currency: $Enums.LedgerCurrency
    direction: $Enums.LedgerDirection
    sourceType: $Enums.LedgerSourceType
    amount: Decimal | DecimalJsLike | number | string
    karatPerMille?: number | null
    pricePerGramRialAtEntry?: Decimal | DecimalJsLike | number | string | null
    orderId?: string | null
    confirmed?: boolean
    confirmedAt?: Date | string | null
    labName?: string | null
    hallmark?: string | null
    accountName?: string | null
    bankName?: string | null
    transferTo?: string | null
    originalValue?: Decimal | DecimalJsLike | number | string | null
    priceRial?: Decimal | DecimalJsLike | number | string | null
    receivedAt?: Date | string | null
    note?: string | null
    createdAt?: Date | string
  }

  export type OrderStatusEventCreateManyActorAdminUserInput = {
    id?: string
    orderId: string
    fromStatus?: $Enums.OrderStatus | null
    toStatus: $Enums.OrderStatus
    note?: string | null
    createdAt?: Date | string
  }

  export type PreOrderStatusEventCreateManyActorAdminUserInput = {
    id?: string
    preOrderId: string
    changes: JsonNullValueInput | InputJsonValue
    ipAddress?: string | null
    createdAt?: Date | string
  }

  export type SmsMessageCreateManySentByAdminUserInput = {
    id?: string
    audience: $Enums.MessageAudience
    recipients?: string | null
    body: string
    sentCount?: number
    createdAt?: Date | string
  }

  export type NotificationCreateManySentByAdminUserInput = {
    id?: string
    title: string
    body: string
    audience?: $Enums.MessageAudience
    createdAt?: Date | string
  }

  export type UploadedFileCreateManyUploadedByAdminUserInput = {
    id?: string
    url: string
    originalName: string
    mimeType: string
    sizeBytes: number
    purpose?: string | null
    createdAt?: Date | string
  }

  export type AdminSessionCreateManyAdminUserInput = {
    id?: string
    jti: string
    iamSessionId?: string | null
    iamSub?: string | null
    ipAddress?: string | null
    userAgent?: string | null
    createdAt?: Date | string
    expiresAt?: Date | string | null
    lastSeenAt?: Date | string | null
    revokedAt?: Date | string | null
    revokedReason?: string | null
  }

  export type CustomerUpdateWithoutReferredByAgentInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutCustomersNestedInput
    salesExpertTradingFor?: SalesExpertProfileUpdateOneWithoutTradingCustomerNestedInput
    avatarFile?: UploadedFileUpdateOneWithoutCustomerAvatarsNestedInput
    addresses?: CustomerAddressUpdateManyWithoutCustomerNestedInput
    orders?: OrderUpdateManyWithoutCustomerNestedInput
    preOrders?: PreOrderUpdateManyWithoutCustomerNestedInput
    ledgerEntries?: LedgerEntryUpdateManyWithoutCustomerNestedInput
    walletBonuses?: WalletBonusUpdateManyWithoutCustomerNestedInput
    comments?: CommentUpdateManyWithoutCustomerNestedInput
    promotions?: PromotionUpdateManyWithoutCustomerNestedInput
    notifications?: NotificationRecipientUpdateManyWithoutCustomerNestedInput
    activityLogs?: CustomerActivityLogUpdateManyWithoutCustomerNestedInput
    otpChallenges?: CustomerOtpUpdateManyWithoutCustomerNestedInput
  }

  export type CustomerUncheckedUpdateWithoutReferredByAgentInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    salesExpertTradingFor?: SalesExpertProfileUncheckedUpdateOneWithoutTradingCustomerNestedInput
    addresses?: CustomerAddressUncheckedUpdateManyWithoutCustomerNestedInput
    orders?: OrderUncheckedUpdateManyWithoutCustomerNestedInput
    preOrders?: PreOrderUncheckedUpdateManyWithoutCustomerNestedInput
    ledgerEntries?: LedgerEntryUncheckedUpdateManyWithoutCustomerNestedInput
    walletBonuses?: WalletBonusUncheckedUpdateManyWithoutCustomerNestedInput
    comments?: CommentUncheckedUpdateManyWithoutCustomerNestedInput
    promotions?: PromotionUncheckedUpdateManyWithoutCustomerNestedInput
    notifications?: NotificationRecipientUncheckedUpdateManyWithoutCustomerNestedInput
    activityLogs?: CustomerActivityLogUncheckedUpdateManyWithoutCustomerNestedInput
    otpChallenges?: CustomerOtpUncheckedUpdateManyWithoutCustomerNestedInput
  }

  export type CustomerUncheckedUpdateManyWithoutReferredByAgentInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type WorkshopUpdateWithoutSupervisorInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    preOrders?: PreOrderUpdateManyWithoutWorkshopNestedInput
  }

  export type WorkshopUncheckedUpdateWithoutSupervisorInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    preOrders?: PreOrderUncheckedUpdateManyWithoutWorkshopNestedInput
  }

  export type WorkshopUncheckedUpdateManyWithoutSupervisorInput = {
    id?: StringFieldUpdateOperationsInput | string
    name?: StringFieldUpdateOperationsInput | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
  }

  export type BranchAllocationUpdateWithoutAllocatorAdminUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    branch?: BranchUpdateOneRequiredWithoutAllocationsNestedInput
    items?: BranchAllocationItemUpdateManyWithoutAllocationNestedInput
  }

  export type BranchAllocationUncheckedUpdateWithoutAllocatorAdminUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    branchId?: StringFieldUpdateOperationsInput | string
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    items?: BranchAllocationItemUncheckedUpdateManyWithoutAllocationNestedInput
  }

  export type BranchAllocationUncheckedUpdateManyWithoutAllocatorAdminUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    branchId?: StringFieldUpdateOperationsInput | string
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LedgerEntryUpdateWithoutPostedByAdminUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    currency?: EnumLedgerCurrencyFieldUpdateOperationsInput | $Enums.LedgerCurrency
    direction?: EnumLedgerDirectionFieldUpdateOperationsInput | $Enums.LedgerDirection
    sourceType?: EnumLedgerSourceTypeFieldUpdateOperationsInput | $Enums.LedgerSourceType
    amount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    karatPerMille?: NullableIntFieldUpdateOperationsInput | number | null
    pricePerGramRialAtEntry?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    confirmed?: BoolFieldUpdateOperationsInput | boolean
    confirmedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    labName?: NullableStringFieldUpdateOperationsInput | string | null
    hallmark?: NullableStringFieldUpdateOperationsInput | string | null
    accountName?: NullableStringFieldUpdateOperationsInput | string | null
    bankName?: NullableStringFieldUpdateOperationsInput | string | null
    transferTo?: NullableStringFieldUpdateOperationsInput | string | null
    originalValue?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    priceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    receivedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    customer?: CustomerUpdateOneRequiredWithoutLedgerEntriesNestedInput
    order?: OrderUpdateOneWithoutLedgerEntriesNestedInput
  }

  export type LedgerEntryUncheckedUpdateWithoutPostedByAdminUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    currency?: EnumLedgerCurrencyFieldUpdateOperationsInput | $Enums.LedgerCurrency
    direction?: EnumLedgerDirectionFieldUpdateOperationsInput | $Enums.LedgerDirection
    sourceType?: EnumLedgerSourceTypeFieldUpdateOperationsInput | $Enums.LedgerSourceType
    amount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    karatPerMille?: NullableIntFieldUpdateOperationsInput | number | null
    pricePerGramRialAtEntry?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    orderId?: NullableStringFieldUpdateOperationsInput | string | null
    confirmed?: BoolFieldUpdateOperationsInput | boolean
    confirmedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    labName?: NullableStringFieldUpdateOperationsInput | string | null
    hallmark?: NullableStringFieldUpdateOperationsInput | string | null
    accountName?: NullableStringFieldUpdateOperationsInput | string | null
    bankName?: NullableStringFieldUpdateOperationsInput | string | null
    transferTo?: NullableStringFieldUpdateOperationsInput | string | null
    originalValue?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    priceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    receivedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LedgerEntryUncheckedUpdateManyWithoutPostedByAdminUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    currency?: EnumLedgerCurrencyFieldUpdateOperationsInput | $Enums.LedgerCurrency
    direction?: EnumLedgerDirectionFieldUpdateOperationsInput | $Enums.LedgerDirection
    sourceType?: EnumLedgerSourceTypeFieldUpdateOperationsInput | $Enums.LedgerSourceType
    amount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    karatPerMille?: NullableIntFieldUpdateOperationsInput | number | null
    pricePerGramRialAtEntry?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    orderId?: NullableStringFieldUpdateOperationsInput | string | null
    confirmed?: BoolFieldUpdateOperationsInput | boolean
    confirmedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    labName?: NullableStringFieldUpdateOperationsInput | string | null
    hallmark?: NullableStringFieldUpdateOperationsInput | string | null
    accountName?: NullableStringFieldUpdateOperationsInput | string | null
    bankName?: NullableStringFieldUpdateOperationsInput | string | null
    transferTo?: NullableStringFieldUpdateOperationsInput | string | null
    originalValue?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    priceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    receivedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type OrderStatusEventUpdateWithoutActorAdminUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    fromStatus?: NullableEnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus | null
    toStatus?: EnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    order?: OrderUpdateOneRequiredWithoutStatusEventsNestedInput
  }

  export type OrderStatusEventUncheckedUpdateWithoutActorAdminUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderId?: StringFieldUpdateOperationsInput | string
    fromStatus?: NullableEnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus | null
    toStatus?: EnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type OrderStatusEventUncheckedUpdateManyWithoutActorAdminUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderId?: StringFieldUpdateOperationsInput | string
    fromStatus?: NullableEnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus | null
    toStatus?: EnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PreOrderStatusEventUpdateWithoutActorAdminUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    changes?: JsonNullValueInput | InputJsonValue
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    preOrder?: PreOrderUpdateOneRequiredWithoutStatusEventsNestedInput
  }

  export type PreOrderStatusEventUncheckedUpdateWithoutActorAdminUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    preOrderId?: StringFieldUpdateOperationsInput | string
    changes?: JsonNullValueInput | InputJsonValue
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PreOrderStatusEventUncheckedUpdateManyWithoutActorAdminUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    preOrderId?: StringFieldUpdateOperationsInput | string
    changes?: JsonNullValueInput | InputJsonValue
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SmsMessageUpdateWithoutSentByAdminUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    audience?: EnumMessageAudienceFieldUpdateOperationsInput | $Enums.MessageAudience
    recipients?: NullableStringFieldUpdateOperationsInput | string | null
    body?: StringFieldUpdateOperationsInput | string
    sentCount?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SmsMessageUncheckedUpdateWithoutSentByAdminUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    audience?: EnumMessageAudienceFieldUpdateOperationsInput | $Enums.MessageAudience
    recipients?: NullableStringFieldUpdateOperationsInput | string | null
    body?: StringFieldUpdateOperationsInput | string
    sentCount?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type SmsMessageUncheckedUpdateManyWithoutSentByAdminUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    audience?: EnumMessageAudienceFieldUpdateOperationsInput | $Enums.MessageAudience
    recipients?: NullableStringFieldUpdateOperationsInput | string | null
    body?: StringFieldUpdateOperationsInput | string
    sentCount?: IntFieldUpdateOperationsInput | number
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type NotificationUpdateWithoutSentByAdminUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    body?: StringFieldUpdateOperationsInput | string
    audience?: EnumMessageAudienceFieldUpdateOperationsInput | $Enums.MessageAudience
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    recipients?: NotificationRecipientUpdateManyWithoutNotificationNestedInput
  }

  export type NotificationUncheckedUpdateWithoutSentByAdminUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    body?: StringFieldUpdateOperationsInput | string
    audience?: EnumMessageAudienceFieldUpdateOperationsInput | $Enums.MessageAudience
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    recipients?: NotificationRecipientUncheckedUpdateManyWithoutNotificationNestedInput
  }

  export type NotificationUncheckedUpdateManyWithoutSentByAdminUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    body?: StringFieldUpdateOperationsInput | string
    audience?: EnumMessageAudienceFieldUpdateOperationsInput | $Enums.MessageAudience
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type UploadedFileUpdateWithoutUploadedByAdminUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    originalName?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
    sizeBytes?: IntFieldUpdateOperationsInput | number
    purpose?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    customerAvatars?: CustomerUpdateManyWithoutAvatarFileNestedInput
    adminUserAvatars?: AdminUserUpdateManyWithoutAvatarFileNestedInput
  }

  export type UploadedFileUncheckedUpdateWithoutUploadedByAdminUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    originalName?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
    sizeBytes?: IntFieldUpdateOperationsInput | number
    purpose?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    customerAvatars?: CustomerUncheckedUpdateManyWithoutAvatarFileNestedInput
    adminUserAvatars?: AdminUserUncheckedUpdateManyWithoutAvatarFileNestedInput
  }

  export type UploadedFileUncheckedUpdateManyWithoutUploadedByAdminUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    originalName?: StringFieldUpdateOperationsInput | string
    mimeType?: StringFieldUpdateOperationsInput | string
    sizeBytes?: IntFieldUpdateOperationsInput | number
    purpose?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AdminSessionUpdateWithoutAdminUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    jti?: StringFieldUpdateOperationsInput | string
    iamSessionId?: NullableStringFieldUpdateOperationsInput | string | null
    iamSub?: NullableStringFieldUpdateOperationsInput | string | null
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    lastSeenAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    revokedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    revokedReason?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type AdminSessionUncheckedUpdateWithoutAdminUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    jti?: StringFieldUpdateOperationsInput | string
    iamSessionId?: NullableStringFieldUpdateOperationsInput | string | null
    iamSub?: NullableStringFieldUpdateOperationsInput | string | null
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    lastSeenAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    revokedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    revokedReason?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type AdminSessionUncheckedUpdateManyWithoutAdminUserInput = {
    id?: StringFieldUpdateOperationsInput | string
    jti?: StringFieldUpdateOperationsInput | string
    iamSessionId?: NullableStringFieldUpdateOperationsInput | string | null
    iamSub?: NullableStringFieldUpdateOperationsInput | string | null
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    userAgent?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    lastSeenAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    revokedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    revokedReason?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type CustomerAddressCreateManyCustomerInput = {
    id?: string
    cityId?: string | null
    addressLine: string
    isDefault?: boolean
  }

  export type OrderCreateManyCustomerInput = {
    id?: string
    orderNumber: string
    branchId?: string | null
    channel?: $Enums.OrderChannel
    status?: $Enums.OrderStatus
    totalGoldWeightGrams: Decimal | DecimalJsLike | number | string
    wageWeightGrams: Decimal | DecimalJsLike | number | string
    flatRialCharge?: Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: boolean
    deliveredAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type PreOrderCreateManyCustomerInput = {
    id?: string
    cityId?: string | null
    workshopId?: string | null
    status?: $Enums.PreOrderStatus
    designImageUrl?: string | null
    colorName?: string | null
    sizeSpec?: string | null
    stoneColor?: string | null
    minaColor?: string | null
    estimatedWeightGrams?: Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: Decimal | DecimalJsLike | number | string | null
    description?: string | null
    convertedOrderId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type LedgerEntryCreateManyCustomerInput = {
    id?: string
    currency: $Enums.LedgerCurrency
    direction: $Enums.LedgerDirection
    sourceType: $Enums.LedgerSourceType
    amount: Decimal | DecimalJsLike | number | string
    karatPerMille?: number | null
    pricePerGramRialAtEntry?: Decimal | DecimalJsLike | number | string | null
    orderId?: string | null
    confirmed?: boolean
    confirmedAt?: Date | string | null
    postedByAdminUserId?: string | null
    labName?: string | null
    hallmark?: string | null
    accountName?: string | null
    bankName?: string | null
    transferTo?: string | null
    originalValue?: Decimal | DecimalJsLike | number | string | null
    priceRial?: Decimal | DecimalJsLike | number | string | null
    receivedAt?: Date | string | null
    note?: string | null
    createdAt?: Date | string
  }

  export type WalletBonusCreateManyCustomerInput = {
    id?: string
    orderId?: string | null
    goldGrams: Decimal | DecimalJsLike | number | string
    grantedAt?: Date | string
    expiresAt: Date | string
    consumedAt?: Date | string | null
    isActive?: boolean
  }

  export type CommentCreateManyCustomerInput = {
    id?: string
    productId: string
    body: string
    status?: $Enums.CommentStatus
    replyToId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type PromotionCreateManyCustomerInput = {
    id?: string
    title: string
    description?: string | null
    scope?: $Enums.PromotionScope
    usage?: $Enums.PromotionUsage
    discountPercent: Decimal | DecimalJsLike | number | string
    isActive?: boolean
    platform?: number
    startsAt?: Date | string | null
    endsAt?: Date | string | null
    productId?: string | null
    categoryId?: string | null
    brandId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type NotificationRecipientCreateManyCustomerInput = {
    id?: string
    notificationId: string
    readAt?: Date | string | null
  }

  export type CustomerActivityLogCreateManyCustomerInput = {
    id?: string
    action: string
    detail?: string | null
    createdAt?: Date | string
  }

  export type CustomerOtpCreateManyCustomerInput = {
    id?: string
    mobile: string
    codeHash: string
    expiresAt: Date | string
    attempts?: number
    consumedAt?: Date | string | null
    requestIp?: string | null
    createdAt?: Date | string
  }

  export type CustomerAddressUpdateWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    addressLine?: StringFieldUpdateOperationsInput | string
    isDefault?: BoolFieldUpdateOperationsInput | boolean
    city?: CityUpdateOneWithoutAddressesNestedInput
  }

  export type CustomerAddressUncheckedUpdateWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    addressLine?: StringFieldUpdateOperationsInput | string
    isDefault?: BoolFieldUpdateOperationsInput | boolean
  }

  export type CustomerAddressUncheckedUpdateManyWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    addressLine?: StringFieldUpdateOperationsInput | string
    isDefault?: BoolFieldUpdateOperationsInput | boolean
  }

  export type OrderUpdateWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderNumber?: StringFieldUpdateOperationsInput | string
    channel?: EnumOrderChannelFieldUpdateOperationsInput | $Enums.OrderChannel
    status?: EnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus
    totalGoldWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    wageWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: BoolFieldUpdateOperationsInput | boolean
    deliveredAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    branch?: BranchUpdateOneWithoutOrdersNestedInput
    items?: OrderItemUpdateManyWithoutOrderNestedInput
    statusEvents?: OrderStatusEventUpdateManyWithoutOrderNestedInput
    ledgerEntries?: LedgerEntryUpdateManyWithoutOrderNestedInput
    convertedFromPreOrder?: PreOrderUpdateOneWithoutConvertedOrderNestedInput
  }

  export type OrderUncheckedUpdateWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderNumber?: StringFieldUpdateOperationsInput | string
    branchId?: NullableStringFieldUpdateOperationsInput | string | null
    channel?: EnumOrderChannelFieldUpdateOperationsInput | $Enums.OrderChannel
    status?: EnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus
    totalGoldWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    wageWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: BoolFieldUpdateOperationsInput | boolean
    deliveredAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    items?: OrderItemUncheckedUpdateManyWithoutOrderNestedInput
    statusEvents?: OrderStatusEventUncheckedUpdateManyWithoutOrderNestedInput
    ledgerEntries?: LedgerEntryUncheckedUpdateManyWithoutOrderNestedInput
    convertedFromPreOrder?: PreOrderUncheckedUpdateOneWithoutConvertedOrderNestedInput
  }

  export type OrderUncheckedUpdateManyWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderNumber?: StringFieldUpdateOperationsInput | string
    branchId?: NullableStringFieldUpdateOperationsInput | string | null
    channel?: EnumOrderChannelFieldUpdateOperationsInput | $Enums.OrderChannel
    status?: EnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus
    totalGoldWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    wageWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: BoolFieldUpdateOperationsInput | boolean
    deliveredAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PreOrderUpdateWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: EnumPreOrderStatusFieldUpdateOperationsInput | $Enums.PreOrderStatus
    designImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    colorName?: NullableStringFieldUpdateOperationsInput | string | null
    sizeSpec?: NullableStringFieldUpdateOperationsInput | string | null
    stoneColor?: NullableStringFieldUpdateOperationsInput | string | null
    minaColor?: NullableStringFieldUpdateOperationsInput | string | null
    estimatedWeightGrams?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutPreOrdersNestedInput
    workshop?: WorkshopUpdateOneWithoutPreOrdersNestedInput
    convertedOrder?: OrderUpdateOneWithoutConvertedFromPreOrderNestedInput
    statusEvents?: PreOrderStatusEventUpdateManyWithoutPreOrderNestedInput
  }

  export type PreOrderUncheckedUpdateWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    workshopId?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPreOrderStatusFieldUpdateOperationsInput | $Enums.PreOrderStatus
    designImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    colorName?: NullableStringFieldUpdateOperationsInput | string | null
    sizeSpec?: NullableStringFieldUpdateOperationsInput | string | null
    stoneColor?: NullableStringFieldUpdateOperationsInput | string | null
    minaColor?: NullableStringFieldUpdateOperationsInput | string | null
    estimatedWeightGrams?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    convertedOrderId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    statusEvents?: PreOrderStatusEventUncheckedUpdateManyWithoutPreOrderNestedInput
  }

  export type PreOrderUncheckedUpdateManyWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    workshopId?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPreOrderStatusFieldUpdateOperationsInput | $Enums.PreOrderStatus
    designImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    colorName?: NullableStringFieldUpdateOperationsInput | string | null
    sizeSpec?: NullableStringFieldUpdateOperationsInput | string | null
    stoneColor?: NullableStringFieldUpdateOperationsInput | string | null
    minaColor?: NullableStringFieldUpdateOperationsInput | string | null
    estimatedWeightGrams?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    convertedOrderId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LedgerEntryUpdateWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    currency?: EnumLedgerCurrencyFieldUpdateOperationsInput | $Enums.LedgerCurrency
    direction?: EnumLedgerDirectionFieldUpdateOperationsInput | $Enums.LedgerDirection
    sourceType?: EnumLedgerSourceTypeFieldUpdateOperationsInput | $Enums.LedgerSourceType
    amount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    karatPerMille?: NullableIntFieldUpdateOperationsInput | number | null
    pricePerGramRialAtEntry?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    confirmed?: BoolFieldUpdateOperationsInput | boolean
    confirmedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    labName?: NullableStringFieldUpdateOperationsInput | string | null
    hallmark?: NullableStringFieldUpdateOperationsInput | string | null
    accountName?: NullableStringFieldUpdateOperationsInput | string | null
    bankName?: NullableStringFieldUpdateOperationsInput | string | null
    transferTo?: NullableStringFieldUpdateOperationsInput | string | null
    originalValue?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    priceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    receivedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    order?: OrderUpdateOneWithoutLedgerEntriesNestedInput
    postedByAdminUser?: AdminUserUpdateOneWithoutPostedLedgerEntriesNestedInput
  }

  export type LedgerEntryUncheckedUpdateWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    currency?: EnumLedgerCurrencyFieldUpdateOperationsInput | $Enums.LedgerCurrency
    direction?: EnumLedgerDirectionFieldUpdateOperationsInput | $Enums.LedgerDirection
    sourceType?: EnumLedgerSourceTypeFieldUpdateOperationsInput | $Enums.LedgerSourceType
    amount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    karatPerMille?: NullableIntFieldUpdateOperationsInput | number | null
    pricePerGramRialAtEntry?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    orderId?: NullableStringFieldUpdateOperationsInput | string | null
    confirmed?: BoolFieldUpdateOperationsInput | boolean
    confirmedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    postedByAdminUserId?: NullableStringFieldUpdateOperationsInput | string | null
    labName?: NullableStringFieldUpdateOperationsInput | string | null
    hallmark?: NullableStringFieldUpdateOperationsInput | string | null
    accountName?: NullableStringFieldUpdateOperationsInput | string | null
    bankName?: NullableStringFieldUpdateOperationsInput | string | null
    transferTo?: NullableStringFieldUpdateOperationsInput | string | null
    originalValue?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    priceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    receivedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LedgerEntryUncheckedUpdateManyWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    currency?: EnumLedgerCurrencyFieldUpdateOperationsInput | $Enums.LedgerCurrency
    direction?: EnumLedgerDirectionFieldUpdateOperationsInput | $Enums.LedgerDirection
    sourceType?: EnumLedgerSourceTypeFieldUpdateOperationsInput | $Enums.LedgerSourceType
    amount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    karatPerMille?: NullableIntFieldUpdateOperationsInput | number | null
    pricePerGramRialAtEntry?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    orderId?: NullableStringFieldUpdateOperationsInput | string | null
    confirmed?: BoolFieldUpdateOperationsInput | boolean
    confirmedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    postedByAdminUserId?: NullableStringFieldUpdateOperationsInput | string | null
    labName?: NullableStringFieldUpdateOperationsInput | string | null
    hallmark?: NullableStringFieldUpdateOperationsInput | string | null
    accountName?: NullableStringFieldUpdateOperationsInput | string | null
    bankName?: NullableStringFieldUpdateOperationsInput | string | null
    transferTo?: NullableStringFieldUpdateOperationsInput | string | null
    originalValue?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    priceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    receivedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type WalletBonusUpdateWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderId?: NullableStringFieldUpdateOperationsInput | string | null
    goldGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    grantedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    consumedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
  }

  export type WalletBonusUncheckedUpdateWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderId?: NullableStringFieldUpdateOperationsInput | string | null
    goldGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    grantedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    consumedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
  }

  export type WalletBonusUncheckedUpdateManyWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderId?: NullableStringFieldUpdateOperationsInput | string | null
    goldGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    grantedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    consumedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
  }

  export type CommentUpdateWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    body?: StringFieldUpdateOperationsInput | string
    status?: EnumCommentStatusFieldUpdateOperationsInput | $Enums.CommentStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    product?: ProductUpdateOneRequiredWithoutCommentsNestedInput
    replyTo?: CommentUpdateOneWithoutRepliesNestedInput
    replies?: CommentUpdateManyWithoutReplyToNestedInput
  }

  export type CommentUncheckedUpdateWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    productId?: StringFieldUpdateOperationsInput | string
    body?: StringFieldUpdateOperationsInput | string
    status?: EnumCommentStatusFieldUpdateOperationsInput | $Enums.CommentStatus
    replyToId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    replies?: CommentUncheckedUpdateManyWithoutReplyToNestedInput
  }

  export type CommentUncheckedUpdateManyWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    productId?: StringFieldUpdateOperationsInput | string
    body?: StringFieldUpdateOperationsInput | string
    status?: EnumCommentStatusFieldUpdateOperationsInput | $Enums.CommentStatus
    replyToId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PromotionUpdateWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: EnumPromotionScopeFieldUpdateOperationsInput | $Enums.PromotionScope
    usage?: EnumPromotionUsageFieldUpdateOperationsInput | $Enums.PromotionUsage
    discountPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    platform?: IntFieldUpdateOperationsInput | number
    startsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    product?: ProductUpdateOneWithoutPromotionsNestedInput
    category?: CategoryUpdateOneWithoutPromotionsNestedInput
    brand?: BrandUpdateOneWithoutPromotionsNestedInput
  }

  export type PromotionUncheckedUpdateWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: EnumPromotionScopeFieldUpdateOperationsInput | $Enums.PromotionScope
    usage?: EnumPromotionUsageFieldUpdateOperationsInput | $Enums.PromotionUsage
    discountPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    platform?: IntFieldUpdateOperationsInput | number
    startsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    productId?: NullableStringFieldUpdateOperationsInput | string | null
    categoryId?: NullableStringFieldUpdateOperationsInput | string | null
    brandId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PromotionUncheckedUpdateManyWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: EnumPromotionScopeFieldUpdateOperationsInput | $Enums.PromotionScope
    usage?: EnumPromotionUsageFieldUpdateOperationsInput | $Enums.PromotionUsage
    discountPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    platform?: IntFieldUpdateOperationsInput | number
    startsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    productId?: NullableStringFieldUpdateOperationsInput | string | null
    categoryId?: NullableStringFieldUpdateOperationsInput | string | null
    brandId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type NotificationRecipientUpdateWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    readAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    notification?: NotificationUpdateOneRequiredWithoutRecipientsNestedInput
  }

  export type NotificationRecipientUncheckedUpdateWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    notificationId?: StringFieldUpdateOperationsInput | string
    readAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type NotificationRecipientUncheckedUpdateManyWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    notificationId?: StringFieldUpdateOperationsInput | string
    readAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type CustomerActivityLogUpdateWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    action?: StringFieldUpdateOperationsInput | string
    detail?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CustomerActivityLogUncheckedUpdateWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    action?: StringFieldUpdateOperationsInput | string
    detail?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CustomerActivityLogUncheckedUpdateManyWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    action?: StringFieldUpdateOperationsInput | string
    detail?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CustomerOtpUpdateWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    mobile?: StringFieldUpdateOperationsInput | string
    codeHash?: StringFieldUpdateOperationsInput | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    attempts?: IntFieldUpdateOperationsInput | number
    consumedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    requestIp?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CustomerOtpUncheckedUpdateWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    mobile?: StringFieldUpdateOperationsInput | string
    codeHash?: StringFieldUpdateOperationsInput | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    attempts?: IntFieldUpdateOperationsInput | number
    consumedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    requestIp?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CustomerOtpUncheckedUpdateManyWithoutCustomerInput = {
    id?: StringFieldUpdateOperationsInput | string
    mobile?: StringFieldUpdateOperationsInput | string
    codeHash?: StringFieldUpdateOperationsInput | string
    expiresAt?: DateTimeFieldUpdateOperationsInput | Date | string
    attempts?: IntFieldUpdateOperationsInput | number
    consumedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    requestIp?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AdminUserCreateManyBranchInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    userTypeId?: number | null
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    avatarFileId?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
  }

  export type OrderCreateManyBranchInput = {
    id?: string
    orderNumber: string
    customerId: string
    channel?: $Enums.OrderChannel
    status?: $Enums.OrderStatus
    totalGoldWeightGrams: Decimal | DecimalJsLike | number | string
    wageWeightGrams: Decimal | DecimalJsLike | number | string
    flatRialCharge?: Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: boolean
    deliveredAt?: Date | string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type BranchAllocationCreateManyBranchInput = {
    id?: string
    allocatorAdminUserId?: string | null
    note?: string | null
    createdAt?: Date | string
  }

  export type AdminUserUpdateWithoutBranchInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    userType?: UserTypeUpdateOneWithoutAdminUsersNestedInput
    avatarFile?: UploadedFileUpdateOneWithoutAdminUserAvatarsNestedInput
    referredCustomers?: CustomerUpdateManyWithoutReferredByAgentNestedInput
    supervisedWorkshops?: WorkshopUpdateManyWithoutSupervisorNestedInput
    branchAllocations?: BranchAllocationUpdateManyWithoutAllocatorAdminUserNestedInput
    postedLedgerEntries?: LedgerEntryUpdateManyWithoutPostedByAdminUserNestedInput
    orderStatusEvents?: OrderStatusEventUpdateManyWithoutActorAdminUserNestedInput
    preOrderStatusEvents?: PreOrderStatusEventUpdateManyWithoutActorAdminUserNestedInput
    sentSmsMessages?: SmsMessageUpdateManyWithoutSentByAdminUserNestedInput
    sentNotifications?: NotificationUpdateManyWithoutSentByAdminUserNestedInput
    uploadedFiles?: UploadedFileUpdateManyWithoutUploadedByAdminUserNestedInput
    salesExpertProfile?: SalesExpertProfileUpdateOneWithoutAdminUserNestedInput
    sessions?: AdminSessionUpdateManyWithoutAdminUserNestedInput
  }

  export type AdminUserUncheckedUpdateWithoutBranchInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    userTypeId?: NullableIntFieldUpdateOperationsInput | number | null
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredCustomers?: CustomerUncheckedUpdateManyWithoutReferredByAgentNestedInput
    supervisedWorkshops?: WorkshopUncheckedUpdateManyWithoutSupervisorNestedInput
    branchAllocations?: BranchAllocationUncheckedUpdateManyWithoutAllocatorAdminUserNestedInput
    postedLedgerEntries?: LedgerEntryUncheckedUpdateManyWithoutPostedByAdminUserNestedInput
    orderStatusEvents?: OrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput
    preOrderStatusEvents?: PreOrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput
    sentSmsMessages?: SmsMessageUncheckedUpdateManyWithoutSentByAdminUserNestedInput
    sentNotifications?: NotificationUncheckedUpdateManyWithoutSentByAdminUserNestedInput
    uploadedFiles?: UploadedFileUncheckedUpdateManyWithoutUploadedByAdminUserNestedInput
    salesExpertProfile?: SalesExpertProfileUncheckedUpdateOneWithoutAdminUserNestedInput
    sessions?: AdminSessionUncheckedUpdateManyWithoutAdminUserNestedInput
  }

  export type AdminUserUncheckedUpdateManyWithoutBranchInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    userTypeId?: NullableIntFieldUpdateOperationsInput | number | null
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type OrderUpdateWithoutBranchInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderNumber?: StringFieldUpdateOperationsInput | string
    channel?: EnumOrderChannelFieldUpdateOperationsInput | $Enums.OrderChannel
    status?: EnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus
    totalGoldWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    wageWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: BoolFieldUpdateOperationsInput | boolean
    deliveredAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    customer?: CustomerUpdateOneRequiredWithoutOrdersNestedInput
    items?: OrderItemUpdateManyWithoutOrderNestedInput
    statusEvents?: OrderStatusEventUpdateManyWithoutOrderNestedInput
    ledgerEntries?: LedgerEntryUpdateManyWithoutOrderNestedInput
    convertedFromPreOrder?: PreOrderUpdateOneWithoutConvertedOrderNestedInput
  }

  export type OrderUncheckedUpdateWithoutBranchInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderNumber?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    channel?: EnumOrderChannelFieldUpdateOperationsInput | $Enums.OrderChannel
    status?: EnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus
    totalGoldWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    wageWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: BoolFieldUpdateOperationsInput | boolean
    deliveredAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    items?: OrderItemUncheckedUpdateManyWithoutOrderNestedInput
    statusEvents?: OrderStatusEventUncheckedUpdateManyWithoutOrderNestedInput
    ledgerEntries?: LedgerEntryUncheckedUpdateManyWithoutOrderNestedInput
    convertedFromPreOrder?: PreOrderUncheckedUpdateOneWithoutConvertedOrderNestedInput
  }

  export type OrderUncheckedUpdateManyWithoutBranchInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderNumber?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    channel?: EnumOrderChannelFieldUpdateOperationsInput | $Enums.OrderChannel
    status?: EnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus
    totalGoldWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    wageWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isSuspendedOverCreditLimit?: BoolFieldUpdateOperationsInput | boolean
    deliveredAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type BranchAllocationUpdateWithoutBranchInput = {
    id?: StringFieldUpdateOperationsInput | string
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    allocatorAdminUser?: AdminUserUpdateOneWithoutBranchAllocationsNestedInput
    items?: BranchAllocationItemUpdateManyWithoutAllocationNestedInput
  }

  export type BranchAllocationUncheckedUpdateWithoutBranchInput = {
    id?: StringFieldUpdateOperationsInput | string
    allocatorAdminUserId?: NullableStringFieldUpdateOperationsInput | string | null
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    items?: BranchAllocationItemUncheckedUpdateManyWithoutAllocationNestedInput
  }

  export type BranchAllocationUncheckedUpdateManyWithoutBranchInput = {
    id?: StringFieldUpdateOperationsInput | string
    allocatorAdminUserId?: NullableStringFieldUpdateOperationsInput | string | null
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PreOrderCreateManyWorkshopInput = {
    id?: string
    customerId: string
    cityId?: string | null
    status?: $Enums.PreOrderStatus
    designImageUrl?: string | null
    colorName?: string | null
    sizeSpec?: string | null
    stoneColor?: string | null
    minaColor?: string | null
    estimatedWeightGrams?: Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: Decimal | DecimalJsLike | number | string | null
    description?: string | null
    convertedOrderId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type PreOrderUpdateWithoutWorkshopInput = {
    id?: StringFieldUpdateOperationsInput | string
    status?: EnumPreOrderStatusFieldUpdateOperationsInput | $Enums.PreOrderStatus
    designImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    colorName?: NullableStringFieldUpdateOperationsInput | string | null
    sizeSpec?: NullableStringFieldUpdateOperationsInput | string | null
    stoneColor?: NullableStringFieldUpdateOperationsInput | string | null
    minaColor?: NullableStringFieldUpdateOperationsInput | string | null
    estimatedWeightGrams?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    customer?: CustomerUpdateOneRequiredWithoutPreOrdersNestedInput
    city?: CityUpdateOneWithoutPreOrdersNestedInput
    convertedOrder?: OrderUpdateOneWithoutConvertedFromPreOrderNestedInput
    statusEvents?: PreOrderStatusEventUpdateManyWithoutPreOrderNestedInput
  }

  export type PreOrderUncheckedUpdateWithoutWorkshopInput = {
    id?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPreOrderStatusFieldUpdateOperationsInput | $Enums.PreOrderStatus
    designImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    colorName?: NullableStringFieldUpdateOperationsInput | string | null
    sizeSpec?: NullableStringFieldUpdateOperationsInput | string | null
    stoneColor?: NullableStringFieldUpdateOperationsInput | string | null
    minaColor?: NullableStringFieldUpdateOperationsInput | string | null
    estimatedWeightGrams?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    convertedOrderId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    statusEvents?: PreOrderStatusEventUncheckedUpdateManyWithoutPreOrderNestedInput
  }

  export type PreOrderUncheckedUpdateManyWithoutWorkshopInput = {
    id?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    status?: EnumPreOrderStatusFieldUpdateOperationsInput | $Enums.PreOrderStatus
    designImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    colorName?: NullableStringFieldUpdateOperationsInput | string | null
    sizeSpec?: NullableStringFieldUpdateOperationsInput | string | null
    stoneColor?: NullableStringFieldUpdateOperationsInput | string | null
    minaColor?: NullableStringFieldUpdateOperationsInput | string | null
    estimatedWeightGrams?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    estimatedPriceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    convertedOrderId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CategoryCreateManyParentInput = {
    id?: string
    title: string
    type?: number
    imageUrl?: string | null
    iconUrl?: string | null
    metaTag?: string | null
    description?: string | null
  }

  export type ProductCreateManyCategoryInput = {
    id?: string
    title: string
    description?: string | null
    brandId?: string | null
    productCode?: string | null
    showType?: number
    isActive?: boolean
    createdAt?: Date | string
  }

  export type PromotionCreateManyCategoryInput = {
    id?: string
    title: string
    description?: string | null
    scope?: $Enums.PromotionScope
    usage?: $Enums.PromotionUsage
    discountPercent: Decimal | DecimalJsLike | number | string
    isActive?: boolean
    platform?: number
    startsAt?: Date | string | null
    endsAt?: Date | string | null
    productId?: string | null
    customerId?: string | null
    brandId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type CategoryUpdateWithoutParentInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    type?: IntFieldUpdateOperationsInput | number
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    iconUrl?: NullableStringFieldUpdateOperationsInput | string | null
    metaTag?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    children?: CategoryUpdateManyWithoutParentNestedInput
    products?: ProductUpdateManyWithoutCategoryNestedInput
    promotions?: PromotionUpdateManyWithoutCategoryNestedInput
  }

  export type CategoryUncheckedUpdateWithoutParentInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    type?: IntFieldUpdateOperationsInput | number
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    iconUrl?: NullableStringFieldUpdateOperationsInput | string | null
    metaTag?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
    children?: CategoryUncheckedUpdateManyWithoutParentNestedInput
    products?: ProductUncheckedUpdateManyWithoutCategoryNestedInput
    promotions?: PromotionUncheckedUpdateManyWithoutCategoryNestedInput
  }

  export type CategoryUncheckedUpdateManyWithoutParentInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    type?: IntFieldUpdateOperationsInput | number
    imageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    iconUrl?: NullableStringFieldUpdateOperationsInput | string | null
    metaTag?: NullableStringFieldUpdateOperationsInput | string | null
    description?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ProductUpdateWithoutCategoryInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    productCode?: NullableStringFieldUpdateOperationsInput | string | null
    showType?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    brand?: BrandUpdateOneWithoutProductsNestedInput
    variants?: ProductVariantUpdateManyWithoutProductNestedInput
    images?: ProductImageUpdateManyWithoutProductNestedInput
    collections?: CollectionProductUpdateManyWithoutProductNestedInput
    comments?: CommentUpdateManyWithoutProductNestedInput
    promotions?: PromotionUpdateManyWithoutProductNestedInput
    allocationItems?: BranchAllocationItemUpdateManyWithoutProductNestedInput
  }

  export type ProductUncheckedUpdateWithoutCategoryInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    brandId?: NullableStringFieldUpdateOperationsInput | string | null
    productCode?: NullableStringFieldUpdateOperationsInput | string | null
    showType?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    variants?: ProductVariantUncheckedUpdateManyWithoutProductNestedInput
    images?: ProductImageUncheckedUpdateManyWithoutProductNestedInput
    collections?: CollectionProductUncheckedUpdateManyWithoutProductNestedInput
    comments?: CommentUncheckedUpdateManyWithoutProductNestedInput
    promotions?: PromotionUncheckedUpdateManyWithoutProductNestedInput
    allocationItems?: BranchAllocationItemUncheckedUpdateManyWithoutProductNestedInput
  }

  export type ProductUncheckedUpdateManyWithoutCategoryInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    brandId?: NullableStringFieldUpdateOperationsInput | string | null
    productCode?: NullableStringFieldUpdateOperationsInput | string | null
    showType?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PromotionUpdateWithoutCategoryInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: EnumPromotionScopeFieldUpdateOperationsInput | $Enums.PromotionScope
    usage?: EnumPromotionUsageFieldUpdateOperationsInput | $Enums.PromotionUsage
    discountPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    platform?: IntFieldUpdateOperationsInput | number
    startsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    product?: ProductUpdateOneWithoutPromotionsNestedInput
    customer?: CustomerUpdateOneWithoutPromotionsNestedInput
    brand?: BrandUpdateOneWithoutPromotionsNestedInput
  }

  export type PromotionUncheckedUpdateWithoutCategoryInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: EnumPromotionScopeFieldUpdateOperationsInput | $Enums.PromotionScope
    usage?: EnumPromotionUsageFieldUpdateOperationsInput | $Enums.PromotionUsage
    discountPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    platform?: IntFieldUpdateOperationsInput | number
    startsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    productId?: NullableStringFieldUpdateOperationsInput | string | null
    customerId?: NullableStringFieldUpdateOperationsInput | string | null
    brandId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PromotionUncheckedUpdateManyWithoutCategoryInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: EnumPromotionScopeFieldUpdateOperationsInput | $Enums.PromotionScope
    usage?: EnumPromotionUsageFieldUpdateOperationsInput | $Enums.PromotionUsage
    discountPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    platform?: IntFieldUpdateOperationsInput | number
    startsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    productId?: NullableStringFieldUpdateOperationsInput | string | null
    customerId?: NullableStringFieldUpdateOperationsInput | string | null
    brandId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type ProductCreateManyBrandInput = {
    id?: string
    title: string
    description?: string | null
    categoryId?: string | null
    productCode?: string | null
    showType?: number
    isActive?: boolean
    createdAt?: Date | string
  }

  export type PromotionCreateManyBrandInput = {
    id?: string
    title: string
    description?: string | null
    scope?: $Enums.PromotionScope
    usage?: $Enums.PromotionUsage
    discountPercent: Decimal | DecimalJsLike | number | string
    isActive?: boolean
    platform?: number
    startsAt?: Date | string | null
    endsAt?: Date | string | null
    productId?: string | null
    categoryId?: string | null
    customerId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type ProductUpdateWithoutBrandInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    productCode?: NullableStringFieldUpdateOperationsInput | string | null
    showType?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    category?: CategoryUpdateOneWithoutProductsNestedInput
    variants?: ProductVariantUpdateManyWithoutProductNestedInput
    images?: ProductImageUpdateManyWithoutProductNestedInput
    collections?: CollectionProductUpdateManyWithoutProductNestedInput
    comments?: CommentUpdateManyWithoutProductNestedInput
    promotions?: PromotionUpdateManyWithoutProductNestedInput
    allocationItems?: BranchAllocationItemUpdateManyWithoutProductNestedInput
  }

  export type ProductUncheckedUpdateWithoutBrandInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    categoryId?: NullableStringFieldUpdateOperationsInput | string | null
    productCode?: NullableStringFieldUpdateOperationsInput | string | null
    showType?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    variants?: ProductVariantUncheckedUpdateManyWithoutProductNestedInput
    images?: ProductImageUncheckedUpdateManyWithoutProductNestedInput
    collections?: CollectionProductUncheckedUpdateManyWithoutProductNestedInput
    comments?: CommentUncheckedUpdateManyWithoutProductNestedInput
    promotions?: PromotionUncheckedUpdateManyWithoutProductNestedInput
    allocationItems?: BranchAllocationItemUncheckedUpdateManyWithoutProductNestedInput
  }

  export type ProductUncheckedUpdateManyWithoutBrandInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    categoryId?: NullableStringFieldUpdateOperationsInput | string | null
    productCode?: NullableStringFieldUpdateOperationsInput | string | null
    showType?: IntFieldUpdateOperationsInput | number
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PromotionUpdateWithoutBrandInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: EnumPromotionScopeFieldUpdateOperationsInput | $Enums.PromotionScope
    usage?: EnumPromotionUsageFieldUpdateOperationsInput | $Enums.PromotionUsage
    discountPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    platform?: IntFieldUpdateOperationsInput | number
    startsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    product?: ProductUpdateOneWithoutPromotionsNestedInput
    category?: CategoryUpdateOneWithoutPromotionsNestedInput
    customer?: CustomerUpdateOneWithoutPromotionsNestedInput
  }

  export type PromotionUncheckedUpdateWithoutBrandInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: EnumPromotionScopeFieldUpdateOperationsInput | $Enums.PromotionScope
    usage?: EnumPromotionUsageFieldUpdateOperationsInput | $Enums.PromotionUsage
    discountPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    platform?: IntFieldUpdateOperationsInput | number
    startsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    productId?: NullableStringFieldUpdateOperationsInput | string | null
    categoryId?: NullableStringFieldUpdateOperationsInput | string | null
    customerId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PromotionUncheckedUpdateManyWithoutBrandInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: EnumPromotionScopeFieldUpdateOperationsInput | $Enums.PromotionScope
    usage?: EnumPromotionUsageFieldUpdateOperationsInput | $Enums.PromotionUsage
    discountPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    platform?: IntFieldUpdateOperationsInput | number
    startsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    productId?: NullableStringFieldUpdateOperationsInput | string | null
    categoryId?: NullableStringFieldUpdateOperationsInput | string | null
    customerId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type CollectionProductCreateManyCollectionInput = {
    productId: string
  }

  export type CollectionProductUpdateWithoutCollectionInput = {
    product?: ProductUpdateOneRequiredWithoutCollectionsNestedInput
  }

  export type CollectionProductUncheckedUpdateWithoutCollectionInput = {
    productId?: StringFieldUpdateOperationsInput | string
  }

  export type CollectionProductUncheckedUpdateManyWithoutCollectionInput = {
    productId?: StringFieldUpdateOperationsInput | string
  }

  export type ProductVariantCreateManyProductInput = {
    id?: string
    title: string
    sku?: string | null
    rashWeightGrams: Decimal | DecimalJsLike | number | string
    defaultWagePercent: Decimal | DecimalJsLike | number | string
    qty?: number
    isPreOrder?: boolean
    isActive?: boolean
    imageId?: string | null
  }

  export type ProductImageCreateManyProductInput = {
    id?: string
    url: string
    sortOrder?: number
    role?: $Enums.ProductImageRole
  }

  export type CollectionProductCreateManyProductInput = {
    collectionId: string
  }

  export type CommentCreateManyProductInput = {
    id?: string
    customerId: string
    body: string
    status?: $Enums.CommentStatus
    replyToId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type PromotionCreateManyProductInput = {
    id?: string
    title: string
    description?: string | null
    scope?: $Enums.PromotionScope
    usage?: $Enums.PromotionUsage
    discountPercent: Decimal | DecimalJsLike | number | string
    isActive?: boolean
    platform?: number
    startsAt?: Date | string | null
    endsAt?: Date | string | null
    categoryId?: string | null
    customerId?: string | null
    brandId?: string | null
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type BranchAllocationItemCreateManyProductInput = {
    id?: string
    allocationId: string
    weightGrams?: Decimal | DecimalJsLike | number | string | null
  }

  export type ProductVariantUpdateWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    sku?: NullableStringFieldUpdateOperationsInput | string | null
    rashWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    defaultWagePercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    qty?: IntFieldUpdateOperationsInput | number
    isPreOrder?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    image?: ProductImageUpdateOneWithoutVariantsNestedInput
    orderItems?: OrderItemUpdateManyWithoutProductVariantNestedInput
  }

  export type ProductVariantUncheckedUpdateWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    sku?: NullableStringFieldUpdateOperationsInput | string | null
    rashWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    defaultWagePercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    qty?: IntFieldUpdateOperationsInput | number
    isPreOrder?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    imageId?: NullableStringFieldUpdateOperationsInput | string | null
    orderItems?: OrderItemUncheckedUpdateManyWithoutProductVariantNestedInput
  }

  export type ProductVariantUncheckedUpdateManyWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    sku?: NullableStringFieldUpdateOperationsInput | string | null
    rashWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    defaultWagePercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    qty?: IntFieldUpdateOperationsInput | number
    isPreOrder?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    imageId?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type ProductImageUpdateWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    sortOrder?: IntFieldUpdateOperationsInput | number
    role?: EnumProductImageRoleFieldUpdateOperationsInput | $Enums.ProductImageRole
    variants?: ProductVariantUpdateManyWithoutImageNestedInput
  }

  export type ProductImageUncheckedUpdateWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    sortOrder?: IntFieldUpdateOperationsInput | number
    role?: EnumProductImageRoleFieldUpdateOperationsInput | $Enums.ProductImageRole
    variants?: ProductVariantUncheckedUpdateManyWithoutImageNestedInput
  }

  export type ProductImageUncheckedUpdateManyWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    url?: StringFieldUpdateOperationsInput | string
    sortOrder?: IntFieldUpdateOperationsInput | number
    role?: EnumProductImageRoleFieldUpdateOperationsInput | $Enums.ProductImageRole
  }

  export type CollectionProductUpdateWithoutProductInput = {
    collection?: CollectionUpdateOneRequiredWithoutProductsNestedInput
  }

  export type CollectionProductUncheckedUpdateWithoutProductInput = {
    collectionId?: StringFieldUpdateOperationsInput | string
  }

  export type CollectionProductUncheckedUpdateManyWithoutProductInput = {
    collectionId?: StringFieldUpdateOperationsInput | string
  }

  export type CommentUpdateWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    body?: StringFieldUpdateOperationsInput | string
    status?: EnumCommentStatusFieldUpdateOperationsInput | $Enums.CommentStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    customer?: CustomerUpdateOneRequiredWithoutCommentsNestedInput
    replyTo?: CommentUpdateOneWithoutRepliesNestedInput
    replies?: CommentUpdateManyWithoutReplyToNestedInput
  }

  export type CommentUncheckedUpdateWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    body?: StringFieldUpdateOperationsInput | string
    status?: EnumCommentStatusFieldUpdateOperationsInput | $Enums.CommentStatus
    replyToId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    replies?: CommentUncheckedUpdateManyWithoutReplyToNestedInput
  }

  export type CommentUncheckedUpdateManyWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    body?: StringFieldUpdateOperationsInput | string
    status?: EnumCommentStatusFieldUpdateOperationsInput | $Enums.CommentStatus
    replyToId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PromotionUpdateWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: EnumPromotionScopeFieldUpdateOperationsInput | $Enums.PromotionScope
    usage?: EnumPromotionUsageFieldUpdateOperationsInput | $Enums.PromotionUsage
    discountPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    platform?: IntFieldUpdateOperationsInput | number
    startsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    category?: CategoryUpdateOneWithoutPromotionsNestedInput
    customer?: CustomerUpdateOneWithoutPromotionsNestedInput
    brand?: BrandUpdateOneWithoutPromotionsNestedInput
  }

  export type PromotionUncheckedUpdateWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: EnumPromotionScopeFieldUpdateOperationsInput | $Enums.PromotionScope
    usage?: EnumPromotionUsageFieldUpdateOperationsInput | $Enums.PromotionUsage
    discountPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    platform?: IntFieldUpdateOperationsInput | number
    startsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    categoryId?: NullableStringFieldUpdateOperationsInput | string | null
    customerId?: NullableStringFieldUpdateOperationsInput | string | null
    brandId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PromotionUncheckedUpdateManyWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    description?: NullableStringFieldUpdateOperationsInput | string | null
    scope?: EnumPromotionScopeFieldUpdateOperationsInput | $Enums.PromotionScope
    usage?: EnumPromotionUsageFieldUpdateOperationsInput | $Enums.PromotionUsage
    discountPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    isActive?: BoolFieldUpdateOperationsInput | boolean
    platform?: IntFieldUpdateOperationsInput | number
    startsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    endsAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    categoryId?: NullableStringFieldUpdateOperationsInput | string | null
    customerId?: NullableStringFieldUpdateOperationsInput | string | null
    brandId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type BranchAllocationItemUpdateWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    weightGrams?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    allocation?: BranchAllocationUpdateOneRequiredWithoutItemsNestedInput
  }

  export type BranchAllocationItemUncheckedUpdateWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    allocationId?: StringFieldUpdateOperationsInput | string
    weightGrams?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
  }

  export type BranchAllocationItemUncheckedUpdateManyWithoutProductInput = {
    id?: StringFieldUpdateOperationsInput | string
    allocationId?: StringFieldUpdateOperationsInput | string
    weightGrams?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
  }

  export type ProductVariantCreateManyImageInput = {
    id?: string
    productId: string
    title: string
    sku?: string | null
    rashWeightGrams: Decimal | DecimalJsLike | number | string
    defaultWagePercent: Decimal | DecimalJsLike | number | string
    qty?: number
    isPreOrder?: boolean
    isActive?: boolean
  }

  export type ProductVariantUpdateWithoutImageInput = {
    id?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    sku?: NullableStringFieldUpdateOperationsInput | string | null
    rashWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    defaultWagePercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    qty?: IntFieldUpdateOperationsInput | number
    isPreOrder?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    product?: ProductUpdateOneRequiredWithoutVariantsNestedInput
    orderItems?: OrderItemUpdateManyWithoutProductVariantNestedInput
  }

  export type ProductVariantUncheckedUpdateWithoutImageInput = {
    id?: StringFieldUpdateOperationsInput | string
    productId?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    sku?: NullableStringFieldUpdateOperationsInput | string | null
    rashWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    defaultWagePercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    qty?: IntFieldUpdateOperationsInput | number
    isPreOrder?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    orderItems?: OrderItemUncheckedUpdateManyWithoutProductVariantNestedInput
  }

  export type ProductVariantUncheckedUpdateManyWithoutImageInput = {
    id?: StringFieldUpdateOperationsInput | string
    productId?: StringFieldUpdateOperationsInput | string
    title?: StringFieldUpdateOperationsInput | string
    sku?: NullableStringFieldUpdateOperationsInput | string | null
    rashWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    defaultWagePercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    qty?: IntFieldUpdateOperationsInput | number
    isPreOrder?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
  }

  export type OrderItemCreateManyProductVariantInput = {
    id?: string
    orderId: string
    quantity: number
    rashWeightGramsSnapshot: Decimal | DecimalJsLike | number | string
    wagePercentSnapshot: Decimal | DecimalJsLike | number | string
    discountPercentSnapshot?: Decimal | DecimalJsLike | number | string
    computedWeightGrams: Decimal | DecimalJsLike | number | string
    flatRialCharge?: Decimal | DecimalJsLike | number | string
  }

  export type OrderItemUpdateWithoutProductVariantInput = {
    id?: StringFieldUpdateOperationsInput | string
    quantity?: IntFieldUpdateOperationsInput | number
    rashWeightGramsSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    wagePercentSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    discountPercentSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    computedWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    order?: OrderUpdateOneRequiredWithoutItemsNestedInput
  }

  export type OrderItemUncheckedUpdateWithoutProductVariantInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderId?: StringFieldUpdateOperationsInput | string
    quantity?: IntFieldUpdateOperationsInput | number
    rashWeightGramsSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    wagePercentSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    discountPercentSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    computedWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
  }

  export type OrderItemUncheckedUpdateManyWithoutProductVariantInput = {
    id?: StringFieldUpdateOperationsInput | string
    orderId?: StringFieldUpdateOperationsInput | string
    quantity?: IntFieldUpdateOperationsInput | number
    rashWeightGramsSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    wagePercentSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    discountPercentSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    computedWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
  }

  export type OrderItemCreateManyOrderInput = {
    id?: string
    productVariantId: string
    quantity: number
    rashWeightGramsSnapshot: Decimal | DecimalJsLike | number | string
    wagePercentSnapshot: Decimal | DecimalJsLike | number | string
    discountPercentSnapshot?: Decimal | DecimalJsLike | number | string
    computedWeightGrams: Decimal | DecimalJsLike | number | string
    flatRialCharge?: Decimal | DecimalJsLike | number | string
  }

  export type OrderStatusEventCreateManyOrderInput = {
    id?: string
    fromStatus?: $Enums.OrderStatus | null
    toStatus: $Enums.OrderStatus
    note?: string | null
    actorAdminUserId?: string | null
    createdAt?: Date | string
  }

  export type LedgerEntryCreateManyOrderInput = {
    id?: string
    customerId: string
    currency: $Enums.LedgerCurrency
    direction: $Enums.LedgerDirection
    sourceType: $Enums.LedgerSourceType
    amount: Decimal | DecimalJsLike | number | string
    karatPerMille?: number | null
    pricePerGramRialAtEntry?: Decimal | DecimalJsLike | number | string | null
    confirmed?: boolean
    confirmedAt?: Date | string | null
    postedByAdminUserId?: string | null
    labName?: string | null
    hallmark?: string | null
    accountName?: string | null
    bankName?: string | null
    transferTo?: string | null
    originalValue?: Decimal | DecimalJsLike | number | string | null
    priceRial?: Decimal | DecimalJsLike | number | string | null
    receivedAt?: Date | string | null
    note?: string | null
    createdAt?: Date | string
  }

  export type OrderItemUpdateWithoutOrderInput = {
    id?: StringFieldUpdateOperationsInput | string
    quantity?: IntFieldUpdateOperationsInput | number
    rashWeightGramsSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    wagePercentSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    discountPercentSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    computedWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    productVariant?: ProductVariantUpdateOneRequiredWithoutOrderItemsNestedInput
  }

  export type OrderItemUncheckedUpdateWithoutOrderInput = {
    id?: StringFieldUpdateOperationsInput | string
    productVariantId?: StringFieldUpdateOperationsInput | string
    quantity?: IntFieldUpdateOperationsInput | number
    rashWeightGramsSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    wagePercentSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    discountPercentSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    computedWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
  }

  export type OrderItemUncheckedUpdateManyWithoutOrderInput = {
    id?: StringFieldUpdateOperationsInput | string
    productVariantId?: StringFieldUpdateOperationsInput | string
    quantity?: IntFieldUpdateOperationsInput | number
    rashWeightGramsSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    wagePercentSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    discountPercentSnapshot?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    computedWeightGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    flatRialCharge?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
  }

  export type OrderStatusEventUpdateWithoutOrderInput = {
    id?: StringFieldUpdateOperationsInput | string
    fromStatus?: NullableEnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus | null
    toStatus?: EnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    actorAdminUser?: AdminUserUpdateOneWithoutOrderStatusEventsNestedInput
  }

  export type OrderStatusEventUncheckedUpdateWithoutOrderInput = {
    id?: StringFieldUpdateOperationsInput | string
    fromStatus?: NullableEnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus | null
    toStatus?: EnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus
    note?: NullableStringFieldUpdateOperationsInput | string | null
    actorAdminUserId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type OrderStatusEventUncheckedUpdateManyWithoutOrderInput = {
    id?: StringFieldUpdateOperationsInput | string
    fromStatus?: NullableEnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus | null
    toStatus?: EnumOrderStatusFieldUpdateOperationsInput | $Enums.OrderStatus
    note?: NullableStringFieldUpdateOperationsInput | string | null
    actorAdminUserId?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LedgerEntryUpdateWithoutOrderInput = {
    id?: StringFieldUpdateOperationsInput | string
    currency?: EnumLedgerCurrencyFieldUpdateOperationsInput | $Enums.LedgerCurrency
    direction?: EnumLedgerDirectionFieldUpdateOperationsInput | $Enums.LedgerDirection
    sourceType?: EnumLedgerSourceTypeFieldUpdateOperationsInput | $Enums.LedgerSourceType
    amount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    karatPerMille?: NullableIntFieldUpdateOperationsInput | number | null
    pricePerGramRialAtEntry?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    confirmed?: BoolFieldUpdateOperationsInput | boolean
    confirmedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    labName?: NullableStringFieldUpdateOperationsInput | string | null
    hallmark?: NullableStringFieldUpdateOperationsInput | string | null
    accountName?: NullableStringFieldUpdateOperationsInput | string | null
    bankName?: NullableStringFieldUpdateOperationsInput | string | null
    transferTo?: NullableStringFieldUpdateOperationsInput | string | null
    originalValue?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    priceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    receivedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    customer?: CustomerUpdateOneRequiredWithoutLedgerEntriesNestedInput
    postedByAdminUser?: AdminUserUpdateOneWithoutPostedLedgerEntriesNestedInput
  }

  export type LedgerEntryUncheckedUpdateWithoutOrderInput = {
    id?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    currency?: EnumLedgerCurrencyFieldUpdateOperationsInput | $Enums.LedgerCurrency
    direction?: EnumLedgerDirectionFieldUpdateOperationsInput | $Enums.LedgerDirection
    sourceType?: EnumLedgerSourceTypeFieldUpdateOperationsInput | $Enums.LedgerSourceType
    amount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    karatPerMille?: NullableIntFieldUpdateOperationsInput | number | null
    pricePerGramRialAtEntry?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    confirmed?: BoolFieldUpdateOperationsInput | boolean
    confirmedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    postedByAdminUserId?: NullableStringFieldUpdateOperationsInput | string | null
    labName?: NullableStringFieldUpdateOperationsInput | string | null
    hallmark?: NullableStringFieldUpdateOperationsInput | string | null
    accountName?: NullableStringFieldUpdateOperationsInput | string | null
    bankName?: NullableStringFieldUpdateOperationsInput | string | null
    transferTo?: NullableStringFieldUpdateOperationsInput | string | null
    originalValue?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    priceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    receivedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type LedgerEntryUncheckedUpdateManyWithoutOrderInput = {
    id?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    currency?: EnumLedgerCurrencyFieldUpdateOperationsInput | $Enums.LedgerCurrency
    direction?: EnumLedgerDirectionFieldUpdateOperationsInput | $Enums.LedgerDirection
    sourceType?: EnumLedgerSourceTypeFieldUpdateOperationsInput | $Enums.LedgerSourceType
    amount?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    karatPerMille?: NullableIntFieldUpdateOperationsInput | number | null
    pricePerGramRialAtEntry?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    confirmed?: BoolFieldUpdateOperationsInput | boolean
    confirmedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    postedByAdminUserId?: NullableStringFieldUpdateOperationsInput | string | null
    labName?: NullableStringFieldUpdateOperationsInput | string | null
    hallmark?: NullableStringFieldUpdateOperationsInput | string | null
    accountName?: NullableStringFieldUpdateOperationsInput | string | null
    bankName?: NullableStringFieldUpdateOperationsInput | string | null
    transferTo?: NullableStringFieldUpdateOperationsInput | string | null
    originalValue?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    priceRial?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    receivedAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    note?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PreOrderStatusEventCreateManyPreOrderInput = {
    id?: string
    changes: JsonNullValueInput | InputJsonValue
    actorAdminUserId?: string | null
    ipAddress?: string | null
    createdAt?: Date | string
  }

  export type PreOrderStatusEventUpdateWithoutPreOrderInput = {
    id?: StringFieldUpdateOperationsInput | string
    changes?: JsonNullValueInput | InputJsonValue
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    actorAdminUser?: AdminUserUpdateOneWithoutPreOrderStatusEventsNestedInput
  }

  export type PreOrderStatusEventUncheckedUpdateWithoutPreOrderInput = {
    id?: StringFieldUpdateOperationsInput | string
    changes?: JsonNullValueInput | InputJsonValue
    actorAdminUserId?: NullableStringFieldUpdateOperationsInput | string | null
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PreOrderStatusEventUncheckedUpdateManyWithoutPreOrderInput = {
    id?: StringFieldUpdateOperationsInput | string
    changes?: JsonNullValueInput | InputJsonValue
    actorAdminUserId?: NullableStringFieldUpdateOperationsInput | string | null
    ipAddress?: NullableStringFieldUpdateOperationsInput | string | null
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type PermissionCreateManyUserTypeInput = {
    rid: string
  }

  export type AdminUserCreateManyUserTypeInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    branchId?: string | null
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    avatarFileId?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
  }

  export type PermissionUpdateWithoutUserTypeInput = {
    rid?: StringFieldUpdateOperationsInput | string
  }

  export type PermissionUncheckedUpdateWithoutUserTypeInput = {
    rid?: StringFieldUpdateOperationsInput | string
  }

  export type PermissionUncheckedUpdateManyWithoutUserTypeInput = {
    rid?: StringFieldUpdateOperationsInput | string
  }

  export type AdminUserUpdateWithoutUserTypeInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    branch?: BranchUpdateOneWithoutAdminUsersNestedInput
    avatarFile?: UploadedFileUpdateOneWithoutAdminUserAvatarsNestedInput
    referredCustomers?: CustomerUpdateManyWithoutReferredByAgentNestedInput
    supervisedWorkshops?: WorkshopUpdateManyWithoutSupervisorNestedInput
    branchAllocations?: BranchAllocationUpdateManyWithoutAllocatorAdminUserNestedInput
    postedLedgerEntries?: LedgerEntryUpdateManyWithoutPostedByAdminUserNestedInput
    orderStatusEvents?: OrderStatusEventUpdateManyWithoutActorAdminUserNestedInput
    preOrderStatusEvents?: PreOrderStatusEventUpdateManyWithoutActorAdminUserNestedInput
    sentSmsMessages?: SmsMessageUpdateManyWithoutSentByAdminUserNestedInput
    sentNotifications?: NotificationUpdateManyWithoutSentByAdminUserNestedInput
    uploadedFiles?: UploadedFileUpdateManyWithoutUploadedByAdminUserNestedInput
    salesExpertProfile?: SalesExpertProfileUpdateOneWithoutAdminUserNestedInput
    sessions?: AdminSessionUpdateManyWithoutAdminUserNestedInput
  }

  export type AdminUserUncheckedUpdateWithoutUserTypeInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    branchId?: NullableStringFieldUpdateOperationsInput | string | null
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredCustomers?: CustomerUncheckedUpdateManyWithoutReferredByAgentNestedInput
    supervisedWorkshops?: WorkshopUncheckedUpdateManyWithoutSupervisorNestedInput
    branchAllocations?: BranchAllocationUncheckedUpdateManyWithoutAllocatorAdminUserNestedInput
    postedLedgerEntries?: LedgerEntryUncheckedUpdateManyWithoutPostedByAdminUserNestedInput
    orderStatusEvents?: OrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput
    preOrderStatusEvents?: PreOrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput
    sentSmsMessages?: SmsMessageUncheckedUpdateManyWithoutSentByAdminUserNestedInput
    sentNotifications?: NotificationUncheckedUpdateManyWithoutSentByAdminUserNestedInput
    uploadedFiles?: UploadedFileUncheckedUpdateManyWithoutUploadedByAdminUserNestedInput
    salesExpertProfile?: SalesExpertProfileUncheckedUpdateOneWithoutAdminUserNestedInput
    sessions?: AdminSessionUncheckedUpdateManyWithoutAdminUserNestedInput
  }

  export type AdminUserUncheckedUpdateManyWithoutUserTypeInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    branchId?: NullableStringFieldUpdateOperationsInput | string | null
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    avatarFileId?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
  }

  export type CommentCreateManyReplyToInput = {
    id?: string
    productId: string
    customerId: string
    body: string
    status?: $Enums.CommentStatus
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type CommentUpdateWithoutReplyToInput = {
    id?: StringFieldUpdateOperationsInput | string
    body?: StringFieldUpdateOperationsInput | string
    status?: EnumCommentStatusFieldUpdateOperationsInput | $Enums.CommentStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    product?: ProductUpdateOneRequiredWithoutCommentsNestedInput
    customer?: CustomerUpdateOneRequiredWithoutCommentsNestedInput
    replies?: CommentUpdateManyWithoutReplyToNestedInput
  }

  export type CommentUncheckedUpdateWithoutReplyToInput = {
    id?: StringFieldUpdateOperationsInput | string
    productId?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    body?: StringFieldUpdateOperationsInput | string
    status?: EnumCommentStatusFieldUpdateOperationsInput | $Enums.CommentStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    replies?: CommentUncheckedUpdateManyWithoutReplyToNestedInput
  }

  export type CommentUncheckedUpdateManyWithoutReplyToInput = {
    id?: StringFieldUpdateOperationsInput | string
    productId?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    body?: StringFieldUpdateOperationsInput | string
    status?: EnumCommentStatusFieldUpdateOperationsInput | $Enums.CommentStatus
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type BranchAllocationItemCreateManyAllocationInput = {
    id?: string
    productId: string
    weightGrams?: Decimal | DecimalJsLike | number | string | null
  }

  export type BranchAllocationItemUpdateWithoutAllocationInput = {
    id?: StringFieldUpdateOperationsInput | string
    weightGrams?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    product?: ProductUpdateOneRequiredWithoutAllocationItemsNestedInput
  }

  export type BranchAllocationItemUncheckedUpdateWithoutAllocationInput = {
    id?: StringFieldUpdateOperationsInput | string
    productId?: StringFieldUpdateOperationsInput | string
    weightGrams?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
  }

  export type BranchAllocationItemUncheckedUpdateManyWithoutAllocationInput = {
    id?: StringFieldUpdateOperationsInput | string
    productId?: StringFieldUpdateOperationsInput | string
    weightGrams?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
  }

  export type NotificationRecipientCreateManyNotificationInput = {
    id?: string
    customerId: string
    readAt?: Date | string | null
  }

  export type NotificationRecipientUpdateWithoutNotificationInput = {
    id?: StringFieldUpdateOperationsInput | string
    readAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
    customer?: CustomerUpdateOneRequiredWithoutNotificationsNestedInput
  }

  export type NotificationRecipientUncheckedUpdateWithoutNotificationInput = {
    id?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    readAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type NotificationRecipientUncheckedUpdateManyWithoutNotificationInput = {
    id?: StringFieldUpdateOperationsInput | string
    customerId?: StringFieldUpdateOperationsInput | string
    readAt?: NullableDateTimeFieldUpdateOperationsInput | Date | string | null
  }

  export type CustomerCreateManyAvatarFileInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    nationalCode: string
    passwordHash: string
    cityId?: string | null
    kind?: $Enums.CustomerKind
    phone?: string | null
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    zone?: string | null
    memberCode?: string | null
    referredByAgentId?: string | null
    goldCreditLimitGrams?: Decimal | DecimalJsLike | number | string
    goldDebtGrams?: Decimal | DecimalJsLike | number | string
    fiatDebtRial?: Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: Decimal | DecimalJsLike | number | string
    verificationStep?: $Enums.VerificationStep
    nationalIdImageUrl?: string | null
    businessLicenseUrl?: string | null
    shopImageUrl?: string | null
    canPlaceOrders?: boolean
    isActive?: boolean
    isArchived?: boolean
    createdAt?: Date | string
    updatedAt?: Date | string
  }

  export type AdminUserCreateManyAvatarFileInput = {
    id?: string
    fullName: string
    firstName?: string | null
    lastName?: string | null
    mobile: string
    passwordHash: string
    role: $Enums.AdminRole
    userTypeId?: number | null
    branchId?: string | null
    wagePercent?: Decimal | DecimalJsLike | number | string | null
    isActive?: boolean
    createdAt?: Date | string
    address?: string | null
    storeName?: string | null
    pasazhName?: string | null
    memberCode?: string | null
  }

  export type CustomerUpdateWithoutAvatarFileInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    city?: CityUpdateOneWithoutCustomersNestedInput
    referredByAgent?: AdminUserUpdateOneWithoutReferredCustomersNestedInput
    salesExpertTradingFor?: SalesExpertProfileUpdateOneWithoutTradingCustomerNestedInput
    addresses?: CustomerAddressUpdateManyWithoutCustomerNestedInput
    orders?: OrderUpdateManyWithoutCustomerNestedInput
    preOrders?: PreOrderUpdateManyWithoutCustomerNestedInput
    ledgerEntries?: LedgerEntryUpdateManyWithoutCustomerNestedInput
    walletBonuses?: WalletBonusUpdateManyWithoutCustomerNestedInput
    comments?: CommentUpdateManyWithoutCustomerNestedInput
    promotions?: PromotionUpdateManyWithoutCustomerNestedInput
    notifications?: NotificationRecipientUpdateManyWithoutCustomerNestedInput
    activityLogs?: CustomerActivityLogUpdateManyWithoutCustomerNestedInput
    otpChallenges?: CustomerOtpUpdateManyWithoutCustomerNestedInput
  }

  export type CustomerUncheckedUpdateWithoutAvatarFileInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredByAgentId?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
    salesExpertTradingFor?: SalesExpertProfileUncheckedUpdateOneWithoutTradingCustomerNestedInput
    addresses?: CustomerAddressUncheckedUpdateManyWithoutCustomerNestedInput
    orders?: OrderUncheckedUpdateManyWithoutCustomerNestedInput
    preOrders?: PreOrderUncheckedUpdateManyWithoutCustomerNestedInput
    ledgerEntries?: LedgerEntryUncheckedUpdateManyWithoutCustomerNestedInput
    walletBonuses?: WalletBonusUncheckedUpdateManyWithoutCustomerNestedInput
    comments?: CommentUncheckedUpdateManyWithoutCustomerNestedInput
    promotions?: PromotionUncheckedUpdateManyWithoutCustomerNestedInput
    notifications?: NotificationRecipientUncheckedUpdateManyWithoutCustomerNestedInput
    activityLogs?: CustomerActivityLogUncheckedUpdateManyWithoutCustomerNestedInput
    otpChallenges?: CustomerOtpUncheckedUpdateManyWithoutCustomerNestedInput
  }

  export type CustomerUncheckedUpdateManyWithoutAvatarFileInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    nationalCode?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    cityId?: NullableStringFieldUpdateOperationsInput | string | null
    kind?: EnumCustomerKindFieldUpdateOperationsInput | $Enums.CustomerKind
    phone?: NullableStringFieldUpdateOperationsInput | string | null
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    zone?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredByAgentId?: NullableStringFieldUpdateOperationsInput | string | null
    goldCreditLimitGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    goldDebtGrams?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    fiatDebtRial?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    makingChargeOffsetPercent?: DecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string
    verificationStep?: EnumVerificationStepFieldUpdateOperationsInput | $Enums.VerificationStep
    nationalIdImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    businessLicenseUrl?: NullableStringFieldUpdateOperationsInput | string | null
    shopImageUrl?: NullableStringFieldUpdateOperationsInput | string | null
    canPlaceOrders?: BoolFieldUpdateOperationsInput | boolean
    isActive?: BoolFieldUpdateOperationsInput | boolean
    isArchived?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
  }

  export type AdminUserUpdateWithoutAvatarFileInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    userType?: UserTypeUpdateOneWithoutAdminUsersNestedInput
    branch?: BranchUpdateOneWithoutAdminUsersNestedInput
    referredCustomers?: CustomerUpdateManyWithoutReferredByAgentNestedInput
    supervisedWorkshops?: WorkshopUpdateManyWithoutSupervisorNestedInput
    branchAllocations?: BranchAllocationUpdateManyWithoutAllocatorAdminUserNestedInput
    postedLedgerEntries?: LedgerEntryUpdateManyWithoutPostedByAdminUserNestedInput
    orderStatusEvents?: OrderStatusEventUpdateManyWithoutActorAdminUserNestedInput
    preOrderStatusEvents?: PreOrderStatusEventUpdateManyWithoutActorAdminUserNestedInput
    sentSmsMessages?: SmsMessageUpdateManyWithoutSentByAdminUserNestedInput
    sentNotifications?: NotificationUpdateManyWithoutSentByAdminUserNestedInput
    uploadedFiles?: UploadedFileUpdateManyWithoutUploadedByAdminUserNestedInput
    salesExpertProfile?: SalesExpertProfileUpdateOneWithoutAdminUserNestedInput
    sessions?: AdminSessionUpdateManyWithoutAdminUserNestedInput
  }

  export type AdminUserUncheckedUpdateWithoutAvatarFileInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    userTypeId?: NullableIntFieldUpdateOperationsInput | number | null
    branchId?: NullableStringFieldUpdateOperationsInput | string | null
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
    referredCustomers?: CustomerUncheckedUpdateManyWithoutReferredByAgentNestedInput
    supervisedWorkshops?: WorkshopUncheckedUpdateManyWithoutSupervisorNestedInput
    branchAllocations?: BranchAllocationUncheckedUpdateManyWithoutAllocatorAdminUserNestedInput
    postedLedgerEntries?: LedgerEntryUncheckedUpdateManyWithoutPostedByAdminUserNestedInput
    orderStatusEvents?: OrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput
    preOrderStatusEvents?: PreOrderStatusEventUncheckedUpdateManyWithoutActorAdminUserNestedInput
    sentSmsMessages?: SmsMessageUncheckedUpdateManyWithoutSentByAdminUserNestedInput
    sentNotifications?: NotificationUncheckedUpdateManyWithoutSentByAdminUserNestedInput
    uploadedFiles?: UploadedFileUncheckedUpdateManyWithoutUploadedByAdminUserNestedInput
    salesExpertProfile?: SalesExpertProfileUncheckedUpdateOneWithoutAdminUserNestedInput
    sessions?: AdminSessionUncheckedUpdateManyWithoutAdminUserNestedInput
  }

  export type AdminUserUncheckedUpdateManyWithoutAvatarFileInput = {
    id?: StringFieldUpdateOperationsInput | string
    fullName?: StringFieldUpdateOperationsInput | string
    firstName?: NullableStringFieldUpdateOperationsInput | string | null
    lastName?: NullableStringFieldUpdateOperationsInput | string | null
    mobile?: StringFieldUpdateOperationsInput | string
    passwordHash?: StringFieldUpdateOperationsInput | string
    role?: EnumAdminRoleFieldUpdateOperationsInput | $Enums.AdminRole
    userTypeId?: NullableIntFieldUpdateOperationsInput | number | null
    branchId?: NullableStringFieldUpdateOperationsInput | string | null
    wagePercent?: NullableDecimalFieldUpdateOperationsInput | Decimal | DecimalJsLike | number | string | null
    isActive?: BoolFieldUpdateOperationsInput | boolean
    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
    address?: NullableStringFieldUpdateOperationsInput | string | null
    storeName?: NullableStringFieldUpdateOperationsInput | string | null
    pasazhName?: NullableStringFieldUpdateOperationsInput | string | null
    memberCode?: NullableStringFieldUpdateOperationsInput | string | null
  }



  /**
   * Aliases for legacy arg types
   */
    /**
     * @deprecated Use CityCountOutputTypeDefaultArgs instead
     */
    export type CityCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CityCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use AdminUserCountOutputTypeDefaultArgs instead
     */
    export type AdminUserCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = AdminUserCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CustomerCountOutputTypeDefaultArgs instead
     */
    export type CustomerCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CustomerCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use BranchCountOutputTypeDefaultArgs instead
     */
    export type BranchCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = BranchCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use WorkshopCountOutputTypeDefaultArgs instead
     */
    export type WorkshopCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = WorkshopCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CategoryCountOutputTypeDefaultArgs instead
     */
    export type CategoryCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CategoryCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use BrandCountOutputTypeDefaultArgs instead
     */
    export type BrandCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = BrandCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CollectionCountOutputTypeDefaultArgs instead
     */
    export type CollectionCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CollectionCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ProductCountOutputTypeDefaultArgs instead
     */
    export type ProductCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ProductCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ProductImageCountOutputTypeDefaultArgs instead
     */
    export type ProductImageCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ProductImageCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ProductVariantCountOutputTypeDefaultArgs instead
     */
    export type ProductVariantCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ProductVariantCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use OrderCountOutputTypeDefaultArgs instead
     */
    export type OrderCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = OrderCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use PreOrderCountOutputTypeDefaultArgs instead
     */
    export type PreOrderCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = PreOrderCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use UserTypeCountOutputTypeDefaultArgs instead
     */
    export type UserTypeCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UserTypeCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CommentCountOutputTypeDefaultArgs instead
     */
    export type CommentCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CommentCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use BranchAllocationCountOutputTypeDefaultArgs instead
     */
    export type BranchAllocationCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = BranchAllocationCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use NotificationCountOutputTypeDefaultArgs instead
     */
    export type NotificationCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = NotificationCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use UploadedFileCountOutputTypeDefaultArgs instead
     */
    export type UploadedFileCountOutputTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UploadedFileCountOutputTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CityDefaultArgs instead
     */
    export type CityArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CityDefaultArgs<ExtArgs>
    /**
     * @deprecated Use AdminUserDefaultArgs instead
     */
    export type AdminUserArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = AdminUserDefaultArgs<ExtArgs>
    /**
     * @deprecated Use AppSessionDefaultArgs instead
     */
    export type AppSessionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = AppSessionDefaultArgs<ExtArgs>
    /**
     * @deprecated Use AdminSessionDefaultArgs instead
     */
    export type AdminSessionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = AdminSessionDefaultArgs<ExtArgs>
    /**
     * @deprecated Use SalesExpertProfileDefaultArgs instead
     */
    export type SalesExpertProfileArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = SalesExpertProfileDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CustomerDefaultArgs instead
     */
    export type CustomerArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CustomerDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CustomerAddressDefaultArgs instead
     */
    export type CustomerAddressArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CustomerAddressDefaultArgs<ExtArgs>
    /**
     * @deprecated Use BranchDefaultArgs instead
     */
    export type BranchArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = BranchDefaultArgs<ExtArgs>
    /**
     * @deprecated Use WorkshopDefaultArgs instead
     */
    export type WorkshopArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = WorkshopDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CategoryDefaultArgs instead
     */
    export type CategoryArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CategoryDefaultArgs<ExtArgs>
    /**
     * @deprecated Use BrandDefaultArgs instead
     */
    export type BrandArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = BrandDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CollectionDefaultArgs instead
     */
    export type CollectionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CollectionDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CollectionProductDefaultArgs instead
     */
    export type CollectionProductArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CollectionProductDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ProductDefaultArgs instead
     */
    export type ProductArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ProductDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ProductImageDefaultArgs instead
     */
    export type ProductImageArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ProductImageDefaultArgs<ExtArgs>
    /**
     * @deprecated Use ProductVariantDefaultArgs instead
     */
    export type ProductVariantArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = ProductVariantDefaultArgs<ExtArgs>
    /**
     * @deprecated Use OrderDefaultArgs instead
     */
    export type OrderArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = OrderDefaultArgs<ExtArgs>
    /**
     * @deprecated Use OrderItemDefaultArgs instead
     */
    export type OrderItemArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = OrderItemDefaultArgs<ExtArgs>
    /**
     * @deprecated Use OrderStatusEventDefaultArgs instead
     */
    export type OrderStatusEventArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = OrderStatusEventDefaultArgs<ExtArgs>
    /**
     * @deprecated Use PreOrderDefaultArgs instead
     */
    export type PreOrderArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = PreOrderDefaultArgs<ExtArgs>
    /**
     * @deprecated Use PreOrderStatusEventDefaultArgs instead
     */
    export type PreOrderStatusEventArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = PreOrderStatusEventDefaultArgs<ExtArgs>
    /**
     * @deprecated Use LedgerEntryDefaultArgs instead
     */
    export type LedgerEntryArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = LedgerEntryDefaultArgs<ExtArgs>
    /**
     * @deprecated Use GoldPriceQuoteDefaultArgs instead
     */
    export type GoldPriceQuoteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = GoldPriceQuoteDefaultArgs<ExtArgs>
    /**
     * @deprecated Use WalletBonusDefaultArgs instead
     */
    export type WalletBonusArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = WalletBonusDefaultArgs<ExtArgs>
    /**
     * @deprecated Use UserTypeDefaultArgs instead
     */
    export type UserTypeArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UserTypeDefaultArgs<ExtArgs>
    /**
     * @deprecated Use PermissionDefaultArgs instead
     */
    export type PermissionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = PermissionDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CommentDefaultArgs instead
     */
    export type CommentArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CommentDefaultArgs<ExtArgs>
    /**
     * @deprecated Use SettingDefaultArgs instead
     */
    export type SettingArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = SettingDefaultArgs<ExtArgs>
    /**
     * @deprecated Use PromotionDefaultArgs instead
     */
    export type PromotionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = PromotionDefaultArgs<ExtArgs>
    /**
     * @deprecated Use PromotionExclusionDefaultArgs instead
     */
    export type PromotionExclusionArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = PromotionExclusionDefaultArgs<ExtArgs>
    /**
     * @deprecated Use BranchAllocationDefaultArgs instead
     */
    export type BranchAllocationArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = BranchAllocationDefaultArgs<ExtArgs>
    /**
     * @deprecated Use BranchAllocationItemDefaultArgs instead
     */
    export type BranchAllocationItemArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = BranchAllocationItemDefaultArgs<ExtArgs>
    /**
     * @deprecated Use SmsMessageDefaultArgs instead
     */
    export type SmsMessageArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = SmsMessageDefaultArgs<ExtArgs>
    /**
     * @deprecated Use NotificationDefaultArgs instead
     */
    export type NotificationArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = NotificationDefaultArgs<ExtArgs>
    /**
     * @deprecated Use NotificationRecipientDefaultArgs instead
     */
    export type NotificationRecipientArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = NotificationRecipientDefaultArgs<ExtArgs>
    /**
     * @deprecated Use NewsletterSubscriberDefaultArgs instead
     */
    export type NewsletterSubscriberArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = NewsletterSubscriberDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CustomerActivityLogDefaultArgs instead
     */
    export type CustomerActivityLogArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CustomerActivityLogDefaultArgs<ExtArgs>
    /**
     * @deprecated Use UploadedFileDefaultArgs instead
     */
    export type UploadedFileArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = UploadedFileDefaultArgs<ExtArgs>
    /**
     * @deprecated Use CustomerOtpDefaultArgs instead
     */
    export type CustomerOtpArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = CustomerOtpDefaultArgs<ExtArgs>

  /**
   * Batch Payload for updateMany & deleteMany & createMany
   */

  export type BatchPayload = {
    count: number
  }

  /**
   * DMMF
   */
  export const dmmf: runtime.BaseDMMF
}