@sagebox-be/prisma-product 0.0.8 → 0.0.10

package/prisma/client/index.d.ts

@@ -236,6 +236,11 @@ export type AttributeValue = $Result.DefaultSelection<Prisma.$AttributeValuePayl
  * 
  */
 export type Sku = $Result.DefaultSelection<Prisma.$SkuPayload>
+/**
+ * Model ProductHistory
+ * 
+ */
+export type ProductHistory = $Result.DefaultSelection<Prisma.$ProductHistoryPayload>
 
 /**
  * ##  Prisma Client ʲˢ
@@ -434,6 +439,16 @@ export class PrismaClient<
     * ```
     */
   get sku(): Prisma.SkuDelegate<ExtArgs, ClientOptions>;
+
+  /**
+   * `prisma.productHistory`: Exposes CRUD operations for the **ProductHistory** model.
+    * Example usage:
+    * ```ts
+    * // Fetch zero or more ProductHistories
+    * const productHistories = await prisma.productHistory.findMany()
+    * ```
+    */
+  get productHistory(): Prisma.ProductHistoryDelegate<ExtArgs, ClientOptions>;
 }
 
 export namespace Prisma {
@@ -881,7 +896,8 @@ export namespace Prisma {
     ProductSyncOutbox: 'ProductSyncOutbox',
     InventoryOutbox: 'InventoryOutbox',
     AttributeValue: 'AttributeValue',
-    Sku: 'Sku'
+    Sku: 'Sku',
+    ProductHistory: 'ProductHistory'
   };
 
   export type ModelName = (typeof ModelName)[keyof typeof ModelName]
@@ -900,7 +916,7 @@ export namespace Prisma {
       omit: GlobalOmitOptions
     }
     meta: {
-      modelProps: "attribute" | "category" | "brand" | "product" | "productSyncOutbox" | "inventoryOutbox" | "attributeValue" | "sku"
+      modelProps: "attribute" | "category" | "brand" | "product" | "productSyncOutbox" | "inventoryOutbox" | "attributeValue" | "sku" | "productHistory"
       txIsolationLevel: Prisma.TransactionIsolationLevel
     }
     model: {
@@ -1496,6 +1512,80 @@ export namespace Prisma {
           }
         }
       }
