@commercejs/platform 0.1.0

package/dist/database/prisma/generated/internal/prismaNamespace.d.ts

@@ -0,0 +1,2735 @@
+import * as runtime from "@prisma/client/runtime/client";
+import type * as Prisma from "../models.js";
+import { type PrismaClient } from "./class.js";
+export type * from '../models.js';
+export type DMMF = typeof runtime.DMMF;
+export type PrismaPromise<T> = runtime.Types.Public.PrismaPromise<T>;
+/**
+ * Prisma Errors
+ */
+export declare const PrismaClientKnownRequestError: typeof runtime.PrismaClientKnownRequestError;
+export type PrismaClientKnownRequestError = runtime.PrismaClientKnownRequestError;
+export declare const PrismaClientUnknownRequestError: typeof runtime.PrismaClientUnknownRequestError;
+export type PrismaClientUnknownRequestError = runtime.PrismaClientUnknownRequestError;
+export declare const PrismaClientRustPanicError: typeof runtime.PrismaClientRustPanicError;
+export type PrismaClientRustPanicError = runtime.PrismaClientRustPanicError;
+export declare const PrismaClientInitializationError: typeof runtime.PrismaClientInitializationError;
+export type PrismaClientInitializationError = runtime.PrismaClientInitializationError;
+export declare const PrismaClientValidationError: typeof runtime.PrismaClientValidationError;
+export type PrismaClientValidationError = runtime.PrismaClientValidationError;
+/**
+ * Re-export of sql-template-tag
+ */
+export declare const sql: typeof runtime.sqltag;
+export declare const empty: runtime.Sql;
+export declare const join: typeof runtime.join;
+export declare const raw: typeof runtime.raw;
+export declare const Sql: typeof runtime.Sql;
+export type Sql = runtime.Sql;
+/**
+ * Decimal.js
+ */
+export declare const Decimal: typeof runtime.Decimal;
+export type Decimal = runtime.Decimal;
+export type DecimalJsLike = runtime.DecimalJsLike;
+/**
+* Extensions
+*/
+export type Extension = runtime.Types.Extensions.UserArgs;
+export declare const getExtensionContext: typeof runtime.Extensions.getExtensionContext;
+export type Args<T, F extends runtime.Operation> = runtime.Types.Public.Args<T, F>;
+export type Payload<T, F extends runtime.Operation = never> = runtime.Types.Public.Payload<T, F>;
+export type Result<T, A, F extends runtime.Operation> = runtime.Types.Public.Result<T, A, F>;
+export type Exact<A, W> = runtime.Types.Public.Exact<A, W>;
+export type PrismaVersion = {
+    client: string;
+    engine: string;
+};
+/**
+ * Prisma Client JS version: 7.3.0
+ * Query Engine version: 9d6ad21cbbceab97458517b147a6a09ff43aa735
+ */
+export declare const prismaVersion: PrismaVersion;
+/**
+ * Utility Types
+ */
+export type Bytes = runtime.Bytes;
+export type JsonObject = runtime.JsonObject;
+export type JsonArray = runtime.JsonArray;
+export type JsonValue = runtime.JsonValue;
+export type InputJsonObject = runtime.InputJsonObject;
+export type InputJsonArray = runtime.InputJsonArray;
+export type InputJsonValue = runtime.InputJsonValue;
+export declare const NullTypes: {
+    DbNull: (new (secret: never) => typeof runtime.DbNull);
+    JsonNull: (new (secret: never) => typeof runtime.JsonNull);
+    AnyNull: (new (secret: never) => typeof runtime.AnyNull);
+};
+/**
+ * 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 declare const DbNull: runtime.DbNullClass;
+/**
+ * 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 declare const JsonNull: runtime.JsonNullClass;
+/**
+ * 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 declare const AnyNull: runtime.AnyNullClass;
+type SelectAndInclude = {
+    select: any;
+    include: any;
+};
+type SelectAndOmit = {
+    select: any;
+    omit: any;
+};
+/**
+ * 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>;
+/**
+ * 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
+ */
+export 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> & {
+    [P in K]: Prisma__Pick<O, P & keyof O>;
+}[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];
+export type Either<O extends object, K extends Key, strict extends Boolean = 1> = O extends unknown ? _Either<O, K, strict> : never;
+export type Union = any;
+export 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 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;
+};
+type NoExpand<T> = T extends unknown ? T : never;
+export 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 ? P : 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>>>;
+export type Boolean = True | False;
+export type True = 1;
+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 : 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;
+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;
+export type GetHavingFields<T> = {
+    [K in keyof T]: Or<Or<Extends<'OR', K>, Extends<'AND', K>>, Extends<'NOT', K>> extends True ? 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>;
+export type MaybeTupleToUnion<T> = T extends any[] ? TupleToUnion<T> : T;
+/**
+ * Like `Pick`, but additionally can also accept an array of keys
+ */
+export type PickEnumerable<T, K extends Enumerable<keyof T> | keyof T> = Prisma__Pick<T, MaybeTupleToUnion<K>>;
+/**
+ * Exclude all keys with underscores
+ */
+export 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 declare const ModelName: {
+    readonly Brand: "Brand";
+    readonly Cart: "Cart";
+    readonly CartItem: "CartItem";
+    readonly Category: "Category";
+    readonly Country: "Country";
+    readonly Customer: "Customer";
+    readonly CustomerAddress: "CustomerAddress";
+    readonly Order: "Order";
+    readonly OrderItem: "OrderItem";
+    readonly OrderHistory: "OrderHistory";
+    readonly Product: "Product";
+    readonly ProductImage: "ProductImage";
+    readonly ProductVariant: "ProductVariant";
+    readonly ProductOption: "ProductOption";
+    readonly ProductOptionValue: "ProductOptionValue";
+    readonly ProductAttribute: "ProductAttribute";
+    readonly ProductCategory: "ProductCategory";
+    readonly ProductTag: "ProductTag";
+    readonly Promotion: "Promotion";
+    readonly Coupon: "Coupon";
+    readonly Return: "Return";
+    readonly ReturnItem: "ReturnItem";
+    readonly Review: "Review";
+    readonly StoreInfo: "StoreInfo";
+    readonly Wishlist: "Wishlist";
+    readonly WishlistItem: "WishlistItem";
+};
+export type ModelName = (typeof ModelName)[keyof typeof ModelName];
+export interface TypeMapCb<GlobalOmitOptions = {}> extends runtime.Types.Utils.Fn<{
+    extArgs: runtime.Types.Extensions.InternalArgs;
+}, runtime.Types.Utils.Record<string, any>> {
+    returns: TypeMap<this['params']['extArgs'], GlobalOmitOptions>;
+}
+export type TypeMap<ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs, GlobalOmitOptions = {}> = {
+    globalOmitOptions: {
+        omit: GlobalOmitOptions;
+    };
+    meta: {
+        modelProps: "brand" | "cart" | "cartItem" | "category" | "country" | "customer" | "customerAddress" | "order" | "orderItem" | "orderHistory" | "product" | "productImage" | "productVariant" | "productOption" | "productOptionValue" | "productAttribute" | "productCategory" | "productTag" | "promotion" | "coupon" | "return" | "returnItem" | "review" | "storeInfo" | "wishlist" | "wishlistItem";
+        txIsolationLevel: TransactionIsolationLevel;
+    };
+    model: {
+        Brand: {
+            payload: Prisma.$BrandPayload<ExtArgs>;
+            fields: Prisma.BrandFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.BrandFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BrandPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.BrandFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BrandPayload>;
+                };
+                findFirst: {
+                    args: Prisma.BrandFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BrandPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.BrandFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BrandPayload>;
+                };
+                findMany: {
+                    args: Prisma.BrandFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BrandPayload>[];
+                };
+                create: {
+                    args: Prisma.BrandCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BrandPayload>;
+                };
+                createMany: {
+                    args: Prisma.BrandCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.BrandCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BrandPayload>[];
+                };
+                delete: {
+                    args: Prisma.BrandDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BrandPayload>;
+                };
+                update: {
+                    args: Prisma.BrandUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BrandPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.BrandDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.BrandUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.BrandUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BrandPayload>[];
+                };
+                upsert: {
+                    args: Prisma.BrandUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$BrandPayload>;
+                };
+                aggregate: {
+                    args: Prisma.BrandAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateBrand>;
+                };
+                groupBy: {
+                    args: Prisma.BrandGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.BrandGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.BrandCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.BrandCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Cart: {
+            payload: Prisma.$CartPayload<ExtArgs>;
+            fields: Prisma.CartFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.CartFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CartPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.CartFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CartPayload>;
+                };
+                findFirst: {
+                    args: Prisma.CartFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CartPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.CartFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CartPayload>;
+                };
+                findMany: {
+                    args: Prisma.CartFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CartPayload>[];
+                };
+                create: {
+                    args: Prisma.CartCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CartPayload>;
+                };
+                createMany: {
+                    args: Prisma.CartCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.CartCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CartPayload>[];
+                };
+                delete: {
+                    args: Prisma.CartDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CartPayload>;
+                };
+                update: {
+                    args: Prisma.CartUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CartPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.CartDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.CartUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.CartUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CartPayload>[];
+                };
+                upsert: {
+                    args: Prisma.CartUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CartPayload>;
+                };
+                aggregate: {
+                    args: Prisma.CartAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateCart>;
+                };
+                groupBy: {
+                    args: Prisma.CartGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.CartGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.CartCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.CartCountAggregateOutputType> | number;
+                };
+            };
+        };
+        CartItem: {
+            payload: Prisma.$CartItemPayload<ExtArgs>;
+            fields: Prisma.CartItemFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.CartItemFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CartItemPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.CartItemFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CartItemPayload>;
+                };
+                findFirst: {
+                    args: Prisma.CartItemFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CartItemPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.CartItemFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CartItemPayload>;
+                };
+                findMany: {
+                    args: Prisma.CartItemFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CartItemPayload>[];
+                };
+                create: {
+                    args: Prisma.CartItemCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CartItemPayload>;
+                };
+                createMany: {
+                    args: Prisma.CartItemCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.CartItemCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CartItemPayload>[];
+                };
+                delete: {
+                    args: Prisma.CartItemDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CartItemPayload>;
+                };
+                update: {
+                    args: Prisma.CartItemUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CartItemPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.CartItemDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.CartItemUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.CartItemUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CartItemPayload>[];
+                };
+                upsert: {
+                    args: Prisma.CartItemUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CartItemPayload>;
+                };
+                aggregate: {
+                    args: Prisma.CartItemAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateCartItem>;
+                };
+                groupBy: {
+                    args: Prisma.CartItemGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.CartItemGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.CartItemCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.CartItemCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Category: {
+            payload: Prisma.$CategoryPayload<ExtArgs>;
+            fields: Prisma.CategoryFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.CategoryFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CategoryPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.CategoryFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CategoryPayload>;
+                };
+                findFirst: {
+                    args: Prisma.CategoryFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CategoryPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.CategoryFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CategoryPayload>;
+                };
+                findMany: {
+                    args: Prisma.CategoryFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CategoryPayload>[];
+                };
+                create: {
+                    args: Prisma.CategoryCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CategoryPayload>;
+                };
+                createMany: {
+                    args: Prisma.CategoryCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.CategoryCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CategoryPayload>[];
+                };
+                delete: {
+                    args: Prisma.CategoryDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CategoryPayload>;
+                };
+                update: {
+                    args: Prisma.CategoryUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CategoryPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.CategoryDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.CategoryUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.CategoryUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CategoryPayload>[];
+                };
+                upsert: {
+                    args: Prisma.CategoryUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CategoryPayload>;
+                };
+                aggregate: {
+                    args: Prisma.CategoryAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateCategory>;
+                };
+                groupBy: {
+                    args: Prisma.CategoryGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.CategoryGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.CategoryCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.CategoryCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Country: {
+            payload: Prisma.$CountryPayload<ExtArgs>;
+            fields: Prisma.CountryFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.CountryFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CountryPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.CountryFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CountryPayload>;
+                };
+                findFirst: {
+                    args: Prisma.CountryFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CountryPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.CountryFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CountryPayload>;
+                };
+                findMany: {
+                    args: Prisma.CountryFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CountryPayload>[];
+                };
+                create: {
+                    args: Prisma.CountryCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CountryPayload>;
+                };
+                createMany: {
+                    args: Prisma.CountryCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.CountryCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CountryPayload>[];
+                };
+                delete: {
+                    args: Prisma.CountryDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CountryPayload>;
+                };
+                update: {
+                    args: Prisma.CountryUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CountryPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.CountryDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.CountryUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.CountryUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CountryPayload>[];
+                };
+                upsert: {
+                    args: Prisma.CountryUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CountryPayload>;
+                };
+                aggregate: {
+                    args: Prisma.CountryAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateCountry>;
+                };
+                groupBy: {
+                    args: Prisma.CountryGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.CountryGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.CountryCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.CountryCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Customer: {
+            payload: Prisma.$CustomerPayload<ExtArgs>;
+            fields: Prisma.CustomerFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.CustomerFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CustomerPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.CustomerFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CustomerPayload>;
+                };
+                findFirst: {
+                    args: Prisma.CustomerFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CustomerPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.CustomerFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CustomerPayload>;
+                };
+                findMany: {
+                    args: Prisma.CustomerFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CustomerPayload>[];
+                };
+                create: {
+                    args: Prisma.CustomerCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CustomerPayload>;
+                };
+                createMany: {
+                    args: Prisma.CustomerCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.CustomerCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CustomerPayload>[];
+                };
+                delete: {
+                    args: Prisma.CustomerDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CustomerPayload>;
+                };
+                update: {
+                    args: Prisma.CustomerUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CustomerPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.CustomerDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.CustomerUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.CustomerUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CustomerPayload>[];
+                };
+                upsert: {
+                    args: Prisma.CustomerUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CustomerPayload>;
+                };
+                aggregate: {
+                    args: Prisma.CustomerAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateCustomer>;
+                };
+                groupBy: {
+                    args: Prisma.CustomerGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.CustomerGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.CustomerCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.CustomerCountAggregateOutputType> | number;
+                };
+            };
+        };
+        CustomerAddress: {
+            payload: Prisma.$CustomerAddressPayload<ExtArgs>;
+            fields: Prisma.CustomerAddressFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.CustomerAddressFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CustomerAddressPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.CustomerAddressFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CustomerAddressPayload>;
+                };
+                findFirst: {
+                    args: Prisma.CustomerAddressFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CustomerAddressPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.CustomerAddressFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CustomerAddressPayload>;
+                };
+                findMany: {
+                    args: Prisma.CustomerAddressFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CustomerAddressPayload>[];
+                };
+                create: {
+                    args: Prisma.CustomerAddressCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CustomerAddressPayload>;
+                };
+                createMany: {
+                    args: Prisma.CustomerAddressCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.CustomerAddressCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CustomerAddressPayload>[];
+                };
+                delete: {
+                    args: Prisma.CustomerAddressDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CustomerAddressPayload>;
+                };
+                update: {
+                    args: Prisma.CustomerAddressUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CustomerAddressPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.CustomerAddressDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.CustomerAddressUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.CustomerAddressUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CustomerAddressPayload>[];
+                };
+                upsert: {
+                    args: Prisma.CustomerAddressUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CustomerAddressPayload>;
+                };
+                aggregate: {
+                    args: Prisma.CustomerAddressAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateCustomerAddress>;
+                };
+                groupBy: {
+                    args: Prisma.CustomerAddressGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.CustomerAddressGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.CustomerAddressCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.CustomerAddressCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Order: {
+            payload: Prisma.$OrderPayload<ExtArgs>;
+            fields: Prisma.OrderFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.OrderFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.OrderFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderPayload>;
+                };
+                findFirst: {
+                    args: Prisma.OrderFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.OrderFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderPayload>;
+                };
+                findMany: {
+                    args: Prisma.OrderFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderPayload>[];
+                };
+                create: {
+                    args: Prisma.OrderCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderPayload>;
+                };
+                createMany: {
+                    args: Prisma.OrderCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.OrderCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderPayload>[];
+                };
+                delete: {
+                    args: Prisma.OrderDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderPayload>;
+                };
+                update: {
+                    args: Prisma.OrderUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.OrderDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.OrderUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.OrderUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderPayload>[];
+                };
+                upsert: {
+                    args: Prisma.OrderUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderPayload>;
+                };
+                aggregate: {
+                    args: Prisma.OrderAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateOrder>;
+                };
+                groupBy: {
+                    args: Prisma.OrderGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OrderGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.OrderCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OrderCountAggregateOutputType> | number;
+                };
+            };
+        };
+        OrderItem: {
+            payload: Prisma.$OrderItemPayload<ExtArgs>;
+            fields: Prisma.OrderItemFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.OrderItemFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderItemPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.OrderItemFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderItemPayload>;
+                };
+                findFirst: {
+                    args: Prisma.OrderItemFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderItemPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.OrderItemFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderItemPayload>;
+                };
+                findMany: {
+                    args: Prisma.OrderItemFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderItemPayload>[];
+                };
+                create: {
+                    args: Prisma.OrderItemCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderItemPayload>;
+                };
+                createMany: {
+                    args: Prisma.OrderItemCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.OrderItemCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderItemPayload>[];
+                };
+                delete: {
+                    args: Prisma.OrderItemDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderItemPayload>;
+                };
+                update: {
+                    args: Prisma.OrderItemUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderItemPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.OrderItemDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.OrderItemUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.OrderItemUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderItemPayload>[];
+                };
+                upsert: {
+                    args: Prisma.OrderItemUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderItemPayload>;
+                };
+                aggregate: {
+                    args: Prisma.OrderItemAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateOrderItem>;
+                };
+                groupBy: {
+                    args: Prisma.OrderItemGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OrderItemGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.OrderItemCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OrderItemCountAggregateOutputType> | number;
+                };
+            };
+        };
+        OrderHistory: {
+            payload: Prisma.$OrderHistoryPayload<ExtArgs>;
+            fields: Prisma.OrderHistoryFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.OrderHistoryFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderHistoryPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.OrderHistoryFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderHistoryPayload>;
+                };
+                findFirst: {
+                    args: Prisma.OrderHistoryFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderHistoryPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.OrderHistoryFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderHistoryPayload>;
+                };
+                findMany: {
+                    args: Prisma.OrderHistoryFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderHistoryPayload>[];
+                };
+                create: {
+                    args: Prisma.OrderHistoryCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderHistoryPayload>;
+                };
+                createMany: {
+                    args: Prisma.OrderHistoryCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.OrderHistoryCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderHistoryPayload>[];
+                };
+                delete: {
+                    args: Prisma.OrderHistoryDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderHistoryPayload>;
+                };
+                update: {
+                    args: Prisma.OrderHistoryUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderHistoryPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.OrderHistoryDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.OrderHistoryUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.OrderHistoryUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderHistoryPayload>[];
+                };
+                upsert: {
+                    args: Prisma.OrderHistoryUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$OrderHistoryPayload>;
+                };
+                aggregate: {
+                    args: Prisma.OrderHistoryAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateOrderHistory>;
+                };
+                groupBy: {
+                    args: Prisma.OrderHistoryGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OrderHistoryGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.OrderHistoryCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.OrderHistoryCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Product: {
+            payload: Prisma.$ProductPayload<ExtArgs>;
+            fields: Prisma.ProductFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.ProductFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.ProductFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductPayload>;
+                };
+                findFirst: {
+                    args: Prisma.ProductFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.ProductFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductPayload>;
+                };
+                findMany: {
+                    args: Prisma.ProductFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductPayload>[];
+                };
+                create: {
+                    args: Prisma.ProductCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductPayload>;
+                };
+                createMany: {
+                    args: Prisma.ProductCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.ProductCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductPayload>[];
+                };
+                delete: {
+                    args: Prisma.ProductDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductPayload>;
+                };
+                update: {
+                    args: Prisma.ProductUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.ProductDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.ProductUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.ProductUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductPayload>[];
+                };
+                upsert: {
+                    args: Prisma.ProductUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductPayload>;
+                };
+                aggregate: {
+                    args: Prisma.ProductAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateProduct>;
+                };
+                groupBy: {
+                    args: Prisma.ProductGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ProductGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.ProductCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ProductCountAggregateOutputType> | number;
+                };
+            };
+        };
+        ProductImage: {
+            payload: Prisma.$ProductImagePayload<ExtArgs>;
+            fields: Prisma.ProductImageFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.ProductImageFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductImagePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.ProductImageFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductImagePayload>;
+                };
+                findFirst: {
+                    args: Prisma.ProductImageFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductImagePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.ProductImageFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductImagePayload>;
+                };
+                findMany: {
+                    args: Prisma.ProductImageFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductImagePayload>[];
+                };
+                create: {
+                    args: Prisma.ProductImageCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductImagePayload>;
+                };
+                createMany: {
+                    args: Prisma.ProductImageCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.ProductImageCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductImagePayload>[];
+                };
+                delete: {
+                    args: Prisma.ProductImageDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductImagePayload>;
+                };
+                update: {
+                    args: Prisma.ProductImageUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductImagePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.ProductImageDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.ProductImageUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.ProductImageUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductImagePayload>[];
+                };
+                upsert: {
+                    args: Prisma.ProductImageUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductImagePayload>;
+                };
+                aggregate: {
+                    args: Prisma.ProductImageAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateProductImage>;
+                };
+                groupBy: {
+                    args: Prisma.ProductImageGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ProductImageGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.ProductImageCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ProductImageCountAggregateOutputType> | number;
+                };
+            };
+        };
+        ProductVariant: {
+            payload: Prisma.$ProductVariantPayload<ExtArgs>;
+            fields: Prisma.ProductVariantFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.ProductVariantFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductVariantPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.ProductVariantFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductVariantPayload>;
+                };
+                findFirst: {
+                    args: Prisma.ProductVariantFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductVariantPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.ProductVariantFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductVariantPayload>;
+                };
+                findMany: {
+                    args: Prisma.ProductVariantFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductVariantPayload>[];
+                };
+                create: {
+                    args: Prisma.ProductVariantCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductVariantPayload>;
+                };
+                createMany: {
+                    args: Prisma.ProductVariantCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.ProductVariantCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductVariantPayload>[];
+                };
+                delete: {
+                    args: Prisma.ProductVariantDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductVariantPayload>;
+                };
+                update: {
+                    args: Prisma.ProductVariantUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductVariantPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.ProductVariantDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.ProductVariantUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.ProductVariantUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductVariantPayload>[];
+                };
+                upsert: {
+                    args: Prisma.ProductVariantUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductVariantPayload>;
+                };
+                aggregate: {
+                    args: Prisma.ProductVariantAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateProductVariant>;
+                };
+                groupBy: {
+                    args: Prisma.ProductVariantGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ProductVariantGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.ProductVariantCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ProductVariantCountAggregateOutputType> | number;
+                };
+            };
+        };
+        ProductOption: {
+            payload: Prisma.$ProductOptionPayload<ExtArgs>;
+            fields: Prisma.ProductOptionFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.ProductOptionFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductOptionPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.ProductOptionFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductOptionPayload>;
+                };
+                findFirst: {
+                    args: Prisma.ProductOptionFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductOptionPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.ProductOptionFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductOptionPayload>;
+                };
+                findMany: {
+                    args: Prisma.ProductOptionFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductOptionPayload>[];
+                };
+                create: {
+                    args: Prisma.ProductOptionCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductOptionPayload>;
+                };
+                createMany: {
+                    args: Prisma.ProductOptionCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.ProductOptionCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductOptionPayload>[];
+                };
+                delete: {
+                    args: Prisma.ProductOptionDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductOptionPayload>;
+                };
+                update: {
+                    args: Prisma.ProductOptionUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductOptionPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.ProductOptionDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.ProductOptionUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.ProductOptionUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductOptionPayload>[];
+                };
+                upsert: {
+                    args: Prisma.ProductOptionUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductOptionPayload>;
+                };
+                aggregate: {
+                    args: Prisma.ProductOptionAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateProductOption>;
+                };
+                groupBy: {
+                    args: Prisma.ProductOptionGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ProductOptionGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.ProductOptionCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ProductOptionCountAggregateOutputType> | number;
+                };
+            };
+        };
+        ProductOptionValue: {
+            payload: Prisma.$ProductOptionValuePayload<ExtArgs>;
+            fields: Prisma.ProductOptionValueFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.ProductOptionValueFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductOptionValuePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.ProductOptionValueFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductOptionValuePayload>;
+                };
+                findFirst: {
+                    args: Prisma.ProductOptionValueFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductOptionValuePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.ProductOptionValueFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductOptionValuePayload>;
+                };
+                findMany: {
+                    args: Prisma.ProductOptionValueFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductOptionValuePayload>[];
+                };
+                create: {
+                    args: Prisma.ProductOptionValueCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductOptionValuePayload>;
+                };
+                createMany: {
+                    args: Prisma.ProductOptionValueCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.ProductOptionValueCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductOptionValuePayload>[];
+                };
+                delete: {
+                    args: Prisma.ProductOptionValueDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductOptionValuePayload>;
+                };
+                update: {
+                    args: Prisma.ProductOptionValueUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductOptionValuePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.ProductOptionValueDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.ProductOptionValueUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.ProductOptionValueUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductOptionValuePayload>[];
+                };
+                upsert: {
+                    args: Prisma.ProductOptionValueUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductOptionValuePayload>;
+                };
+                aggregate: {
+                    args: Prisma.ProductOptionValueAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateProductOptionValue>;
+                };
+                groupBy: {
+                    args: Prisma.ProductOptionValueGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ProductOptionValueGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.ProductOptionValueCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ProductOptionValueCountAggregateOutputType> | number;
+                };
+            };
+        };
+        ProductAttribute: {
+            payload: Prisma.$ProductAttributePayload<ExtArgs>;
+            fields: Prisma.ProductAttributeFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.ProductAttributeFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductAttributePayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.ProductAttributeFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductAttributePayload>;
+                };
+                findFirst: {
+                    args: Prisma.ProductAttributeFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductAttributePayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.ProductAttributeFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductAttributePayload>;
+                };
+                findMany: {
+                    args: Prisma.ProductAttributeFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductAttributePayload>[];
+                };
+                create: {
+                    args: Prisma.ProductAttributeCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductAttributePayload>;
+                };
+                createMany: {
+                    args: Prisma.ProductAttributeCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.ProductAttributeCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductAttributePayload>[];
+                };
+                delete: {
+                    args: Prisma.ProductAttributeDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductAttributePayload>;
+                };
+                update: {
+                    args: Prisma.ProductAttributeUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductAttributePayload>;
+                };
+                deleteMany: {
+                    args: Prisma.ProductAttributeDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.ProductAttributeUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.ProductAttributeUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductAttributePayload>[];
+                };
+                upsert: {
+                    args: Prisma.ProductAttributeUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductAttributePayload>;
+                };
+                aggregate: {
+                    args: Prisma.ProductAttributeAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateProductAttribute>;
+                };
+                groupBy: {
+                    args: Prisma.ProductAttributeGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ProductAttributeGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.ProductAttributeCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ProductAttributeCountAggregateOutputType> | number;
+                };
+            };
+        };
+        ProductCategory: {
+            payload: Prisma.$ProductCategoryPayload<ExtArgs>;
+            fields: Prisma.ProductCategoryFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.ProductCategoryFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductCategoryPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.ProductCategoryFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductCategoryPayload>;
+                };
+                findFirst: {
+                    args: Prisma.ProductCategoryFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductCategoryPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.ProductCategoryFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductCategoryPayload>;
+                };
+                findMany: {
+                    args: Prisma.ProductCategoryFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductCategoryPayload>[];
+                };
+                create: {
+                    args: Prisma.ProductCategoryCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductCategoryPayload>;
+                };
+                createMany: {
+                    args: Prisma.ProductCategoryCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.ProductCategoryCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductCategoryPayload>[];
+                };
+                delete: {
+                    args: Prisma.ProductCategoryDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductCategoryPayload>;
+                };
+                update: {
+                    args: Prisma.ProductCategoryUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductCategoryPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.ProductCategoryDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.ProductCategoryUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.ProductCategoryUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductCategoryPayload>[];
+                };
+                upsert: {
+                    args: Prisma.ProductCategoryUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductCategoryPayload>;
+                };
+                aggregate: {
+                    args: Prisma.ProductCategoryAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateProductCategory>;
+                };
+                groupBy: {
+                    args: Prisma.ProductCategoryGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ProductCategoryGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.ProductCategoryCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ProductCategoryCountAggregateOutputType> | number;
+                };
+            };
+        };
+        ProductTag: {
+            payload: Prisma.$ProductTagPayload<ExtArgs>;
+            fields: Prisma.ProductTagFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.ProductTagFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductTagPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.ProductTagFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductTagPayload>;
+                };
+                findFirst: {
+                    args: Prisma.ProductTagFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductTagPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.ProductTagFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductTagPayload>;
+                };
+                findMany: {
+                    args: Prisma.ProductTagFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductTagPayload>[];
+                };
+                create: {
+                    args: Prisma.ProductTagCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductTagPayload>;
+                };
+                createMany: {
+                    args: Prisma.ProductTagCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.ProductTagCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductTagPayload>[];
+                };
+                delete: {
+                    args: Prisma.ProductTagDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductTagPayload>;
+                };
+                update: {
+                    args: Prisma.ProductTagUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductTagPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.ProductTagDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.ProductTagUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.ProductTagUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductTagPayload>[];
+                };
+                upsert: {
+                    args: Prisma.ProductTagUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ProductTagPayload>;
+                };
+                aggregate: {
+                    args: Prisma.ProductTagAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateProductTag>;
+                };
+                groupBy: {
+                    args: Prisma.ProductTagGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ProductTagGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.ProductTagCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ProductTagCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Promotion: {
+            payload: Prisma.$PromotionPayload<ExtArgs>;
+            fields: Prisma.PromotionFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.PromotionFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PromotionPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.PromotionFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PromotionPayload>;
+                };
+                findFirst: {
+                    args: Prisma.PromotionFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PromotionPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.PromotionFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PromotionPayload>;
+                };
+                findMany: {
+                    args: Prisma.PromotionFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PromotionPayload>[];
+                };
+                create: {
+                    args: Prisma.PromotionCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PromotionPayload>;
+                };
+                createMany: {
+                    args: Prisma.PromotionCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.PromotionCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PromotionPayload>[];
+                };
+                delete: {
+                    args: Prisma.PromotionDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PromotionPayload>;
+                };
+                update: {
+                    args: Prisma.PromotionUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PromotionPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.PromotionDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.PromotionUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.PromotionUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PromotionPayload>[];
+                };
+                upsert: {
+                    args: Prisma.PromotionUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$PromotionPayload>;
+                };
+                aggregate: {
+                    args: Prisma.PromotionAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregatePromotion>;
+                };
+                groupBy: {
+                    args: Prisma.PromotionGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.PromotionGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.PromotionCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.PromotionCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Coupon: {
+            payload: Prisma.$CouponPayload<ExtArgs>;
+            fields: Prisma.CouponFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.CouponFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CouponPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.CouponFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CouponPayload>;
+                };
+                findFirst: {
+                    args: Prisma.CouponFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CouponPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.CouponFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CouponPayload>;
+                };
+                findMany: {
+                    args: Prisma.CouponFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CouponPayload>[];
+                };
+                create: {
+                    args: Prisma.CouponCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CouponPayload>;
+                };
+                createMany: {
+                    args: Prisma.CouponCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.CouponCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CouponPayload>[];
+                };
+                delete: {
+                    args: Prisma.CouponDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CouponPayload>;
+                };
+                update: {
+                    args: Prisma.CouponUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CouponPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.CouponDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.CouponUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.CouponUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CouponPayload>[];
+                };
+                upsert: {
+                    args: Prisma.CouponUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$CouponPayload>;
+                };
+                aggregate: {
+                    args: Prisma.CouponAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateCoupon>;
+                };
+                groupBy: {
+                    args: Prisma.CouponGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.CouponGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.CouponCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.CouponCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Return: {
+            payload: Prisma.$ReturnPayload<ExtArgs>;
+            fields: Prisma.ReturnFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.ReturnFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReturnPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.ReturnFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReturnPayload>;
+                };
+                findFirst: {
+                    args: Prisma.ReturnFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReturnPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.ReturnFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReturnPayload>;
+                };
+                findMany: {
+                    args: Prisma.ReturnFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReturnPayload>[];
+                };
+                create: {
+                    args: Prisma.ReturnCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReturnPayload>;
+                };
+                createMany: {
+                    args: Prisma.ReturnCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.ReturnCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReturnPayload>[];
+                };
+                delete: {
+                    args: Prisma.ReturnDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReturnPayload>;
+                };
+                update: {
+                    args: Prisma.ReturnUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReturnPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.ReturnDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.ReturnUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.ReturnUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReturnPayload>[];
+                };
+                upsert: {
+                    args: Prisma.ReturnUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReturnPayload>;
+                };
+                aggregate: {
+                    args: Prisma.ReturnAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateReturn>;
+                };
+                groupBy: {
+                    args: Prisma.ReturnGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ReturnGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.ReturnCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ReturnCountAggregateOutputType> | number;
+                };
+            };
+        };
+        ReturnItem: {
+            payload: Prisma.$ReturnItemPayload<ExtArgs>;
+            fields: Prisma.ReturnItemFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.ReturnItemFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReturnItemPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.ReturnItemFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReturnItemPayload>;
+                };
+                findFirst: {
+                    args: Prisma.ReturnItemFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReturnItemPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.ReturnItemFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReturnItemPayload>;
+                };
+                findMany: {
+                    args: Prisma.ReturnItemFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReturnItemPayload>[];
+                };
+                create: {
+                    args: Prisma.ReturnItemCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReturnItemPayload>;
+                };
+                createMany: {
+                    args: Prisma.ReturnItemCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.ReturnItemCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReturnItemPayload>[];
+                };
+                delete: {
+                    args: Prisma.ReturnItemDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReturnItemPayload>;
+                };
+                update: {
+                    args: Prisma.ReturnItemUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReturnItemPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.ReturnItemDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.ReturnItemUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.ReturnItemUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReturnItemPayload>[];
+                };
+                upsert: {
+                    args: Prisma.ReturnItemUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReturnItemPayload>;
+                };
+                aggregate: {
+                    args: Prisma.ReturnItemAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateReturnItem>;
+                };
+                groupBy: {
+                    args: Prisma.ReturnItemGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ReturnItemGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.ReturnItemCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ReturnItemCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Review: {
+            payload: Prisma.$ReviewPayload<ExtArgs>;
+            fields: Prisma.ReviewFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.ReviewFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReviewPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.ReviewFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReviewPayload>;
+                };
+                findFirst: {
+                    args: Prisma.ReviewFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReviewPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.ReviewFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReviewPayload>;
+                };
+                findMany: {
+                    args: Prisma.ReviewFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReviewPayload>[];
+                };
+                create: {
+                    args: Prisma.ReviewCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReviewPayload>;
+                };
+                createMany: {
+                    args: Prisma.ReviewCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.ReviewCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReviewPayload>[];
+                };
+                delete: {
+                    args: Prisma.ReviewDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReviewPayload>;
+                };
+                update: {
+                    args: Prisma.ReviewUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReviewPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.ReviewDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.ReviewUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.ReviewUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReviewPayload>[];
+                };
+                upsert: {
+                    args: Prisma.ReviewUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$ReviewPayload>;
+                };
+                aggregate: {
+                    args: Prisma.ReviewAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateReview>;
+                };
+                groupBy: {
+                    args: Prisma.ReviewGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ReviewGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.ReviewCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.ReviewCountAggregateOutputType> | number;
+                };
+            };
+        };
+        StoreInfo: {
+            payload: Prisma.$StoreInfoPayload<ExtArgs>;
+            fields: Prisma.StoreInfoFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.StoreInfoFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StoreInfoPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.StoreInfoFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StoreInfoPayload>;
+                };
+                findFirst: {
+                    args: Prisma.StoreInfoFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StoreInfoPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.StoreInfoFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StoreInfoPayload>;
+                };
+                findMany: {
+                    args: Prisma.StoreInfoFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StoreInfoPayload>[];
+                };
+                create: {
+                    args: Prisma.StoreInfoCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StoreInfoPayload>;
+                };
+                createMany: {
+                    args: Prisma.StoreInfoCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.StoreInfoCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StoreInfoPayload>[];
+                };
+                delete: {
+                    args: Prisma.StoreInfoDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StoreInfoPayload>;
+                };
+                update: {
+                    args: Prisma.StoreInfoUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StoreInfoPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.StoreInfoDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.StoreInfoUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.StoreInfoUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StoreInfoPayload>[];
+                };
+                upsert: {
+                    args: Prisma.StoreInfoUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$StoreInfoPayload>;
+                };
+                aggregate: {
+                    args: Prisma.StoreInfoAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateStoreInfo>;
+                };
+                groupBy: {
+                    args: Prisma.StoreInfoGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.StoreInfoGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.StoreInfoCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.StoreInfoCountAggregateOutputType> | number;
+                };
+            };
+        };
+        Wishlist: {
+            payload: Prisma.$WishlistPayload<ExtArgs>;
+            fields: Prisma.WishlistFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.WishlistFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WishlistPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.WishlistFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WishlistPayload>;
+                };
+                findFirst: {
+                    args: Prisma.WishlistFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WishlistPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.WishlistFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WishlistPayload>;
+                };
+                findMany: {
+                    args: Prisma.WishlistFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WishlistPayload>[];
+                };
+                create: {
+                    args: Prisma.WishlistCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WishlistPayload>;
+                };
+                createMany: {
+                    args: Prisma.WishlistCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.WishlistCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WishlistPayload>[];
+                };
+                delete: {
+                    args: Prisma.WishlistDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WishlistPayload>;
+                };
+                update: {
+                    args: Prisma.WishlistUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WishlistPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.WishlistDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.WishlistUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.WishlistUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WishlistPayload>[];
+                };
+                upsert: {
+                    args: Prisma.WishlistUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WishlistPayload>;
+                };
+                aggregate: {
+                    args: Prisma.WishlistAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateWishlist>;
+                };
+                groupBy: {
+                    args: Prisma.WishlistGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WishlistGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.WishlistCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WishlistCountAggregateOutputType> | number;
+                };
+            };
+        };
+        WishlistItem: {
+            payload: Prisma.$WishlistItemPayload<ExtArgs>;
+            fields: Prisma.WishlistItemFieldRefs;
+            operations: {
+                findUnique: {
+                    args: Prisma.WishlistItemFindUniqueArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WishlistItemPayload> | null;
+                };
+                findUniqueOrThrow: {
+                    args: Prisma.WishlistItemFindUniqueOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WishlistItemPayload>;
+                };
+                findFirst: {
+                    args: Prisma.WishlistItemFindFirstArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WishlistItemPayload> | null;
+                };
+                findFirstOrThrow: {
+                    args: Prisma.WishlistItemFindFirstOrThrowArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WishlistItemPayload>;
+                };
+                findMany: {
+                    args: Prisma.WishlistItemFindManyArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WishlistItemPayload>[];
+                };
+                create: {
+                    args: Prisma.WishlistItemCreateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WishlistItemPayload>;
+                };
+                createMany: {
+                    args: Prisma.WishlistItemCreateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                createManyAndReturn: {
+                    args: Prisma.WishlistItemCreateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WishlistItemPayload>[];
+                };
+                delete: {
+                    args: Prisma.WishlistItemDeleteArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WishlistItemPayload>;
+                };
+                update: {
+                    args: Prisma.WishlistItemUpdateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WishlistItemPayload>;
+                };
+                deleteMany: {
+                    args: Prisma.WishlistItemDeleteManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateMany: {
+                    args: Prisma.WishlistItemUpdateManyArgs<ExtArgs>;
+                    result: BatchPayload;
+                };
+                updateManyAndReturn: {
+                    args: Prisma.WishlistItemUpdateManyAndReturnArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WishlistItemPayload>[];
+                };
+                upsert: {
+                    args: Prisma.WishlistItemUpsertArgs<ExtArgs>;
+                    result: runtime.Types.Utils.PayloadToResult<Prisma.$WishlistItemPayload>;
+                };
+                aggregate: {
+                    args: Prisma.WishlistItemAggregateArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.AggregateWishlistItem>;
+                };
+                groupBy: {
+                    args: Prisma.WishlistItemGroupByArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WishlistItemGroupByOutputType>[];
+                };
+                count: {
+                    args: Prisma.WishlistItemCountArgs<ExtArgs>;
+                    result: runtime.Types.Utils.Optional<Prisma.WishlistItemCountAggregateOutputType> | number;
+                };
+            };
+        };
+    };
+} & {
+    other: {
+        payload: any;
+        operations: {
+            $executeRaw: {
+                args: [query: TemplateStringsArray | Sql, ...values: any[]];
+                result: any;
+            };
+            $executeRawUnsafe: {
+                args: [query: string, ...values: any[]];
+                result: any;
+            };
+            $queryRaw: {
+                args: [query: TemplateStringsArray | Sql, ...values: any[]];
+                result: any;
+            };
+            $queryRawUnsafe: {
+                args: [query: string, ...values: any[]];
+                result: any;
+            };
+        };
+    };
+};
+/**
+ * Enums
+ */
+export declare const TransactionIsolationLevel: {
+    readonly Serializable: "Serializable";
+};
+export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel];
+export declare const BrandScalarFieldEnum: {
+    readonly id: "id";
+    readonly name: "name";
+    readonly nameAr: "nameAr";
+    readonly slug: "slug";
+    readonly logo: "logo";
+    readonly description: "description";
+    readonly descriptionAr: "descriptionAr";
+    readonly isActive: "isActive";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type BrandScalarFieldEnum = (typeof BrandScalarFieldEnum)[keyof typeof BrandScalarFieldEnum];
+export declare const CartScalarFieldEnum: {
+    readonly id: "id";
+    readonly customerId: "customerId";
+    readonly couponCode: "couponCode";
+    readonly shippingAddress: "shippingAddress";
+    readonly billingAddress: "billingAddress";
+    readonly shippingMethodId: "shippingMethodId";
+    readonly paymentMethodId: "paymentMethodId";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type CartScalarFieldEnum = (typeof CartScalarFieldEnum)[keyof typeof CartScalarFieldEnum];
+export declare const CartItemScalarFieldEnum: {
+    readonly id: "id";
+    readonly cartId: "cartId";
+    readonly productId: "productId";
+    readonly variantId: "variantId";
+    readonly quantity: "quantity";
+    readonly createdAt: "createdAt";
+};
+export type CartItemScalarFieldEnum = (typeof CartItemScalarFieldEnum)[keyof typeof CartItemScalarFieldEnum];
+export declare const CategoryScalarFieldEnum: {
+    readonly id: "id";
+    readonly name: "name";
+    readonly nameAr: "nameAr";
+    readonly slug: "slug";
+    readonly description: "description";
+    readonly descriptionAr: "descriptionAr";
+    readonly image: "image";
+    readonly parentId: "parentId";
+    readonly sortOrder: "sortOrder";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type CategoryScalarFieldEnum = (typeof CategoryScalarFieldEnum)[keyof typeof CategoryScalarFieldEnum];
+export declare const CountryScalarFieldEnum: {
+    readonly id: "id";
+    readonly code: "code";
+    readonly name: "name";
+    readonly nameAr: "nameAr";
+    readonly callingCode: "callingCode";
+    readonly currency: "currency";
+    readonly capital: "capital";
+    readonly isActive: "isActive";
+};
+export type CountryScalarFieldEnum = (typeof CountryScalarFieldEnum)[keyof typeof CountryScalarFieldEnum];
+export declare const CustomerScalarFieldEnum: {
+    readonly id: "id";
+    readonly email: "email";
+    readonly passwordHash: "passwordHash";
+    readonly firstName: "firstName";
+    readonly lastName: "lastName";
+    readonly phone: "phone";
+    readonly defaultAddressId: "defaultAddressId";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type CustomerScalarFieldEnum = (typeof CustomerScalarFieldEnum)[keyof typeof CustomerScalarFieldEnum];
+export declare const CustomerAddressScalarFieldEnum: {
+    readonly id: "id";
+    readonly customerId: "customerId";
+    readonly firstName: "firstName";
+    readonly lastName: "lastName";
+    readonly phone: "phone";
+    readonly street: "street";
+    readonly street2: "street2";
+    readonly city: "city";
+    readonly state: "state";
+    readonly country: "country";
+    readonly postalCode: "postalCode";
+    readonly district: "district";
+    readonly nationalAddress: "nationalAddress";
+    readonly additionalNumber: "additionalNumber";
+    readonly isDefault: "isDefault";
+};
+export type CustomerAddressScalarFieldEnum = (typeof CustomerAddressScalarFieldEnum)[keyof typeof CustomerAddressScalarFieldEnum];
+export declare const OrderScalarFieldEnum: {
+    readonly id: "id";
+    readonly orderNumber: "orderNumber";
+    readonly customerId: "customerId";
+    readonly status: "status";
+    readonly subtotal: "subtotal";
+    readonly shippingCost: "shippingCost";
+    readonly tax: "tax";
+    readonly discount: "discount";
+    readonly total: "total";
+    readonly currency: "currency";
+    readonly shippingAddress: "shippingAddress";
+    readonly billingAddress: "billingAddress";
+    readonly shippingMethod: "shippingMethod";
+    readonly paymentMethod: "paymentMethod";
+    readonly trackingNumber: "trackingNumber";
+    readonly trackingUrl: "trackingUrl";
+    readonly note: "note";
+    readonly requiresShipping: "requiresShipping";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type OrderScalarFieldEnum = (typeof OrderScalarFieldEnum)[keyof typeof OrderScalarFieldEnum];
+export declare const OrderItemScalarFieldEnum: {
+    readonly id: "id";
+    readonly orderId: "orderId";
+    readonly productId: "productId";
+    readonly variantId: "variantId";
+    readonly name: "name";
+    readonly nameAr: "nameAr";
+    readonly image: "image";
+    readonly quantity: "quantity";
+    readonly price: "price";
+    readonly totalPrice: "totalPrice";
+    readonly productType: "productType";
+    readonly fulfillmentStatus: "fulfillmentStatus";
+};
+export type OrderItemScalarFieldEnum = (typeof OrderItemScalarFieldEnum)[keyof typeof OrderItemScalarFieldEnum];
+export declare const OrderHistoryScalarFieldEnum: {
+    readonly id: "id";
+    readonly orderId: "orderId";
+    readonly fromStatus: "fromStatus";
+    readonly toStatus: "toStatus";
+    readonly note: "note";
+    readonly createdAt: "createdAt";
+};
+export type OrderHistoryScalarFieldEnum = (typeof OrderHistoryScalarFieldEnum)[keyof typeof OrderHistoryScalarFieldEnum];
+export declare const ProductScalarFieldEnum: {
+    readonly id: "id";
+    readonly sku: "sku";
+    readonly name: "name";
+    readonly nameAr: "nameAr";
+    readonly slug: "slug";
+    readonly description: "description";
+    readonly descriptionAr: "descriptionAr";
+    readonly shortDescription: "shortDescription";
+    readonly shortDescriptionAr: "shortDescriptionAr";
+    readonly price: "price";
+    readonly compareAtPrice: "compareAtPrice";
+    readonly currency: "currency";
+    readonly productType: "productType";
+    readonly inStock: "inStock";
+    readonly inventoryQuantity: "inventoryQuantity";
+    readonly quantityLimit: "quantityLimit";
+    readonly vatIncluded: "vatIncluded";
+    readonly vatRate: "vatRate";
+    readonly requiresShipping: "requiresShipping";
+    readonly isDropshipped: "isDropshipped";
+    readonly status: "status";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type ProductScalarFieldEnum = (typeof ProductScalarFieldEnum)[keyof typeof ProductScalarFieldEnum];
+export declare const ProductImageScalarFieldEnum: {
+    readonly id: "id";
+    readonly productId: "productId";
+    readonly url: "url";
+    readonly altText: "altText";
+    readonly sortOrder: "sortOrder";
+    readonly isPrimary: "isPrimary";
+};
+export type ProductImageScalarFieldEnum = (typeof ProductImageScalarFieldEnum)[keyof typeof ProductImageScalarFieldEnum];
+export declare const ProductVariantScalarFieldEnum: {
+    readonly id: "id";
+    readonly productId: "productId";
+    readonly sku: "sku";
+    readonly name: "name";
+    readonly nameAr: "nameAr";
+    readonly price: "price";
+    readonly compareAtPrice: "compareAtPrice";
+    readonly inStock: "inStock";
+    readonly inventoryQuantity: "inventoryQuantity";
+    readonly sortOrder: "sortOrder";
+};
+export type ProductVariantScalarFieldEnum = (typeof ProductVariantScalarFieldEnum)[keyof typeof ProductVariantScalarFieldEnum];
+export declare const ProductOptionScalarFieldEnum: {
+    readonly id: "id";
+    readonly productId: "productId";
+    readonly name: "name";
+    readonly nameAr: "nameAr";
+    readonly sortOrder: "sortOrder";
+};
+export type ProductOptionScalarFieldEnum = (typeof ProductOptionScalarFieldEnum)[keyof typeof ProductOptionScalarFieldEnum];
+export declare const ProductOptionValueScalarFieldEnum: {
+    readonly id: "id";
+    readonly optionId: "optionId";
+    readonly name: "name";
+    readonly nameAr: "nameAr";
+    readonly sortOrder: "sortOrder";
+};
+export type ProductOptionValueScalarFieldEnum = (typeof ProductOptionValueScalarFieldEnum)[keyof typeof ProductOptionValueScalarFieldEnum];
+export declare const ProductAttributeScalarFieldEnum: {
+    readonly id: "id";
+    readonly productId: "productId";
+    readonly code: "code";
+    readonly name: "name";
+    readonly nameAr: "nameAr";
+    readonly value: "value";
+    readonly valueAr: "valueAr";
+};
+export type ProductAttributeScalarFieldEnum = (typeof ProductAttributeScalarFieldEnum)[keyof typeof ProductAttributeScalarFieldEnum];
+export declare const ProductCategoryScalarFieldEnum: {
+    readonly productId: "productId";
+    readonly categoryId: "categoryId";
+};
+export type ProductCategoryScalarFieldEnum = (typeof ProductCategoryScalarFieldEnum)[keyof typeof ProductCategoryScalarFieldEnum];
+export declare const ProductTagScalarFieldEnum: {
+    readonly id: "id";
+    readonly productId: "productId";
+    readonly tag: "tag";
+};
+export type ProductTagScalarFieldEnum = (typeof ProductTagScalarFieldEnum)[keyof typeof ProductTagScalarFieldEnum];
+export declare const PromotionScalarFieldEnum: {
+    readonly id: "id";
+    readonly name: "name";
+    readonly nameAr: "nameAr";
+    readonly description: "description";
+    readonly descriptionAr: "descriptionAr";
+    readonly discountType: "discountType";
+    readonly discountValue: "discountValue";
+    readonly currency: "currency";
+    readonly maxDiscount: "maxDiscount";
+    readonly target: "target";
+    readonly conditionsJson: "conditionsJson";
+    readonly startsAt: "startsAt";
+    readonly endsAt: "endsAt";
+    readonly isActive: "isActive";
+    readonly requiresCoupon: "requiresCoupon";
+    readonly usageLimitPerCustomer: "usageLimitPerCustomer";
+    readonly usageLimitTotal: "usageLimitTotal";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type PromotionScalarFieldEnum = (typeof PromotionScalarFieldEnum)[keyof typeof PromotionScalarFieldEnum];
+export declare const CouponScalarFieldEnum: {
+    readonly id: "id";
+    readonly code: "code";
+    readonly promotionId: "promotionId";
+    readonly isValid: "isValid";
+    readonly invalidReason: "invalidReason";
+    readonly timesUsed: "timesUsed";
+};
+export type CouponScalarFieldEnum = (typeof CouponScalarFieldEnum)[keyof typeof CouponScalarFieldEnum];
+export declare const ReturnScalarFieldEnum: {
+    readonly id: "id";
+    readonly orderId: "orderId";
+    readonly orderNumber: "orderNumber";
+    readonly status: "status";
+    readonly refundAmount: "refundAmount";
+    readonly refundCurrency: "refundCurrency";
+    readonly refundMethod: "refundMethod";
+    readonly returnShippingLabel: "returnShippingLabel";
+    readonly returnTrackingNumber: "returnTrackingNumber";
+    readonly merchantNote: "merchantNote";
+    readonly customerNote: "customerNote";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type ReturnScalarFieldEnum = (typeof ReturnScalarFieldEnum)[keyof typeof ReturnScalarFieldEnum];
+export declare const ReturnItemScalarFieldEnum: {
+    readonly id: "id";
+    readonly returnId: "returnId";
+    readonly orderItemId: "orderItemId";
+    readonly productId: "productId";
+    readonly variantId: "variantId";
+    readonly name: "name";
+    readonly nameAr: "nameAr";
+    readonly image: "image";
+    readonly quantity: "quantity";
+    readonly reason: "reason";
+    readonly reasonNote: "reasonNote";
+};
+export type ReturnItemScalarFieldEnum = (typeof ReturnItemScalarFieldEnum)[keyof typeof ReturnItemScalarFieldEnum];
+export declare const ReviewScalarFieldEnum: {
+    readonly id: "id";
+    readonly productId: "productId";
+    readonly authorName: "authorName";
+    readonly rating: "rating";
+    readonly title: "title";
+    readonly body: "body";
+    readonly verified: "verified";
+    readonly status: "status";
+    readonly createdAt: "createdAt";
+};
+export type ReviewScalarFieldEnum = (typeof ReviewScalarFieldEnum)[keyof typeof ReviewScalarFieldEnum];
+export declare const StoreInfoScalarFieldEnum: {
+    readonly id: "id";
+    readonly name: "name";
+    readonly nameAr: "nameAr";
+    readonly description: "description";
+    readonly descriptionAr: "descriptionAr";
+    readonly logo: "logo";
+    readonly favicon: "favicon";
+    readonly currency: "currency";
+    readonly locale: "locale";
+    readonly supportedCurrencies: "supportedCurrencies";
+    readonly supportedLocales: "supportedLocales";
+    readonly timezone: "timezone";
+    readonly contactEmail: "contactEmail";
+    readonly contactPhone: "contactPhone";
+    readonly address: "address";
+    readonly socialLinks: "socialLinks";
+    readonly createdAt: "createdAt";
+    readonly updatedAt: "updatedAt";
+};
+export type StoreInfoScalarFieldEnum = (typeof StoreInfoScalarFieldEnum)[keyof typeof StoreInfoScalarFieldEnum];
+export declare const WishlistScalarFieldEnum: {
+    readonly id: "id";
+    readonly customerId: "customerId";
+    readonly createdAt: "createdAt";
+};
+export type WishlistScalarFieldEnum = (typeof WishlistScalarFieldEnum)[keyof typeof WishlistScalarFieldEnum];
+export declare const WishlistItemScalarFieldEnum: {
+    readonly id: "id";
+    readonly wishlistId: "wishlistId";
+    readonly productId: "productId";
+    readonly variantId: "variantId";
+    readonly addedAt: "addedAt";
+};
+export type WishlistItemScalarFieldEnum = (typeof WishlistItemScalarFieldEnum)[keyof typeof WishlistItemScalarFieldEnum];
+export declare const SortOrder: {
+    readonly asc: "asc";
+    readonly desc: "desc";
+};
+export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder];
+export declare const NullsOrder: {
+    readonly first: "first";
+    readonly last: "last";
+};
+export type NullsOrder = (typeof NullsOrder)[keyof typeof NullsOrder];
+/**
+ * Field references
+ */
+/**
+ * Reference to a field of type 'String'
+ */
+export type StringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String'>;
+/**
+ * Reference to a field of type 'Boolean'
+ */
+export type BooleanFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Boolean'>;
+/**
+ * Reference to a field of type 'Int'
+ */
+export type IntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int'>;
+/**
+ * Reference to a field of type 'Float'
+ */
+export type FloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float'>;
+/**
+ * Batch Payload for updateMany & deleteMany & createMany
+ */
+export type BatchPayload = {
+    count: number;
+};
+export declare const defineExtension: runtime.Types.Extensions.ExtendsHook<"define", TypeMapCb, runtime.Types.Extensions.DefaultArgs>;
+export type DefaultPrismaClient = PrismaClient;
+export type ErrorFormat = 'pretty' | 'colorless' | 'minimal';
+export type PrismaClientOptions = ({
+    /**
+     * Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-pg`.
+     */
+    adapter: runtime.SqlDriverAdapterFactory;
+    accelerateUrl?: never;
+} | {
+    /**
+     * Prisma Accelerate URL allowing the client to connect through Accelerate instead of a direct database.
+     */
+    accelerateUrl: string;
+    adapter?: never;
+}) & {
+    /**
+     * @default "colorless"
+     */
+    errorFormat?: ErrorFormat;
+    /**
+     * @example
+     * ```
+     * // Shorthand for `emit: 'stdout'`
+     * log: ['query', 'info', 'warn', 'error']
+     *
+     * // Emit as events only
+     * log: [
+     *   { emit: 'event', level: 'query' },
+     *   { emit: 'event', level: 'info' },
+     *   { emit: 'event', level: 'warn' }
+     *   { emit: 'event', level: 'error' }
+     * ]
+     *
+     * / Emit as events and log to stdout
+     * og: [
+     *  { emit: 'stdout', level: 'query' },
+     *  { emit: 'stdout', level: 'info' },
+     *  { emit: 'stdout', level: 'warn' }
+     *  { emit: 'stdout', level: 'error' }
+     *
+     * ```
+     * Read more in our [docs](https://pris.ly/d/logging).
+     */
+    log?: (LogLevel | LogDefinition)[];
+    /**
+     * The default values for transactionOptions
+     * maxWait ?= 2000
+     * timeout ?= 5000
+     */
+    transactionOptions?: {
+        maxWait?: number;
+        timeout?: number;
+        isolationLevel?: TransactionIsolationLevel;
+    };
+    /**
+     * Global configuration for omitting model fields by default.
+     *
+     * @example
+     * ```
+     * const prisma = new PrismaClient({
+     *   omit: {
+     *     user: {
+     *       password: true
+     *     }
+     *   }
+     * })
+     * ```
+     */
+    omit?: GlobalOmitConfig;
+    /**
+     * SQL commenter plugins that add metadata to SQL queries as comments.
+     * Comments follow the sqlcommenter format: https://google.github.io/sqlcommenter/
+     *
+     * @example
+     * ```
+     * const prisma = new PrismaClient({
+     *   adapter,
+     *   comments: [
+     *     traceContext(),
+     *     queryInsights(),
+     *   ],
+     * })
+     * ```
+     */
+    comments?: runtime.SqlCommenterPlugin[];
+};
+export type GlobalOmitConfig = {
+    brand?: Prisma.BrandOmit;
+    cart?: Prisma.CartOmit;
+    cartItem?: Prisma.CartItemOmit;
+    category?: Prisma.CategoryOmit;
+    country?: Prisma.CountryOmit;
+    customer?: Prisma.CustomerOmit;
+    customerAddress?: Prisma.CustomerAddressOmit;
+    order?: Prisma.OrderOmit;
+    orderItem?: Prisma.OrderItemOmit;
+    orderHistory?: Prisma.OrderHistoryOmit;
+    product?: Prisma.ProductOmit;
+    productImage?: Prisma.ProductImageOmit;
+    productVariant?: Prisma.ProductVariantOmit;
+    productOption?: Prisma.ProductOptionOmit;
+    productOptionValue?: Prisma.ProductOptionValueOmit;
+    productAttribute?: Prisma.ProductAttributeOmit;
+    productCategory?: Prisma.ProductCategoryOmit;
+    productTag?: Prisma.ProductTagOmit;
+    promotion?: Prisma.PromotionOmit;
+    coupon?: Prisma.CouponOmit;
+    return?: Prisma.ReturnOmit;
+    returnItem?: Prisma.ReturnItemOmit;
+    review?: Prisma.ReviewOmit;
+    storeInfo?: Prisma.StoreInfoOmit;
+    wishlist?: Prisma.WishlistOmit;
+    wishlistItem?: Prisma.WishlistItemOmit;
+};
+export type LogLevel = 'info' | 'query' | 'warn' | 'error';
+export type LogDefinition = {
+    level: LogLevel;
+    emit: 'stdout' | 'event';
+};
+export type CheckIsLogLevel<T> = T extends LogLevel ? T : never;
+export type GetLogType<T> = CheckIsLogLevel<T extends LogDefinition ? T['level'] : T>;
+export type GetEvents<T extends any[]> = T extends Array<LogLevel | LogDefinition> ? GetLogType<T[number]> : never;
+export type QueryEvent = {
+    timestamp: Date;
+    query: string;
+    params: string;
+    duration: number;
+    target: string;
+};
+export type LogEvent = {
+    timestamp: Date;
+    message: string;
+    target: string;
+};
+export type PrismaAction = 'findUnique' | 'findUniqueOrThrow' | 'findMany' | 'findFirst' | 'findFirstOrThrow' | 'create' | 'createMany' | 'createManyAndReturn' | 'update' | 'updateMany' | 'updateManyAndReturn' | 'upsert' | 'delete' | 'deleteMany' | 'executeRaw' | 'queryRaw' | 'aggregate' | 'count' | 'runCommandRaw' | 'findRaw' | 'groupBy';
+/**
+ * `PrismaClient` proxy available in interactive transactions.
+ */
+export type TransactionClient = Omit<DefaultPrismaClient, runtime.ITXClientDenyList>;
+//# sourceMappingURL=prismaNamespace.d.ts.map