+      ProductHistory: {
+        payload: Prisma.$ProductHistoryPayload<ExtArgs>
+        fields: Prisma.ProductHistoryFieldRefs
+        operations: {
+          findUnique: {
+            args: Prisma.ProductHistoryFindUniqueArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$ProductHistoryPayload> | null
+          }
+          findUniqueOrThrow: {
+            args: Prisma.ProductHistoryFindUniqueOrThrowArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$ProductHistoryPayload>
+          }
+          findFirst: {
+            args: Prisma.ProductHistoryFindFirstArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$ProductHistoryPayload> | null
+          }
+          findFirstOrThrow: {
+            args: Prisma.ProductHistoryFindFirstOrThrowArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$ProductHistoryPayload>
+          }
+          findMany: {
+            args: Prisma.ProductHistoryFindManyArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$ProductHistoryPayload>[]
+          }
+          create: {
+            args: Prisma.ProductHistoryCreateArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$ProductHistoryPayload>
+          }
+          createMany: {
+            args: Prisma.ProductHistoryCreateManyArgs<ExtArgs>
+            result: BatchPayload
+          }
+          createManyAndReturn: {
+            args: Prisma.ProductHistoryCreateManyAndReturnArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$ProductHistoryPayload>[]
+          }
+          delete: {
+            args: Prisma.ProductHistoryDeleteArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$ProductHistoryPayload>
+          }
+          update: {
+            args: Prisma.ProductHistoryUpdateArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$ProductHistoryPayload>
+          }
+          deleteMany: {
+            args: Prisma.ProductHistoryDeleteManyArgs<ExtArgs>
+            result: BatchPayload
+          }
+          updateMany: {
+            args: Prisma.ProductHistoryUpdateManyArgs<ExtArgs>
+            result: BatchPayload
+          }
+          updateManyAndReturn: {
+            args: Prisma.ProductHistoryUpdateManyAndReturnArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$ProductHistoryPayload>[]
+          }
+          upsert: {
+            args: Prisma.ProductHistoryUpsertArgs<ExtArgs>
+            result: $Utils.PayloadToResult<Prisma.$ProductHistoryPayload>
+          }
+          aggregate: {
+            args: Prisma.ProductHistoryAggregateArgs<ExtArgs>
+            result: $Utils.Optional<AggregateProductHistory>
+          }
+          groupBy: {
+            args: Prisma.ProductHistoryGroupByArgs<ExtArgs>
+            result: $Utils.Optional<ProductHistoryGroupByOutputType>[]
+          }
+          count: {
+            args: Prisma.ProductHistoryCountArgs<ExtArgs>
+            result: $Utils.Optional<ProductHistoryCountAggregateOutputType> | number
+          }
+        }
+      }
     }
   } & {
     other: {
@@ -1600,6 +1690,7 @@ export namespace Prisma {
     inventoryOutbox?: InventoryOutboxOmit
     attributeValue?: AttributeValueOmit
     sku?: SkuOmit
+    productHistory?: ProductHistoryOmit
   }
 
   /* Types for Logging */
@@ -11025,134 +11116,1153 @@ export namespace Prisma {
 
 
   /**
-   * Enums
+   * Model ProductHistory
    */
 
-  export const TransactionIsolationLevel: {
-    ReadUncommitted: 'ReadUncommitted',
-    ReadCommitted: 'ReadCommitted',
-    RepeatableRead: 'RepeatableRead',
-    Serializable: 'Serializable'
-  };
-
-  export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel]
-
+  export type AggregateProductHistory = {
+    _count: ProductHistoryCountAggregateOutputType | null
+    _min: ProductHistoryMinAggregateOutputType | null
+    _max: ProductHistoryMaxAggregateOutputType | null
+  }
 
-  export const AttributeScalarFieldEnum: {
-    id: 'id',
-    name: 'name',
-    productId: 'productId',
-    order: 'order',
-    createdAt: 'createdAt',
-    updatedAt: 'updatedAt'
-  };
+  export type ProductHistoryMinAggregateOutputType = {
+    id: string | null
+    productId: string | null
+    changeType: string | null
+    changedBy: string | null
+    createdAt: Date | null
+  }
 
-  export type AttributeScalarFieldEnum = (typeof AttributeScalarFieldEnum)[keyof typeof AttributeScalarFieldEnum]
+  export type ProductHistoryMaxAggregateOutputType = {
+    id: string | null
+    productId: string | null
+    changeType: string | null
+    changedBy: string | null
+    createdAt: Date | null
+  }
 
+  export type ProductHistoryCountAggregateOutputType = {
+    id: number
+    productId: number
+    changeType: number
+    changedBy: number
+    snapshot: number
+    createdAt: number
+    _all: number
+  }
 
-  export const CategoryScalarFieldEnum: {
-    id: 'id',
-    key: 'key',
-    name: 'name',
-    priority: 'priority',
-    parentId: 'parentId',
-    primary: 'primary',
-    createdAt: 'createdAt',
-    updatedAt: 'updatedAt'
-  };
 
-  export type CategoryScalarFieldEnum = (typeof CategoryScalarFieldEnum)[keyof typeof CategoryScalarFieldEnum]
+  export type ProductHistoryMinAggregateInputType = {
+    id?: true
+    productId?: true
+    changeType?: true
+    changedBy?: true
+    createdAt?: true
+  }
 
+  export type ProductHistoryMaxAggregateInputType = {
+    id?: true
+    productId?: true
+    changeType?: true
+    changedBy?: true
+    createdAt?: true
+  }
 
-  export const BrandScalarFieldEnum: {
-    id: 'id',
-    code: 'code',
-    name: 'name',
-    createdAt: 'createdAt',
-    updatedAt: 'updatedAt'
-  };
+  export type ProductHistoryCountAggregateInputType = {
+    id?: true
+    productId?: true
+    changeType?: true
+    changedBy?: true
+    snapshot?: true
+    createdAt?: true
+    _all?: true
+  }
 
-  export type BrandScalarFieldEnum = (typeof BrandScalarFieldEnum)[keyof typeof BrandScalarFieldEnum]
+  export type ProductHistoryAggregateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Filter which ProductHistory to aggregate.
+     */
+    where?: ProductHistoryWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of ProductHistories to fetch.
+     */
+    orderBy?: ProductHistoryOrderByWithRelationInput | ProductHistoryOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the start position
+     */
+    cursor?: ProductHistoryWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` ProductHistories from the position of the cursor.
+     */
+    take?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Skip the first `n` ProductHistories.
+     */
+    skip?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Count returned ProductHistories
+    **/
+    _count?: true | ProductHistoryCountAggregateInputType
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Select which fields to find the minimum value
+    **/
+    _min?: ProductHistoryMinAggregateInputType
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs}
+     * 
+     * Select which fields to find the maximum value
+    **/
+    _max?: ProductHistoryMaxAggregateInputType
+  }
 
+  export type GetProductHistoryAggregateType<T extends ProductHistoryAggregateArgs> = {
+        [P in keyof T & keyof AggregateProductHistory]: P extends '_count' | 'count'
+      ? T[P] extends true
+        ? number
+        : GetScalarType<T[P], AggregateProductHistory[P]>
+      : GetScalarType<T[P], AggregateProductHistory[P]>
+  }
 
-  export const ProductScalarFieldEnum: {
-    id: 'id',
-    name: 'name',
-    brandId: 'brandId',
-    description: 'description',
-    keywords: 'keywords',
-    categoryId: 'categoryId',
-    viewedCount: 'viewedCount',
-    status: 'status',
-    media: 'media',
-    createdAt: 'createdAt',
-    updatedAt: 'updatedAt'
-  };
 
-  export type ProductScalarFieldEnum = (typeof ProductScalarFieldEnum)[keyof typeof ProductScalarFieldEnum]
 
 
-  export const ProductSyncOutboxScalarFieldEnum: {
-    id: 'id',
-    publishStatus: 'publishStatus',
-    publishRetryCount: 'publishRetryCount',
-    publishError: 'publishError',
-    publishedAt: 'publishedAt',
-    esSyncStatus: 'esSyncStatus',
-    esRetryCount: 'esRetryCount',
-    esSyncedAt: 'esSyncedAt',
-    esSyncError: 'esSyncError',
-    payload: 'payload',
-    createdAt: 'createdAt',
-    updatedAt: 'updatedAt'
-  };
+  export type ProductHistoryGroupByArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    where?: ProductHistoryWhereInput
+    orderBy?: ProductHistoryOrderByWithAggregationInput | ProductHistoryOrderByWithAggregationInput[]
+    by: ProductHistoryScalarFieldEnum[] | ProductHistoryScalarFieldEnum
+    having?: ProductHistoryScalarWhereWithAggregatesInput
+    take?: number
+    skip?: number
+    _count?: ProductHistoryCountAggregateInputType | true
+    _min?: ProductHistoryMinAggregateInputType
+    _max?: ProductHistoryMaxAggregateInputType
+  }
 
-  export type ProductSyncOutboxScalarFieldEnum = (typeof ProductSyncOutboxScalarFieldEnum)[keyof typeof ProductSyncOutboxScalarFieldEnum]
+  export type ProductHistoryGroupByOutputType = {
+    id: string
+    productId: string
+    changeType: string
+    changedBy: string | null
+    snapshot:PrismaJson.PrismaProductEntityPopulated
+    createdAt: Date
+    _count: ProductHistoryCountAggregateOutputType | null
+    _min: ProductHistoryMinAggregateOutputType | null
+    _max: ProductHistoryMaxAggregateOutputType | null
+  }
 
+  type GetProductHistoryGroupByPayload<T extends ProductHistoryGroupByArgs> = Prisma.PrismaPromise<
+    Array<
+      PickEnumerable<ProductHistoryGroupByOutputType, T['by']> &
+        {
+          [P in ((keyof T) & (keyof ProductHistoryGroupByOutputType))]: P extends '_count'
+            ? T[P] extends boolean
+              ? number
+              : GetScalarType<T[P], ProductHistoryGroupByOutputType[P]>
+            : GetScalarType<T[P], ProductHistoryGroupByOutputType[P]>
+        }
+      >
+    >
 
-  export const InventoryOutboxScalarFieldEnum: {
-    id: 'id',
-    publishStatus: 'publishStatus',
-    publishRetryCount: 'publishRetryCount',
-    publishError: 'publishError',
-    publishedAt: 'publishedAt',
-    payload: 'payload',
-    createdAt: 'createdAt',
-    updatedAt: 'updatedAt'
-  };
 
-  export type InventoryOutboxScalarFieldEnum = (typeof InventoryOutboxScalarFieldEnum)[keyof typeof InventoryOutboxScalarFieldEnum]
+  export type ProductHistorySelect<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
+    id?: boolean
+    productId?: boolean
+    changeType?: boolean
+    changedBy?: boolean
+    snapshot?: boolean
+    createdAt?: boolean
+  }, ExtArgs["result"]["productHistory"]>
 
+  export type ProductHistorySelectCreateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
+    id?: boolean
+    productId?: boolean
+    changeType?: boolean
+    changedBy?: boolean
+    snapshot?: boolean
+    createdAt?: boolean
+  }, ExtArgs["result"]["productHistory"]>
 
-  export const AttributeValueScalarFieldEnum: {
-    id: 'id',
-    skuId: 'skuId',
-    attrId: 'attrId',
-    value: 'value',
-    order: 'order',
-    createdAt: 'createdAt',
-    updatedAt: 'updatedAt'
-  };
+  export type ProductHistorySelectUpdateManyAndReturn<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetSelect<{
+    id?: boolean
+    productId?: boolean
+    changeType?: boolean
+    changedBy?: boolean
+    snapshot?: boolean
+    createdAt?: boolean
+  }, ExtArgs["result"]["productHistory"]>
 
-  export type AttributeValueScalarFieldEnum = (typeof AttributeValueScalarFieldEnum)[keyof typeof AttributeValueScalarFieldEnum]
+  export type ProductHistorySelectScalar = {
+    id?: boolean
+    productId?: boolean
+    changeType?: boolean
+    changedBy?: boolean
+    snapshot?: boolean
+    createdAt?: boolean
+  }
 
+  export type ProductHistoryOmit<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = $Extensions.GetOmit<"id" | "productId" | "changeType" | "changedBy" | "snapshot" | "createdAt", ExtArgs["result"]["productHistory"]>
 
-  export const SkuScalarFieldEnum: {
-    id: 'id',
-    skuNo: 'skuNo',
-    productId: 'productId',
-    price: 'price',
-    width: 'width',
-    height: 'height',
-    length: 'length',
-    weight: 'weight',
-    media: 'media',
-    inactive: 'inactive',
-    createdAt: 'createdAt',
-    updatedAt: 'updatedAt'
-  };
+  export type $ProductHistoryPayload<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    name: "ProductHistory"
+    objects: {}
+    scalars: $Extensions.GetPayloadResult<{
+      id: string
+      productId: string
+      changeType: string
+      changedBy: string | null
+      /**
+       * [PrismaProductEntityPopulated]
+       */
+      snapshot:PrismaJson.PrismaProductEntityPopulated
+      createdAt: Date
+    }, ExtArgs["result"]["productHistory"]>
+    composites: {}
+  }
 
-  export type SkuScalarFieldEnum = (typeof SkuScalarFieldEnum)[keyof typeof SkuScalarFieldEnum]
+  type ProductHistoryGetPayload<S extends boolean | null | undefined | ProductHistoryDefaultArgs> = $Result.GetResult<Prisma.$ProductHistoryPayload, S>
+
+  type ProductHistoryCountArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> =
+    Omit<ProductHistoryFindManyArgs, 'select' | 'include' | 'distinct' | 'omit'> & {
+      select?: ProductHistoryCountAggregateInputType | true
+    }
+
+  export interface ProductHistoryDelegate<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> {
+    [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['model']['ProductHistory'], meta: { name: 'ProductHistory' } }
+    /**
+     * Find zero or one ProductHistory that matches the filter.
+     * @param {ProductHistoryFindUniqueArgs} args - Arguments to find a ProductHistory
+     * @example
+     * // Get one ProductHistory
+     * const productHistory = await prisma.productHistory.findUnique({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findUnique<T extends ProductHistoryFindUniqueArgs>(args: SelectSubset<T, ProductHistoryFindUniqueArgs<ExtArgs>>): Prisma__ProductHistoryClient<$Result.GetResult<Prisma.$ProductHistoryPayload<ExtArgs>, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Find one ProductHistory that matches the filter or throw an error with `error.code='P2025'`
+     * if no matches were found.
+     * @param {ProductHistoryFindUniqueOrThrowArgs} args - Arguments to find a ProductHistory
+     * @example
+     * // Get one ProductHistory
+     * const productHistory = await prisma.productHistory.findUniqueOrThrow({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findUniqueOrThrow<T extends ProductHistoryFindUniqueOrThrowArgs>(args: SelectSubset<T, ProductHistoryFindUniqueOrThrowArgs<ExtArgs>>): Prisma__ProductHistoryClient<$Result.GetResult<Prisma.$ProductHistoryPayload<ExtArgs>, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Find the first ProductHistory that matches the filter.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {ProductHistoryFindFirstArgs} args - Arguments to find a ProductHistory
+     * @example
+     * // Get one ProductHistory
+     * const productHistory = await prisma.productHistory.findFirst({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findFirst<T extends ProductHistoryFindFirstArgs>(args?: SelectSubset<T, ProductHistoryFindFirstArgs<ExtArgs>>): Prisma__ProductHistoryClient<$Result.GetResult<Prisma.$ProductHistoryPayload<ExtArgs>, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Find the first ProductHistory that matches the filter or
+     * throw `PrismaKnownClientError` with `P2025` code if no matches were found.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {ProductHistoryFindFirstOrThrowArgs} args - Arguments to find a ProductHistory
+     * @example
+     * // Get one ProductHistory
+     * const productHistory = await prisma.productHistory.findFirstOrThrow({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     */
+    findFirstOrThrow<T extends ProductHistoryFindFirstOrThrowArgs>(args?: SelectSubset<T, ProductHistoryFindFirstOrThrowArgs<ExtArgs>>): Prisma__ProductHistoryClient<$Result.GetResult<Prisma.$ProductHistoryPayload<ExtArgs>, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Find zero or more ProductHistories that matches the filter.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {ProductHistoryFindManyArgs} args - Arguments to filter and select certain fields only.
+     * @example
+     * // Get all ProductHistories
+     * const productHistories = await prisma.productHistory.findMany()
+     * 
+     * // Get first 10 ProductHistories
+     * const productHistories = await prisma.productHistory.findMany({ take: 10 })
+     * 
+     * // Only select the `id`
+     * const productHistoryWithIdOnly = await prisma.productHistory.findMany({ select: { id: true } })
+     * 
+     */
+    findMany<T extends ProductHistoryFindManyArgs>(args?: SelectSubset<T, ProductHistoryFindManyArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ProductHistoryPayload<ExtArgs>, T, "findMany", GlobalOmitOptions>>
+
+    /**
+     * Create a ProductHistory.
+     * @param {ProductHistoryCreateArgs} args - Arguments to create a ProductHistory.
+     * @example
+     * // Create one ProductHistory
+     * const ProductHistory = await prisma.productHistory.create({
+     *   data: {
+     *     // ... data to create a ProductHistory
+     *   }
+     * })
+     * 
+     */
+    create<T extends ProductHistoryCreateArgs>(args: SelectSubset<T, ProductHistoryCreateArgs<ExtArgs>>): Prisma__ProductHistoryClient<$Result.GetResult<Prisma.$ProductHistoryPayload<ExtArgs>, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Create many ProductHistories.
+     * @param {ProductHistoryCreateManyArgs} args - Arguments to create many ProductHistories.
+     * @example
+     * // Create many ProductHistories
+     * const productHistory = await prisma.productHistory.createMany({
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     *     
+     */
+    createMany<T extends ProductHistoryCreateManyArgs>(args?: SelectSubset<T, ProductHistoryCreateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+
+    /**
+     * Create many ProductHistories and returns the data saved in the database.
+     * @param {ProductHistoryCreateManyAndReturnArgs} args - Arguments to create many ProductHistories.
+     * @example
+     * // Create many ProductHistories
+     * const productHistory = await prisma.productHistory.createManyAndReturn({
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     * 
+     * // Create many ProductHistories and only return the `id`
+     * const productHistoryWithIdOnly = await prisma.productHistory.createManyAndReturn({
+     *   select: { id: true },
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * 
+     */
+    createManyAndReturn<T extends ProductHistoryCreateManyAndReturnArgs>(args?: SelectSubset<T, ProductHistoryCreateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ProductHistoryPayload<ExtArgs>, T, "createManyAndReturn", GlobalOmitOptions>>
+
+    /**
+     * Delete a ProductHistory.
+     * @param {ProductHistoryDeleteArgs} args - Arguments to delete one ProductHistory.
+     * @example
+     * // Delete one ProductHistory
+     * const ProductHistory = await prisma.productHistory.delete({
+     *   where: {
+     *     // ... filter to delete one ProductHistory
+     *   }
+     * })
+     * 
+     */
+    delete<T extends ProductHistoryDeleteArgs>(args: SelectSubset<T, ProductHistoryDeleteArgs<ExtArgs>>): Prisma__ProductHistoryClient<$Result.GetResult<Prisma.$ProductHistoryPayload<ExtArgs>, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Update one ProductHistory.
+     * @param {ProductHistoryUpdateArgs} args - Arguments to update one ProductHistory.
+     * @example
+     * // Update one ProductHistory
+     * const productHistory = await prisma.productHistory.update({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: {
+     *     // ... provide data here
+     *   }
+     * })
+     * 
+     */
+    update<T extends ProductHistoryUpdateArgs>(args: SelectSubset<T, ProductHistoryUpdateArgs<ExtArgs>>): Prisma__ProductHistoryClient<$Result.GetResult<Prisma.$ProductHistoryPayload<ExtArgs>, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+    /**
+     * Delete zero or more ProductHistories.
+     * @param {ProductHistoryDeleteManyArgs} args - Arguments to filter ProductHistories to delete.
+     * @example
+     * // Delete a few ProductHistories
+     * const { count } = await prisma.productHistory.deleteMany({
+     *   where: {
+     *     // ... provide filter here
+     *   }
+     * })
+     * 
+     */
+    deleteMany<T extends ProductHistoryDeleteManyArgs>(args?: SelectSubset<T, ProductHistoryDeleteManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+
+    /**
+     * Update zero or more ProductHistories.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {ProductHistoryUpdateManyArgs} args - Arguments to update one or more rows.
+     * @example
+     * // Update many ProductHistories
+     * const productHistory = await prisma.productHistory.updateMany({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: {
+     *     // ... provide data here
+     *   }
+     * })
+     * 
+     */
+    updateMany<T extends ProductHistoryUpdateManyArgs>(args: SelectSubset<T, ProductHistoryUpdateManyArgs<ExtArgs>>): Prisma.PrismaPromise<BatchPayload>
+
+    /**
+     * Update zero or more ProductHistories and returns the data updated in the database.
+     * @param {ProductHistoryUpdateManyAndReturnArgs} args - Arguments to update many ProductHistories.
+     * @example
+     * // Update many ProductHistories
+     * const productHistory = await prisma.productHistory.updateManyAndReturn({
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     * 
+     * // Update zero or more ProductHistories and only return the `id`
+     * const productHistoryWithIdOnly = await prisma.productHistory.updateManyAndReturn({
+     *   select: { id: true },
+     *   where: {
+     *     // ... provide filter here
+     *   },
+     *   data: [
+     *     // ... provide data here
+     *   ]
+     * })
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * 
+     */
+    updateManyAndReturn<T extends ProductHistoryUpdateManyAndReturnArgs>(args: SelectSubset<T, ProductHistoryUpdateManyAndReturnArgs<ExtArgs>>): Prisma.PrismaPromise<$Result.GetResult<Prisma.$ProductHistoryPayload<ExtArgs>, T, "updateManyAndReturn", GlobalOmitOptions>>
+
+    /**
+     * Create or update one ProductHistory.
+     * @param {ProductHistoryUpsertArgs} args - Arguments to update or create a ProductHistory.
+     * @example
+     * // Update or create a ProductHistory
+     * const productHistory = await prisma.productHistory.upsert({
+     *   create: {
+     *     // ... data to create a ProductHistory
+     *   },
+     *   update: {
+     *     // ... in case it already exists, update
+     *   },
+     *   where: {
+     *     // ... the filter for the ProductHistory we want to update
+     *   }
+     * })
+     */
+    upsert<T extends ProductHistoryUpsertArgs>(args: SelectSubset<T, ProductHistoryUpsertArgs<ExtArgs>>): Prisma__ProductHistoryClient<$Result.GetResult<Prisma.$ProductHistoryPayload<ExtArgs>, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions>
+
+
+    /**
+     * Count the number of ProductHistories.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {ProductHistoryCountArgs} args - Arguments to filter ProductHistories to count.
+     * @example
+     * // Count the number of ProductHistories
+     * const count = await prisma.productHistory.count({
+     *   where: {
+     *     // ... the filter for the ProductHistories we want to count
+     *   }
+     * })
+    **/
+    count<T extends ProductHistoryCountArgs>(
+      args?: Subset<T, ProductHistoryCountArgs>,
+    ): Prisma.PrismaPromise<
+      T extends $Utils.Record<'select', any>
+        ? T['select'] extends true
+          ? number
+          : GetScalarType<T['select'], ProductHistoryCountAggregateOutputType>
+        : number
+    >
+
+    /**
+     * Allows you to perform aggregations operations on a ProductHistory.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {ProductHistoryAggregateArgs} args - Select which aggregations you would like to apply and on what fields.
+     * @example
+     * // Ordered by age ascending
+     * // Where email contains prisma.io
+     * // Limited to the 10 users
+     * const aggregations = await prisma.user.aggregate({
+     *   _avg: {
+     *     age: true,
+     *   },
+     *   where: {
+     *     email: {
+     *       contains: "prisma.io",
+     *     },
+     *   },
+     *   orderBy: {
+     *     age: "asc",
+     *   },
+     *   take: 10,
+     * })
+    **/
+    aggregate<T extends ProductHistoryAggregateArgs>(args: Subset<T, ProductHistoryAggregateArgs>): Prisma.PrismaPromise<GetProductHistoryAggregateType<T>>
+
+    /**
+     * Group by ProductHistory.
+     * Note, that providing `undefined` is treated as the value not being there.
+     * Read more here: https://pris.ly/d/null-undefined
+     * @param {ProductHistoryGroupByArgs} args - Group by arguments.
+     * @example
+     * // Group by city, order by createdAt, get count
+     * const result = await prisma.user.groupBy({
+     *   by: ['city', 'createdAt'],
+     *   orderBy: {
+     *     createdAt: true
+     *   },
+     *   _count: {
+     *     _all: true
+     *   },
+     * })
+     * 
+    **/
+    groupBy<
+      T extends ProductHistoryGroupByArgs,
+      HasSelectOrTake extends Or<
+        Extends<'skip', Keys<T>>,
+        Extends<'take', Keys<T>>
+      >,
+      OrderByArg extends True extends HasSelectOrTake
+        ? { orderBy: ProductHistoryGroupByArgs['orderBy'] }
+        : { orderBy?: ProductHistoryGroupByArgs['orderBy'] },
+      OrderFields extends ExcludeUnderscoreKeys<Keys<MaybeTupleToUnion<T['orderBy']>>>,
+      ByFields extends MaybeTupleToUnion<T['by']>,
+      ByValid extends Has<ByFields, OrderFields>,
+      HavingFields extends GetHavingFields<T['having']>,
+      HavingValid extends Has<ByFields, HavingFields>,
+      ByEmpty extends T['by'] extends never[] ? True : False,
+      InputErrors extends ByEmpty extends True
+      ? `Error: "by" must not be empty.`
+      : HavingValid extends False
+      ? {
+          [P in HavingFields]: P extends ByFields
+            ? never
+            : P extends string
+            ? `Error: Field "${P}" used in "having" needs to be provided in "by".`
+            : [
+                Error,
+                'Field ',
+                P,
+                ` in "having" needs to be provided in "by"`,
+              ]
+        }[HavingFields]
+      : 'take' extends Keys<T>
+      ? 'orderBy' extends Keys<T>
+        ? ByValid extends True
+          ? {}
+          : {
+              [P in OrderFields]: P extends ByFields
+                ? never
+                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+            }[OrderFields]
+        : 'Error: If you provide "take", you also need to provide "orderBy"'
+      : 'skip' extends Keys<T>
+      ? 'orderBy' extends Keys<T>
+        ? ByValid extends True
+          ? {}
+          : {
+              [P in OrderFields]: P extends ByFields
+                ? never
+                : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+            }[OrderFields]
+        : 'Error: If you provide "skip", you also need to provide "orderBy"'
+      : ByValid extends True
+      ? {}
+      : {
+          [P in OrderFields]: P extends ByFields
+            ? never
+            : `Error: Field "${P}" in "orderBy" needs to be provided in "by"`
+        }[OrderFields]
+    >(args: SubsetIntersection<T, ProductHistoryGroupByArgs, OrderByArg> & InputErrors): {} extends InputErrors ? GetProductHistoryGroupByPayload<T> : Prisma.PrismaPromise<InputErrors>
+  /**
+   * Fields of the ProductHistory model
+   */
+  readonly fields: ProductHistoryFieldRefs;
+  }
+
+  /**
+   * The delegate class that acts as a "Promise-like" for ProductHistory.
+   * Why is this prefixed with `Prisma__`?
+   * Because we want to prevent naming conflicts as mentioned in
+   * https://github.com/prisma/prisma-client-js/issues/707
+   */
+  export interface Prisma__ProductHistoryClient<T, Null = never, ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs, GlobalOmitOptions = {}> extends Prisma.PrismaPromise<T> {
+    readonly [Symbol.toStringTag]: "PrismaPromise"
+    /**
+     * Attaches callbacks for the resolution and/or rejection of the Promise.
+     * @param onfulfilled The callback to execute when the Promise is resolved.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of which ever callback is executed.
+     */
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): $Utils.JsPromise<TResult1 | TResult2>
+    /**
+     * Attaches a callback for only the rejection of the Promise.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of the callback.
+     */
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): $Utils.JsPromise<T | TResult>
+    /**
+     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+     * resolved value cannot be modified from the callback.
+     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+     * @returns A Promise for the completion of the callback.
+     */
+    finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise<T>
+  }
+
+
+
+
+  /**
+   * Fields of the ProductHistory model
+   */
+  interface ProductHistoryFieldRefs {
+    readonly id: FieldRef<"ProductHistory", 'String'>
+    readonly productId: FieldRef<"ProductHistory", 'String'>
+    readonly changeType: FieldRef<"ProductHistory", 'String'>
+    readonly changedBy: FieldRef<"ProductHistory", 'String'>
+    readonly snapshot: FieldRef<"ProductHistory", 'Json'>
+    readonly createdAt: FieldRef<"ProductHistory", 'DateTime'>
+  }
+    
+
+  // Custom InputTypes
+  /**
+   * ProductHistory findUnique
+   */
+  export type ProductHistoryFindUniqueArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the ProductHistory
+     */
+    select?: ProductHistorySelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the ProductHistory
+     */
+    omit?: ProductHistoryOmit<ExtArgs> | null
+    /**
+     * Filter, which ProductHistory to fetch.
+     */
+    where: ProductHistoryWhereUniqueInput
+  }
+
+  /**
+   * ProductHistory findUniqueOrThrow
+   */
+  export type ProductHistoryFindUniqueOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the ProductHistory
+     */
+    select?: ProductHistorySelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the ProductHistory
+     */
+    omit?: ProductHistoryOmit<ExtArgs> | null
+    /**
+     * Filter, which ProductHistory to fetch.
+     */
+    where: ProductHistoryWhereUniqueInput
+  }
+
+  /**
+   * ProductHistory findFirst
+   */
+  export type ProductHistoryFindFirstArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the ProductHistory
+     */
+    select?: ProductHistorySelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the ProductHistory
+     */
+    omit?: ProductHistoryOmit<ExtArgs> | null
+    /**
+     * Filter, which ProductHistory to fetch.
+     */
+    where?: ProductHistoryWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of ProductHistories to fetch.
+     */
+    orderBy?: ProductHistoryOrderByWithRelationInput | ProductHistoryOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the position for searching for ProductHistories.
+     */
+    cursor?: ProductHistoryWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` ProductHistories from the position of the cursor.
+     */
+    take?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Skip the first `n` ProductHistories.
+     */
+    skip?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+     * 
+     * Filter by unique combinations of ProductHistories.
+     */
+    distinct?: ProductHistoryScalarFieldEnum | ProductHistoryScalarFieldEnum[]
+  }
+
+  /**
+   * ProductHistory findFirstOrThrow
+   */
+  export type ProductHistoryFindFirstOrThrowArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the ProductHistory
+     */
+    select?: ProductHistorySelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the ProductHistory
+     */
+    omit?: ProductHistoryOmit<ExtArgs> | null
+    /**
+     * Filter, which ProductHistory to fetch.
+     */
+    where?: ProductHistoryWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of ProductHistories to fetch.
+     */
+    orderBy?: ProductHistoryOrderByWithRelationInput | ProductHistoryOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the position for searching for ProductHistories.
+     */
+    cursor?: ProductHistoryWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` ProductHistories from the position of the cursor.
+     */
+    take?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Skip the first `n` ProductHistories.
+     */
+    skip?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs}
+     * 
+     * Filter by unique combinations of ProductHistories.
+     */
+    distinct?: ProductHistoryScalarFieldEnum | ProductHistoryScalarFieldEnum[]
+  }
+
+  /**
+   * ProductHistory findMany
+   */
+  export type ProductHistoryFindManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the ProductHistory
+     */
+    select?: ProductHistorySelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the ProductHistory
+     */
+    omit?: ProductHistoryOmit<ExtArgs> | null
+    /**
+     * Filter, which ProductHistories to fetch.
+     */
+    where?: ProductHistoryWhereInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs}
+     * 
+     * Determine the order of ProductHistories to fetch.
+     */
+    orderBy?: ProductHistoryOrderByWithRelationInput | ProductHistoryOrderByWithRelationInput[]
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}
+     * 
+     * Sets the position for listing ProductHistories.
+     */
+    cursor?: ProductHistoryWhereUniqueInput
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Take `±n` ProductHistories from the position of the cursor.
+     */
+    take?: number
+    /**
+     * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}
+     * 
+     * Skip the first `n` ProductHistories.
+     */
+    skip?: number
+    distinct?: ProductHistoryScalarFieldEnum | ProductHistoryScalarFieldEnum[]
+  }
+
+  /**
+   * ProductHistory create
+   */
+  export type ProductHistoryCreateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the ProductHistory
+     */
+    select?: ProductHistorySelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the ProductHistory
+     */
+    omit?: ProductHistoryOmit<ExtArgs> | null
+    /**
+     * The data needed to create a ProductHistory.
+     */
+    data: XOR<ProductHistoryCreateInput, ProductHistoryUncheckedCreateInput>
+  }
+
+  /**
+   * ProductHistory createMany
+   */
+  export type ProductHistoryCreateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * The data used to create many ProductHistories.
+     */
+    data: ProductHistoryCreateManyInput | ProductHistoryCreateManyInput[]
+    skipDuplicates?: boolean
+  }
+
+  /**
+   * ProductHistory createManyAndReturn
+   */
+  export type ProductHistoryCreateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the ProductHistory
+     */
+    select?: ProductHistorySelectCreateManyAndReturn<ExtArgs> | null
+    /**
+     * Omit specific fields from the ProductHistory
+     */
+    omit?: ProductHistoryOmit<ExtArgs> | null
+    /**
+     * The data used to create many ProductHistories.
+     */
+    data: ProductHistoryCreateManyInput | ProductHistoryCreateManyInput[]
+    skipDuplicates?: boolean
+  }
+
+  /**
+   * ProductHistory update
+   */
+  export type ProductHistoryUpdateArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the ProductHistory
+     */
+    select?: ProductHistorySelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the ProductHistory
+     */
+    omit?: ProductHistoryOmit<ExtArgs> | null
+    /**
+     * The data needed to update a ProductHistory.
+     */
+    data: XOR<ProductHistoryUpdateInput, ProductHistoryUncheckedUpdateInput>
+    /**
+     * Choose, which ProductHistory to update.
+     */
+    where: ProductHistoryWhereUniqueInput
+  }
+
+  /**
+   * ProductHistory updateMany
+   */
+  export type ProductHistoryUpdateManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * The data used to update ProductHistories.
+     */
+    data: XOR<ProductHistoryUpdateManyMutationInput, ProductHistoryUncheckedUpdateManyInput>
+    /**
+     * Filter which ProductHistories to update
+     */
+    where?: ProductHistoryWhereInput
+    /**
+     * Limit how many ProductHistories to update.
+     */
+    limit?: number
+  }
+
+  /**
+   * ProductHistory updateManyAndReturn
+   */
+  export type ProductHistoryUpdateManyAndReturnArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the ProductHistory
+     */
+    select?: ProductHistorySelectUpdateManyAndReturn<ExtArgs> | null
+    /**
+     * Omit specific fields from the ProductHistory
+     */
+    omit?: ProductHistoryOmit<ExtArgs> | null
+    /**
+     * The data used to update ProductHistories.
+     */
+    data: XOR<ProductHistoryUpdateManyMutationInput, ProductHistoryUncheckedUpdateManyInput>
+    /**
+     * Filter which ProductHistories to update
+     */
+    where?: ProductHistoryWhereInput
+    /**
+     * Limit how many ProductHistories to update.
+     */
+    limit?: number
+  }
+
+  /**
+   * ProductHistory upsert
+   */
+  export type ProductHistoryUpsertArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the ProductHistory
+     */
+    select?: ProductHistorySelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the ProductHistory
+     */
+    omit?: ProductHistoryOmit<ExtArgs> | null
+    /**
+     * The filter to search for the ProductHistory to update in case it exists.
+     */
+    where: ProductHistoryWhereUniqueInput
+    /**
+     * In case the ProductHistory found by the `where` argument doesn't exist, create a new ProductHistory with this data.
+     */
+    create: XOR<ProductHistoryCreateInput, ProductHistoryUncheckedCreateInput>
+    /**
+     * In case the ProductHistory was found with the provided `where` argument, update it with this data.
+     */
+    update: XOR<ProductHistoryUpdateInput, ProductHistoryUncheckedUpdateInput>
+  }
+
+  /**
+   * ProductHistory delete
+   */
+  export type ProductHistoryDeleteArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the ProductHistory
+     */
+    select?: ProductHistorySelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the ProductHistory
+     */
+    omit?: ProductHistoryOmit<ExtArgs> | null
+    /**
+     * Filter which ProductHistory to delete.
+     */
+    where: ProductHistoryWhereUniqueInput
+  }
+
+  /**
+   * ProductHistory deleteMany
+   */
+  export type ProductHistoryDeleteManyArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Filter which ProductHistories to delete
+     */
+    where?: ProductHistoryWhereInput
+    /**
+     * Limit how many ProductHistories to delete.
+     */
+    limit?: number
+  }
+
+  /**
+   * ProductHistory without action
+   */
+  export type ProductHistoryDefaultArgs<ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs> = {
+    /**
+     * Select specific fields to fetch from the ProductHistory
+     */
+    select?: ProductHistorySelect<ExtArgs> | null
+    /**
+     * Omit specific fields from the ProductHistory
+     */
+    omit?: ProductHistoryOmit<ExtArgs> | null
+  }
+
+
+  /**
+   * Enums
+   */
+
+  export const TransactionIsolationLevel: {
+    ReadUncommitted: 'ReadUncommitted',
+    ReadCommitted: 'ReadCommitted',
+    RepeatableRead: 'RepeatableRead',
+    Serializable: 'Serializable'
+  };
+
+  export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel]
+
+
+  export const AttributeScalarFieldEnum: {
+    id: 'id',
+    name: 'name',
+    productId: 'productId',
+    order: 'order',
+    createdAt: 'createdAt',
+    updatedAt: 'updatedAt'
+  };
+
+  export type AttributeScalarFieldEnum = (typeof AttributeScalarFieldEnum)[keyof typeof AttributeScalarFieldEnum]
+
+
+  export const CategoryScalarFieldEnum: {
+    id: 'id',
+    key: 'key',
+    name: 'name',
+    priority: 'priority',
+    parentId: 'parentId',
+    primary: 'primary',
+    createdAt: 'createdAt',
+    updatedAt: 'updatedAt'
+  };
+
+  export type CategoryScalarFieldEnum = (typeof CategoryScalarFieldEnum)[keyof typeof CategoryScalarFieldEnum]
+
+
+  export const BrandScalarFieldEnum: {
+    id: 'id',
+    code: 'code',
+    name: 'name',
+    createdAt: 'createdAt',
+    updatedAt: 'updatedAt'
+  };
+
+  export type BrandScalarFieldEnum = (typeof BrandScalarFieldEnum)[keyof typeof BrandScalarFieldEnum]
+
+
+  export const ProductScalarFieldEnum: {
+    id: 'id',
+    name: 'name',
+    brandId: 'brandId',
+    description: 'description',
+    keywords: 'keywords',
+    categoryId: 'categoryId',
+    viewedCount: 'viewedCount',
+    status: 'status',
+    media: 'media',
+    createdAt: 'createdAt',
+    updatedAt: 'updatedAt'
+  };
+
+  export type ProductScalarFieldEnum = (typeof ProductScalarFieldEnum)[keyof typeof ProductScalarFieldEnum]
+
+
+  export const ProductSyncOutboxScalarFieldEnum: {
+    id: 'id',
+    publishStatus: 'publishStatus',
+    publishRetryCount: 'publishRetryCount',
+    publishError: 'publishError',
+    publishedAt: 'publishedAt',
+    esSyncStatus: 'esSyncStatus',
+    esRetryCount: 'esRetryCount',
+    esSyncedAt: 'esSyncedAt',
+    esSyncError: 'esSyncError',
+    payload: 'payload',
+    createdAt: 'createdAt',
+    updatedAt: 'updatedAt'
+  };
+
+  export type ProductSyncOutboxScalarFieldEnum = (typeof ProductSyncOutboxScalarFieldEnum)[keyof typeof ProductSyncOutboxScalarFieldEnum]
+
+
+  export const InventoryOutboxScalarFieldEnum: {
+    id: 'id',
+    publishStatus: 'publishStatus',
+    publishRetryCount: 'publishRetryCount',
+    publishError: 'publishError',
+    publishedAt: 'publishedAt',
+    payload: 'payload',
+    createdAt: 'createdAt',
+    updatedAt: 'updatedAt'
+  };
+
+  export type InventoryOutboxScalarFieldEnum = (typeof InventoryOutboxScalarFieldEnum)[keyof typeof InventoryOutboxScalarFieldEnum]
+
+
+  export const AttributeValueScalarFieldEnum: {
+    id: 'id',
+    skuId: 'skuId',
+    attrId: 'attrId',
+    value: 'value',
+    order: 'order',
+    createdAt: 'createdAt',
+    updatedAt: 'updatedAt'
+  };
+
+  export type AttributeValueScalarFieldEnum = (typeof AttributeValueScalarFieldEnum)[keyof typeof AttributeValueScalarFieldEnum]
+
+
+  export const SkuScalarFieldEnum: {
+    id: 'id',
+    skuNo: 'skuNo',
+    productId: 'productId',
+    price: 'price',
+    width: 'width',
+    height: 'height',
+    length: 'length',
+    weight: 'weight',
+    media: 'media',
+    inactive: 'inactive',
+    createdAt: 'createdAt',
+    updatedAt: 'updatedAt'
+  };
+
+  export type SkuScalarFieldEnum = (typeof SkuScalarFieldEnum)[keyof typeof SkuScalarFieldEnum]
+
+
+  export const ProductHistoryScalarFieldEnum: {
+    id: 'id',
+    productId: 'productId',
+    changeType: 'changeType',
+    changedBy: 'changedBy',
+    snapshot: 'snapshot',
+    createdAt: 'createdAt'
+  };
+
+  export type ProductHistoryScalarFieldEnum = (typeof ProductHistoryScalarFieldEnum)[keyof typeof ProductHistoryScalarFieldEnum]
 
 
   export const SortOrder: {
@@ -11914,6 +13024,63 @@ export namespace Prisma {
     updatedAt?: DateTimeWithAggregatesFilter<"Sku"> | Date | string
   }
 
+  export type ProductHistoryWhereInput = {
+    AND?: ProductHistoryWhereInput | ProductHistoryWhereInput[]
+    OR?: ProductHistoryWhereInput[]
+    NOT?: ProductHistoryWhereInput | ProductHistoryWhereInput[]
+    id?: UuidFilter<"ProductHistory"> | string
+    productId?: UuidFilter<"ProductHistory"> | string
+    changeType?: StringFilter<"ProductHistory"> | string
+    changedBy?: UuidNullableFilter<"ProductHistory"> | string | null
+    snapshot?: JsonFilter<"ProductHistory">
+    createdAt?: DateTimeFilter<"ProductHistory"> | Date | string
+  }
+
+  export type ProductHistoryOrderByWithRelationInput = {
+    id?: SortOrder
+    productId?: SortOrder
+    changeType?: SortOrder
+    changedBy?: SortOrderInput | SortOrder
+    snapshot?: SortOrder
+    createdAt?: SortOrder
+  }
+
+  export type ProductHistoryWhereUniqueInput = Prisma.AtLeast<{
+    id?: string
+    AND?: ProductHistoryWhereInput | ProductHistoryWhereInput[]
+    OR?: ProductHistoryWhereInput[]
+    NOT?: ProductHistoryWhereInput | ProductHistoryWhereInput[]
+    productId?: UuidFilter<"ProductHistory"> | string
+    changeType?: StringFilter<"ProductHistory"> | string
+    changedBy?: UuidNullableFilter<"ProductHistory"> | string | null
+    snapshot?: JsonFilter<"ProductHistory">
+    createdAt?: DateTimeFilter<"ProductHistory"> | Date | string
+  }, "id">
+
+  export type ProductHistoryOrderByWithAggregationInput = {
+    id?: SortOrder
+    productId?: SortOrder
+    changeType?: SortOrder
+    changedBy?: SortOrderInput | SortOrder
+    snapshot?: SortOrder
+    createdAt?: SortOrder
+    _count?: ProductHistoryCountOrderByAggregateInput
+    _max?: ProductHistoryMaxOrderByAggregateInput
+    _min?: ProductHistoryMinOrderByAggregateInput
+  }
+
+  export type ProductHistoryScalarWhereWithAggregatesInput = {
+    AND?: ProductHistoryScalarWhereWithAggregatesInput | ProductHistoryScalarWhereWithAggregatesInput[]
+    OR?: ProductHistoryScalarWhereWithAggregatesInput[]
+    NOT?: ProductHistoryScalarWhereWithAggregatesInput | ProductHistoryScalarWhereWithAggregatesInput[]
+    id?: UuidWithAggregatesFilter<"ProductHistory"> | string
+    productId?: UuidWithAggregatesFilter<"ProductHistory"> | string
+    changeType?: StringWithAggregatesFilter<"ProductHistory"> | string
+    changedBy?: UuidNullableWithAggregatesFilter<"ProductHistory"> | string | null
+    snapshot?: JsonWithAggregatesFilter<"ProductHistory">
+    createdAt?: DateTimeWithAggregatesFilter<"ProductHistory"> | Date | string
+  }
+
   export type AttributeCreateInput = {
     id?: string
     name: string
@@ -12583,6 +13750,69 @@ export namespace Prisma {
     updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string
   }
 
+  export type ProductHistoryCreateInput = {
+    id?: string
+    productId: string
+    changeType: string
+    changedBy?: string | null
+    snapshot:PrismaJson.PrismaProductEntityPopulated
+    createdAt?: Date | string
+  }
+
+  export type ProductHistoryUncheckedCreateInput = {
+    id?: string
+    productId: string
+    changeType: string
+    changedBy?: string | null
+    snapshot:PrismaJson.PrismaProductEntityPopulated
+    createdAt?: Date | string
+  }
+
+  export type ProductHistoryUpdateInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    productId?: StringFieldUpdateOperationsInput | string
+    changeType?: StringFieldUpdateOperationsInput | string
+    changedBy?: NullableStringFieldUpdateOperationsInput | string | null
+    snapshot?:PrismaJson.PrismaProductEntityPopulated
+    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
+  }
+
+  export type ProductHistoryUncheckedUpdateInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    productId?: StringFieldUpdateOperationsInput | string
+    changeType?: StringFieldUpdateOperationsInput | string
+    changedBy?: NullableStringFieldUpdateOperationsInput | string | null
+    snapshot?:PrismaJson.PrismaProductEntityPopulated
+    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
+  }
+
+  export type ProductHistoryCreateManyInput = {
+    id?: string
+    productId: string
+    changeType: string
+    changedBy?: string | null
+    snapshot:PrismaJson.PrismaProductEntityPopulated
+    createdAt?: Date | string
+  }
+
+  export type ProductHistoryUpdateManyMutationInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    productId?: StringFieldUpdateOperationsInput | string
+    changeType?: StringFieldUpdateOperationsInput | string
+    changedBy?: NullableStringFieldUpdateOperationsInput | string | null
+    snapshot?:PrismaJson.PrismaProductEntityPopulated
+    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
+  }
+
+  export type ProductHistoryUncheckedUpdateManyInput = {
+    id?: StringFieldUpdateOperationsInput | string
+    productId?: StringFieldUpdateOperationsInput | string
+    changeType?: StringFieldUpdateOperationsInput | string
+    changedBy?: NullableStringFieldUpdateOperationsInput | string | null
+    snapshot?:PrismaJson.PrismaProductEntityPopulated
+    createdAt?: DateTimeFieldUpdateOperationsInput | Date | string
+  }
+
   export type UuidFilter<$PrismaModel = never> = {
     equals?: string | StringFieldRefInput<$PrismaModel>
     in?: string[] | ListStringFieldRefInput<$PrismaModel>
@@ -13335,6 +14565,31 @@ export namespace Prisma {
     _max?: NestedBigIntFilter<$PrismaModel>
   }
 
+  export type ProductHistoryCountOrderByAggregateInput = {
+    id?: SortOrder
+    productId?: SortOrder
+    changeType?: SortOrder
+    changedBy?: SortOrder
+    snapshot?: SortOrder
+    createdAt?: SortOrder
+  }
+
+  export type ProductHistoryMaxOrderByAggregateInput = {
+    id?: SortOrder
+    productId?: SortOrder
+    changeType?: SortOrder
+    changedBy?: SortOrder
+    createdAt?: SortOrder
+  }
+
+  export type ProductHistoryMinOrderByAggregateInput = {
+    id?: SortOrder
+    productId?: SortOrder
+    changeType?: SortOrder
+    changedBy?: SortOrder
+    createdAt?: SortOrder
+  }
+
   export type AttributeValueCreateNestedManyWithoutAttrInput = {
     create?: XOR<AttributeValueCreateWithoutAttrInput, AttributeValueUncheckedCreateWithoutAttrInput> | AttributeValueCreateWithoutAttrInput[] | AttributeValueUncheckedCreateWithoutAttrInput[]
     connectOrCreate?: AttributeValueCreateOrConnectWithoutAttrInput | AttributeValueCreateOrConnectWithoutAttrInput[]