@reactionary/core 0.3.14 → 0.3.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactionary/core",
-  "version": "0.3.14",
+  "version": "0.3.16",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {

package/providers/index.js

@@ -12,6 +12,7 @@ export * from "./product-search.provider.js";
 export * from "./product-recommendations.provider.js";
 export * from "./product-associations.provider.js";
 export * from "./product-reviews.provider.js";
+export * from "./product-list.provider.js";
 export * from "./store.provider.js";
 export * from "./order.provider.js";
 export * from "./order-search.provider.js";

package/providers/product-list.provider.js

@@ -0,0 +1,10 @@
+import {} from "../schemas/queries/product-list.query.js";
+import { BaseProvider } from "./base.provider.js";
+class ProductListProvider extends BaseProvider {
+  getResourceName() {
+    return "product-lists";
+  }
+}
+export {
+  ProductListProvider
+};

package/schemas/capabilities.schema.js

@@ -5,6 +5,7 @@ const CapabilitiesSchema = z.looseObject({
   productAssociations: z.boolean(),
   productRecommendations: z.boolean(),
   productReviews: z.boolean(),
+  productList: z.boolean(),
   analytics: z.boolean(),
   identity: z.boolean(),
   cart: z.boolean(),

package/schemas/models/identifiers.model.js

@@ -2,6 +2,7 @@ import * as z from "zod";
 import { PaginationOptionsSchema } from "./base.model.js";
 const OrderStatusSchema = z.enum(["AwaitingPayment", "ReleasedToFulfillment", "Shipped", "Cancelled"]).meta({ description: "The current status of the order." });
 const OrderInventoryStatusSchema = z.enum(["NotAllocated", "Allocated", "Backordered", "Preordered"]).meta({ description: "The inventory release status of the order." });
+const ProductListTypeSchema = z.enum(["favorite", "wish", "requisition", "shopping"]).meta({ description: 'The type of product list, e.g., "wish" or "favorite".' });
 const FacetIdentifierSchema = z.looseObject({
   key: z.string()
 });
@@ -115,6 +116,22 @@ const OrderSearchIdentifierSchema = z.looseObject({
   filters: z.array(z.string()).meta({ description: "Additional filters applied to the search results." }),
   paginationOptions: PaginationOptionsSchema.describe("Pagination options for the search results.")
 });
+const ProductListSearchIdentifierSchema = z.looseObject({
+  listType: ProductListTypeSchema.meta({ description: 'The type of product list, e.g., "wishlist" or "favorites".' }),
+  paginationOptions: PaginationOptionsSchema.describe("Pagination options for the search results.")
+});
+const ProductListIdentifierSchema = z.looseObject({
+  listType: ProductListTypeSchema.meta({ description: 'The type of product list, e.g., "wish" or "favorite".' }),
+  key: z.string().meta({ description: "The unique identifier for the product list." })
+});
+const ProductListItemSearchIdentifierSchema = z.looseObject({
+  list: ProductListIdentifierSchema.describe("The identifier for the product list to query. The provider should return the items in the list that match this identifier. For example, if the identifier is a customer ID, the provider should return the items in the customer's wishlist. If the identifier is a session ID, the provider should return the items in the customer's current shopping cart. If the identifier is a product ID, the provider should return the items in the product's related products list."),
+  paginationOptions: PaginationOptionsSchema.describe("Pagination options for the search results.")
+});
+const ProductListItemIdentifierSchema = z.looseObject({
+  key: z.string().meta({ description: "The unique identifier for the product list item." }),
+  list: ProductListIdentifierSchema
+});
 export {
   AddressIdentifierSchema,
   CartIdentifierSchema,
@@ -140,6 +157,11 @@ export {
   ProductAttributeIdentifierSchema,
   ProductAttributeValueIdentifierSchema,
   ProductIdentifierSchema,
+  ProductListIdentifierSchema,
+  ProductListItemIdentifierSchema,
+  ProductListItemSearchIdentifierSchema,
+  ProductListSearchIdentifierSchema,
+  ProductListTypeSchema,
   ProductOptionIdentifierSchema,
   ProductOptionValueIdentifierSchema,
   ProductRatingIdentifierSchema,

package/schemas/models/index.js

@@ -20,3 +20,5 @@ export * from "./checkout.model.js";
 export * from "./payment.model.js";
 export * from "./order-search.model.js";
 export * from "./product-recommendations.model.js";
+export * from "./product-associations.model.js";
+export * from "./product-list.model.js";

package/schemas/models/product-associations.model.js

@@ -2,24 +2,24 @@ import * as z from "zod";
 import { ProductIdentifierSchema, ProductAssociationsIdentifierSchema, ProductVariantIdentifierSchema } from "./identifiers.model.js";
 import { ProductSearchResultItemSchema } from "./product-search.model.js";
 import { BaseModelSchema } from "./base.model.js";
-const BaseProductAssociationsSchema = BaseModelSchema.extend({
+const BaseProductAssociationSchema = BaseModelSchema.extend({
   associationIdentifier: ProductAssociationsIdentifierSchema.meta({ description: "The identifier for the product recommendation, which includes a key and an algorithm and any other vendor specific/instance specific data " })
 });
-const ProductAssociationsIdOnlySchema = BaseProductAssociationsSchema.extend({
+const ProductAssociationIdOnlySchema = BaseProductAssociationSchema.extend({
   associationReturnType: z.literal("idOnly").meta({ description: "The type of recommendation return" }),
   product: ProductIdentifierSchema.meta({ description: "The identifier for the recommended product." })
 });
-const ProductAssociationsProductSearchResultItemSchema = BaseProductAssociationsSchema.extend({
+const ProductAssociationProductSearchResultItemSchema = BaseProductAssociationSchema.extend({
   associationReturnType: z.literal("productSearchResultItem").meta({ description: "The type of recommendation return" }),
   product: ProductSearchResultItemSchema.meta({ description: "The recommended product, including its identifier, name, slug, and variants. This can be used to display the recommended product directly on the frontend without needing to make an additional request to fetch the product details." })
 });
-const ProductAssociationsSchema = z.discriminatedUnion("associationReturnType", [
-  ProductAssociationsIdOnlySchema,
-  ProductAssociationsProductSearchResultItemSchema
+const ProductAssociationSchema = z.discriminatedUnion("associationReturnType", [
+  ProductAssociationIdOnlySchema,
+  ProductAssociationProductSearchResultItemSchema
 ]);
 export {
-  BaseProductAssociationsSchema,
-  ProductAssociationsIdOnlySchema,
-  ProductAssociationsProductSearchResultItemSchema,
-  ProductAssociationsSchema
+  BaseProductAssociationSchema,
+  ProductAssociationIdOnlySchema,
+  ProductAssociationProductSearchResultItemSchema,
+  ProductAssociationSchema
 };

package/schemas/models/product-list.model.js

@@ -0,0 +1,33 @@
+import * as z from "zod";
+import { ProductListIdentifierSchema, ProductListItemIdentifierSchema, ProductListItemSearchIdentifierSchema, ProductListSearchIdentifierSchema, ProductListTypeSchema, ProductVariantIdentifierSchema } from "./identifiers.model.js";
+import { BaseModelSchema, createPaginatedResponseSchema, ImageSchema } from "./base.model.js";
+const ProductListSchema = BaseModelSchema.extend({
+  identifier: ProductListIdentifierSchema.meta({ description: "The unique identifier for the product list." }),
+  type: ProductListTypeSchema.meta({ description: 'The type of product list, e.g., "wish" or "favorite".' }),
+  name: z.string().meta({ description: "The name of the product list." }),
+  description: z.string().optional().meta({ description: "A description of the product list. A longer text providing more details about the list." }),
+  image: ImageSchema.optional().meta({ description: "Icon or image associated with list " }),
+  published: z.boolean().default(true).meta({ description: "Whether the wish list is published and visible to others. Semantics may vary. " }),
+  publishDate: z.string().optional().meta({ description: "The date at which a list is published for others to see. Sematics may vary" })
+});
+const ProductListItemSchema = BaseModelSchema.extend({
+  identifier: ProductListItemIdentifierSchema.meta({ description: "The unique identifier for the product list item." }),
+  variant: ProductVariantIdentifierSchema.meta({ description: "The identifier for the product variant that is included in the list." }),
+  quantity: z.number().positive({
+    error: "Quantity must be a positive number."
+  }).meta({ description: "The quantity of the product variant that is included in the list." }),
+  notes: z.string().optional().meta({ description: "Additional notes or comments about the product variant in the list." }),
+  order: z.number().default(1).meta({ description: "The order of the item in the list. This can be used to sort the items in the list." })
+});
+const ProductListPaginatedResultsSchema = createPaginatedResponseSchema(ProductListSchema).extend({
+  identifier: ProductListSearchIdentifierSchema.meta({ description: "The search parameters applied to retrive this subset of the items in the list." })
+});
+const ProductListItemPaginatedResultsSchema = createPaginatedResponseSchema(ProductListItemSchema).extend({
+  identifier: ProductListItemSearchIdentifierSchema.meta({ description: "The search parameters applied to retrive this subset of the items in the list." })
+});
+export {
+  ProductListItemPaginatedResultsSchema,
+  ProductListItemSchema,
+  ProductListPaginatedResultsSchema,
+  ProductListSchema
+};

package/schemas/mutations/index.js

@@ -4,7 +4,7 @@ export * from "./cart.mutation.js";
 export * from "./identity.mutation.js";
 export * from "./inventory.mutation.js";
 export * from "./price.mutation.js";
-export * from "./product.mutation.js";
+export * from "./product-list.mutation.js";
 export * from "./product-reviews.mutation.js";
 export * from "./profile.mutation.js";
 export * from "./search.mutation.js";

package/schemas/mutations/product-list.mutation.js

@@ -0,0 +1,44 @@
+import * as z from "zod";
+import { ImageSchema } from "../models/base.model.js";
+import { ProductListIdentifierSchema, ProductListItemIdentifierSchema } from "../models/identifiers.model.js";
+import { ProductListItemSchema, ProductListSchema } from "../models/product-list.model.js";
+import { BaseMutationSchema } from "./base.mutation.js";
+const ProductListCreateSchema = ProductListSchema.omit({ identifier: true });
+const ProductListMutationCreateSchema = BaseMutationSchema.extend({
+  list: ProductListCreateSchema.describe("The details of the product list to create, including its name, description, type, and any associated image.")
+});
+const ProductListMutationDeleteSchema = BaseMutationSchema.extend({
+  list: ProductListIdentifierSchema.meta({ description: "The identifier for the product list to delete." })
+});
+const ProductListMutationUpdateSchema = BaseMutationSchema.extend({
+  list: ProductListIdentifierSchema.meta({ description: "The identifier for the product list to update." }),
+  name: z.string().optional().meta({ description: "The name of the product list." }),
+  description: z.string().optional().meta({ description: "A description of the product list. A longer text providing more details about the list." }),
+  image: ImageSchema.optional().describe("Icon or image associated with list "),
+  published: z.boolean().optional().meta({ description: "Whether the wish list is published and visible to others. Semantics may vary. " }),
+  publishDate: z.string().optional().meta({ description: "The date at which a list is published for others to see. Sematics may vary" })
+});
+const ProductListItemCreateSchema = ProductListItemSchema.omit({ identifier: true });
+const ProductListItemMutationCreateSchema = BaseMutationSchema.extend({
+  list: ProductListIdentifierSchema.describe("The identifier for the product list to add an item to."),
+  listItem: ProductListItemCreateSchema.describe("The details of the item to add to the list, including the product variant identifier, quantity, and any notes about the item.")
+});
+const ProductListItemMutationDeleteSchema = BaseMutationSchema.extend({
+  listItem: ProductListItemIdentifierSchema.describe("The identifier for the product list item to remove. The list items identifier contains a reference to the list itself")
+});
+const ProductListItemMutationUpdateSchema = BaseMutationSchema.extend({
+  listItem: ProductListItemIdentifierSchema.describe("The identifier for the product list item to update. The list items identifier contains a reference to the list itself"),
+  quantity: z.number().positive().optional().meta({ description: "The updated quantity of the product variant that is included in the list." }),
+  notes: z.string().optional().meta({ description: "Updated additional notes or comments about the product variant in the list." }),
+  order: z.number().optional().meta({ description: "The updated order of the item in the list. This can be used to sort the items in the list." })
+});
+export {
+  ProductListCreateSchema,
+  ProductListItemCreateSchema,
+  ProductListItemMutationCreateSchema,
+  ProductListItemMutationDeleteSchema,
+  ProductListItemMutationUpdateSchema,
+  ProductListMutationCreateSchema,
+  ProductListMutationDeleteSchema,
+  ProductListMutationUpdateSchema
+};

package/schemas/queries/index.js

@@ -15,3 +15,4 @@ export * from "./checkout.query.js";
 export * from "./order-search.query.js";
 export * from "./product-recommendations.query.js";
 export * from "./product-associations.query.js";
+export * from "./product-list.query.js";

package/schemas/queries/product-associations.query.js

@@ -3,14 +3,16 @@ import { BaseQuerySchema } from "./base.query.js";
 import { ProductIdentifierSchema, ProductVariantIdentifierSchema } from "../models/identifiers.model.js";
 import { CartItemSchema } from "../models/cart.model.js";
 const ProductAssociationsGetAccessoriesQuerySchema = BaseQuerySchema.extend({
-  forProductVariant: ProductVariantIdentifierSchema.describe("The product variant identifier for which to get accessory recommendations. The provider should return recommendations that are relevant to this product, e.g., products that are frequently bought together, products that are similar in style or category, or products that are popular among users with similar preferences."),
+  forProduct: ProductIdentifierSchema.describe("The product identifier for which to get accessory recommendations. The provider should return recommendations that are relevant to this product, e.g., products that are frequently bought together, products that are similar in style or category, or products that are popular among users with similar preferences."),
   numberOfAccessories: z.number().min(1).max(12).meta({ description: "The number of accessory recommendations requested. The provider may return fewer than this number, but should not return more." })
 });
 const ProductAssociationsGetSparepartsQuerySchema = BaseQuerySchema.extend({
-  forProductVariant: ProductVariantIdentifierSchema.describe("The product variant identifier for which to get similar item recommendations. The provider should return recommendations that are relevant to this product, e.g., products that are frequently bought together, products that are similar in style or category, or products that are popular among users with similar preferences.")
+  forProduct: ProductIdentifierSchema.describe("The product identifier for which to get similar item recommendations. The provider should return recommendations that are relevant to this product, e.g., products that are frequently bought together, products that are similar in style or category, or products that are popular among users with similar preferences."),
+  numberOfSpareparts: z.number().min(1).max(12).meta({ description: "The number of spare part recommendations requested. The provider may return fewer than this number, but should not return more." })
 });
 const ProductAssociationsGetReplacementsQuerySchema = BaseQuerySchema.extend({
-  forProductVariant: ProductVariantIdentifierSchema.describe("The product variant identifier for which to get replacement recommendations. The provider should return recommendations that are relevant to this product, e.g., products that are frequently bought together, products that are similar in style or category, or products that are popular among users with similar preferences.")
+  forProduct: ProductIdentifierSchema.describe("The product identifier for which to get replacement recommendations. The provider should return recommendations that are relevant to this product, e.g., products that are frequently bought together, products that are similar in style or category, or products that are popular among users with similar preferences."),
+  numberOfReplacements: z.number().min(1).max(12).meta({ description: "The number of replacement recommendations requested. The provider may return fewer than this number, but should not return more." })
 });
 export {
   ProductAssociationsGetAccessoriesQuerySchema,

package/schemas/queries/product-list.query.js

@@ -0,0 +1,16 @@
+import { ProductListIdentifierSchema, ProductListItemSearchIdentifierSchema, ProductListSearchIdentifierSchema } from "../models/identifiers.model.js";
+import { BaseQuerySchema } from "./base.query.js";
+const ProductListQueryByIdSchema = BaseQuerySchema.extend({
+  identifier: ProductListIdentifierSchema.describe("The unique identifier for the product list to retrieve. For example, this could be the identifier for a specific wishlist or shopping cart.")
+});
+const ProductListQuerySchema = BaseQuerySchema.extend({
+  search: ProductListSearchIdentifierSchema.describe("The identifier for the product list to query. The provider should return the items in the list that match this identifier. For example, if the identifier is a customer ID, the provider should return the items in the customer's wishlist. If the identifier is a session ID, the provider should return the items in the customer's current shopping cart. If the identifier is a product ID, the provider should return the items in the product's related products list.")
+});
+const ProductListItemQuerySchema = BaseQuerySchema.extend({
+  search: ProductListItemSearchIdentifierSchema.describe("The identifier for the product list to query. The provider should return the items in the list that match this identifier. For example, if the identifier is a customer ID, the provider should return the items in the customer's wishlist. If the identifier is a session ID, the provider should return the items in the customer's current shopping cart. If the identifier is a product ID, the provider should return the items in the product's related products list.")
+});
+export {
+  ProductListItemQuerySchema,
+  ProductListQueryByIdSchema,
+  ProductListQuerySchema
+};

package/src/client/client.d.ts

@@ -6,7 +6,7 @@ import type { PriceProvider } from "../providers/price.provider.js";
 import type { InventoryProvider } from "../providers/inventory.provider.js";
 import type { Cache } from "../cache/cache.interface.js";
 import type { CategoryProvider } from "../providers/category.provider.js";
-import type { AnalyticsProvider, CheckoutProvider, OrderProvider, ProfileProvider, StoreProvider } from "../providers/index.js";
+import type { AnalyticsProvider, CheckoutProvider, OrderProvider, ProductListProvider, ProfileProvider, StoreProvider } from "../providers/index.js";
 import type { OrderSearchProvider } from "../providers/order-search.provider.js";
 import type { ProductRecommendationsProvider } from "../providers/product-recommendations.provider.js";
 import type { ProductAssociationsProvider } from "../providers/product-associations.provider.js";
@@ -17,6 +17,7 @@ export interface Client {
     productRecommendations: ProductRecommendationsProvider;
     productAssociations: ProductAssociationsProvider;
     productReviews: ProductReviewsProvider;
+    productList: ProductListProvider;
     identity: IdentityProvider;
     cache: Cache;
     cart: CartProvider;

package/src/providers/index.d.ts

@@ -12,6 +12,7 @@ export * from './product-search.provider.js';
 export * from './product-recommendations.provider.js';
 export * from './product-associations.provider.js';
 export * from './product-reviews.provider.js';
+export * from './product-list.provider.js';
 export * from './store.provider.js';
 export * from './order.provider.js';
 export * from './order-search.provider.js';

package/src/providers/product-associations.provider.d.ts

@@ -1,6 +1,7 @@
-import type { ProductVariantIdentifier } from "../schemas/index.js";
 import type { ProductAssociationsGetAccessoriesQuery, ProductAssociationsGetSparepartsQuery, ProductAssociationsGetReplacementsQuery } from "../schemas/queries/product-associations.query.js";
 import { BaseProvider } from "./base.provider.js";
+import type { Result } from '../schemas/result.js';
+import type { ProductAssociation } from '../schemas/models/product-associations.model.js';
 /**
  * The product association provider is responsible for providing evidence based associations between products, such as
  * accessories, spareparts, and replacements. These associations are typically used to provide recommendations to customers on the product detail page, but can also be used in other contexts such as the cart or post-purchase, but
@@ -16,20 +17,26 @@ export declare abstract class ProductAssociationsProvider extends BaseProvider {
      *
      * Usecase:
      * - PDP: Accessories for this product
+     *
+     * TODO:  This should be a PaginatedResult
      */
-    abstract getAccessories(query: ProductAssociationsGetAccessoriesQuery): Promise<ProductVariantIdentifier[]>;
+    abstract getAccessories(query: ProductAssociationsGetAccessoriesQuery): Promise<Result<ProductAssociation[]>>;
     /**
      * Returns a list of product identifiers which are spareparts to the given product.
      * Spareparts are products which are necessary for the use of the main product, but are not typically purchased alongside it. Examples of spareparts include:
      *
      * Usecase:
-     * - PDP: Accessories for this product
+     * - PDP: Spareparts for this product
+     *
+     * TODO:  This should be a PaginatedResult
      */
-    abstract getSpareparts(query: ProductAssociationsGetSparepartsQuery): Promise<ProductVariantIdentifier[]>;
+    abstract getSpareparts(query: ProductAssociationsGetSparepartsQuery): Promise<Result<ProductAssociation[]>>;
     /**
      * This product is replaced by these equivalent or newer products
+     *
+     * TODO:  This should be a PaginatedResult
      * @param query
      */
-    abstract getReplacements(query: ProductAssociationsGetReplacementsQuery): Promise<ProductVariantIdentifier[]>;
+    abstract getReplacements(query: ProductAssociationsGetReplacementsQuery): Promise<Result<ProductAssociation[]>>;
     getResourceName(): string;
 }

package/src/providers/product-list.provider.d.ts

@@ -0,0 +1,70 @@
+import type { ProductList, ProductListItem, ProductListItemPaginatedResult, ProductListPaginatedResult } from "../schemas/models/product-list.model.js";
+import type { ProductListItemMutationCreate, ProductListItemMutationDelete, ProductListItemMutationUpdate, ProductListMutationCreate, ProductListMutationDelete, ProductListMutationUpdate } from "../schemas/mutations/product-list.mutation.js";
+import type { ProductListQuery, ProductListQueryById } from "../schemas/queries/product-list.query.js";
+import { type ProductListItemsQuery } from "../schemas/queries/product-list.query.js";
+import type { Result } from "../schemas/result.js";
+import { BaseProvider } from "./base.provider.js";
+/**
+ * The product list provider is a general purpose provider for creating various types of product lists, such as favorite lists, projects, wishlists, requisitionlists, etc
+ * It supports having multiples of each list, so that users can have multiple wishlists for example. The lists are identified by a key, which is passed in the query for the various methods.
+ * The provider also supports having different types of lists, which can be used to differentiate between wishlists, favorite lists, etc.
+ * The type is also passed in the query for the various methods.
+ *
+ * Some systems might only support single entries of each type, but the general case is to support multiples.
+ */
+export declare abstract class ProductListProvider extends BaseProvider {
+    protected getResourceName(): string;
+    /**
+     * Usecase: in the frontend you want to fetch a specific list, for example a specific wishlist, to show the details of the list, such as the name, description, image, etc.
+     * you might have stored the identifier from an earlier session or looked it up previously.
+     * @param payload
+     */
+    abstract getById(payload: ProductListQueryById): Promise<Result<ProductList>>;
+    /**
+     * Usecase: in the frontend you want to see if the customer already has a favorite list or wishlist, to which the product can be added.
+     * In complex scenarios you might want to fetch a list of wishlists, and allow customer to pick which one to add the product-variant to.
+     *
+     * @param query
+     */
+    abstract queryLists(query: ProductListQuery): Promise<Result<ProductListPaginatedResult>>;
+    /**
+     * Usecase: in the frontend, if customer has clicked the "add to favorites list", and you have used the queryLists to find out there is no
+     * preexistiing list, you can use this method to create a new favorite list.
+     *
+     * Usecase: in frontend, if customer has chosing "add to favorites list", and you allow multiple lists, you can use this method to create a new favorite list,
+     * which the customer can then add the product to.
+     * @param mutation
+     */
+    abstract addList(mutation: ProductListMutationCreate): Promise<Result<ProductList>>;
+    /**
+     *
+     * Usecase: update name of list, or other metadata related to the list, such as "this is my summer wishlist", or "this is my favorite list for cameras".
+     * @param mutation
+     */
+    abstract updateList(mutation: ProductListMutationUpdate): Promise<Result<ProductList>>;
+    /**
+     * Usecase: customer wants to delete a list, such as "delete my summer wishlist", including all the product list items
+     * @param mutation
+     */
+    abstract deleteList(mutation: ProductListMutationDelete): Promise<Result<void>>;
+    /**
+     * Usecase: in the frontend you want to show a list of the products in the customers wishlist.
+     * @param query
+     */
+    abstract queryListItems(query: ProductListItemsQuery): Promise<Result<ProductListItemPaginatedResult>>;
+    /**
+     * Usecase: Add a new product-variant to a list
+     * @param mutation
+     */
+    abstract addItem(mutation: ProductListItemMutationCreate): Promise<Result<ProductListItem>>;
+    /**
+     * Usecase: Remove a product-variant from a list.
+     * @param mutation
+     */
+    abstract deleteItem(mutation: ProductListItemMutationDelete): Promise<Result<void>>;
+    /**
+     * Usecase: Update the quantity of a product-variant in a list.
+     * @param mutation
+     */
+    abstract updateItem(mutation: ProductListItemMutationUpdate): Promise<Result<ProductListItem>>;
+}

package/src/schemas/capabilities.schema.d.ts

@@ -7,6 +7,7 @@ export declare const CapabilitiesSchema: z.ZodObject<{
     productAssociations: z.ZodBoolean;
     productRecommendations: z.ZodBoolean;
     productReviews: z.ZodBoolean;
+    productList: z.ZodBoolean;
     analytics: z.ZodBoolean;
     identity: z.ZodBoolean;
     cart: z.ZodBoolean;

package/src/schemas/models/identifiers.model.d.ts

@@ -12,6 +12,12 @@ export declare const OrderInventoryStatusSchema: z.ZodEnum<{
     Backordered: "Backordered";
     Preordered: "Preordered";
 }>;
+export declare const ProductListTypeSchema: z.ZodEnum<{
+    favorite: "favorite";
+    wish: "wish";
+    requisition: "requisition";
+    shopping: "shopping";
+}>;
 export declare const FacetIdentifierSchema: z.ZodObject<{
     key: z.ZodString;
 }, z.core.$loose>;
@@ -166,6 +172,54 @@ export declare const OrderSearchIdentifierSchema: z.ZodObject<{
         pageSize: z.ZodDefault<z.ZodNumber>;
     }, z.core.$loose>;
 }, z.core.$loose>;
+export declare const ProductListSearchIdentifierSchema: z.ZodObject<{
+    listType: z.ZodEnum<{
+        favorite: "favorite";
+        wish: "wish";
+        requisition: "requisition";
+        shopping: "shopping";
+    }>;
+    paginationOptions: z.ZodObject<{
+        pageNumber: z.ZodDefault<z.ZodNumber>;
+        pageSize: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export declare const ProductListIdentifierSchema: z.ZodObject<{
+    listType: z.ZodEnum<{
+        favorite: "favorite";
+        wish: "wish";
+        requisition: "requisition";
+        shopping: "shopping";
+    }>;
+    key: z.ZodString;
+}, z.core.$loose>;
+export declare const ProductListItemSearchIdentifierSchema: z.ZodObject<{
+    list: z.ZodObject<{
+        listType: z.ZodEnum<{
+            favorite: "favorite";
+            wish: "wish";
+            requisition: "requisition";
+            shopping: "shopping";
+        }>;
+        key: z.ZodString;
+    }, z.core.$loose>;
+    paginationOptions: z.ZodObject<{
+        pageNumber: z.ZodDefault<z.ZodNumber>;
+        pageSize: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export declare const ProductListItemIdentifierSchema: z.ZodObject<{
+    key: z.ZodString;
+    list: z.ZodObject<{
+        listType: z.ZodEnum<{
+            favorite: "favorite";
+            wish: "wish";
+            requisition: "requisition";
+            shopping: "shopping";
+        }>;
+        key: z.ZodString;
+    }, z.core.$loose>;
+}, z.core.$loose>;
 export type OrderSearchIdentifier = InferType<typeof OrderSearchIdentifierSchema>;
 export type ProductIdentifier = InferType<typeof ProductIdentifierSchema>;
 export type ProductVariantIdentifier = InferType<typeof ProductVariantIdentifierSchema>;
@@ -198,4 +252,9 @@ export type ProductRecommendationIdentifier = InferType<typeof ProductRecommenda
 export type ProductAssociationsIdentifier = InferType<typeof ProductAssociationsIdentifierSchema>;
 export type ProductRatingIdentifier = InferType<typeof ProductRatingIdentifierSchema>;
 export type ProductReviewIdentifier = InferType<typeof ProductReviewIdentifierSchema>;
-export type IdentifierType = ProductIdentifier | ProductVariantIdentifier | SearchIdentifier | FacetIdentifier | FacetValueIdentifier | CartIdentifier | CartItemIdentifier | PriceIdentifier | CategoryIdentifier | WebStoreIdentifier | InventoryIdentifier | ProductRecommendationIdentifier | FulfillmentCenterIdentifier | IdentityIdentifier | ShippingMethodIdentifier | PaymentMethodIdentifier | AddressIdentifier | PaymentInstructionIdentifier | OrderIdentifier | OrderItemIdentifier | CheckoutIdentifier | CheckoutItemIdentifier | StoreIdentifier | ProductOptionIdentifier | ProductOptionValueIdentifier | PickupPointIdentifier | ProductAttributeIdentifier | ProductAttributeValueIdentifier | ProductRatingIdentifier | ProductReviewIdentifier;
+export type ProductListIdentifier = InferType<typeof ProductListIdentifierSchema>;
+export type ProductListItemIdentifier = InferType<typeof ProductListItemIdentifierSchema>;
+export type ProductListSearchIdentifier = InferType<typeof ProductListSearchIdentifierSchema>;
+export type ProductListItemSearchIdentifier = InferType<typeof ProductListItemSearchIdentifierSchema>;
+export type ProductListType = InferType<typeof ProductListTypeSchema>;
+export type IdentifierType = ProductIdentifier | ProductVariantIdentifier | SearchIdentifier | FacetIdentifier | FacetValueIdentifier | CartIdentifier | CartItemIdentifier | PriceIdentifier | CategoryIdentifier | WebStoreIdentifier | InventoryIdentifier | ProductRecommendationIdentifier | FulfillmentCenterIdentifier | IdentityIdentifier | ShippingMethodIdentifier | PaymentMethodIdentifier | AddressIdentifier | PaymentInstructionIdentifier | OrderIdentifier | OrderItemIdentifier | CheckoutIdentifier | CheckoutItemIdentifier | StoreIdentifier | ProductOptionIdentifier | ProductOptionValueIdentifier | PickupPointIdentifier | ProductAttributeIdentifier | ProductAttributeValueIdentifier | ProductRatingIdentifier | ProductReviewIdentifier | ProductAssociationsIdentifier | ProductListIdentifier | ProductListItemIdentifier | ProductListSearchIdentifier;

package/src/schemas/models/index.d.ts

@@ -20,3 +20,5 @@ export * from './checkout.model.js';
 export * from './payment.model.js';
 export * from './order-search.model.js';
 export * from './product-recommendations.model.js';
+export * from './product-associations.model.js';
+export * from './product-list.model.js';

package/src/schemas/models/product-associations.model.d.ts

@@ -1,11 +1,11 @@
 import * as z from "zod";
 import type { InferType } from "../../zod-utils.js";
-export declare const BaseProductAssociationsSchema: z.ZodObject<{
+export declare const BaseProductAssociationSchema: z.ZodObject<{
     associationIdentifier: z.ZodObject<{
         key: z.ZodString;
     }, z.core.$loose>;
 }, z.core.$loose>;
-export declare const ProductAssociationsIdOnlySchema: z.ZodObject<{
+export declare const ProductAssociationIdOnlySchema: z.ZodObject<{
     associationIdentifier: z.ZodObject<{
         key: z.ZodString;
     }, z.core.$loose>;
@@ -14,7 +14,7 @@ export declare const ProductAssociationsIdOnlySchema: z.ZodObject<{
         key: z.ZodString;
     }, z.core.$loose>;
 }, z.core.$loose>;
-export declare const ProductAssociationsProductSearchResultItemSchema: z.ZodObject<{
+export declare const ProductAssociationProductSearchResultItemSchema: z.ZodObject<{
     associationIdentifier: z.ZodObject<{
         key: z.ZodString;
     }, z.core.$loose>;
@@ -53,7 +53,7 @@ export declare const ProductAssociationsProductSearchResultItemSchema: z.ZodObje
         }, z.core.$loose>>;
     }, z.core.$loose>;
 }, z.core.$loose>;
-export declare const ProductAssociationsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const ProductAssociationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     associationIdentifier: z.ZodObject<{
         key: z.ZodString;
     }, z.core.$loose>;
@@ -100,6 +100,6 @@ export declare const ProductAssociationsSchema: z.ZodDiscriminatedUnion<[z.ZodOb
         }, z.core.$loose>>;
     }, z.core.$loose>;
 }, z.core.$loose>], "associationReturnType">;
-export type ProductAssociationsIdOnly = InferType<typeof ProductAssociationsIdOnlySchema>;
-export type ProductAssociationsSearchItem = InferType<typeof ProductAssociationsProductSearchResultItemSchema>;
-export type ProductAssociations = InferType<typeof ProductAssociationsSchema>;
+export type ProductAssociationIdOnly = InferType<typeof ProductAssociationIdOnlySchema>;
+export type ProductAssociationSearchItem = InferType<typeof ProductAssociationProductSearchResultItemSchema>;
+export type ProductAssociation = InferType<typeof ProductAssociationSchema>;

package/src/schemas/models/product-list.model.d.ts

@@ -0,0 +1,139 @@
+import * as z from "zod";
+import type { InferType } from "../../zod-utils.js";
+export declare const ProductListSchema: z.ZodObject<{
+    identifier: z.ZodObject<{
+        listType: z.ZodEnum<{
+            favorite: "favorite";
+            wish: "wish";
+            requisition: "requisition";
+            shopping: "shopping";
+        }>;
+        key: z.ZodString;
+    }, z.core.$loose>;
+    type: z.ZodEnum<{
+        favorite: "favorite";
+        wish: "wish";
+        requisition: "requisition";
+        shopping: "shopping";
+    }>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    image: z.ZodOptional<z.ZodObject<{
+        sourceUrl: z.ZodDefault<z.ZodString>;
+        altText: z.ZodDefault<z.ZodString>;
+        width: z.ZodOptional<z.ZodNumber>;
+        height: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+    published: z.ZodDefault<z.ZodBoolean>;
+    publishDate: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const ProductListItemSchema: z.ZodObject<{
+    identifier: z.ZodObject<{
+        key: z.ZodString;
+        list: z.ZodObject<{
+            listType: z.ZodEnum<{
+                favorite: "favorite";
+                wish: "wish";
+                requisition: "requisition";
+                shopping: "shopping";
+            }>;
+            key: z.ZodString;
+        }, z.core.$loose>;
+    }, z.core.$loose>;
+    variant: z.ZodObject<{
+        sku: z.ZodString;
+    }, z.core.$loose>;
+    quantity: z.ZodNumber;
+    notes: z.ZodOptional<z.ZodString>;
+    order: z.ZodDefault<z.ZodNumber>;
+}, z.core.$loose>;
+export declare const ProductListPaginatedResultsSchema: z.ZodObject<{
+    pageNumber: z.ZodNumber;
+    pageSize: z.ZodNumber;
+    totalCount: z.ZodNumber;
+    totalPages: z.ZodNumber;
+    items: z.ZodArray<z.ZodObject<{
+        identifier: z.ZodObject<{
+            listType: z.ZodEnum<{
+                favorite: "favorite";
+                wish: "wish";
+                requisition: "requisition";
+                shopping: "shopping";
+            }>;
+            key: z.ZodString;
+        }, z.core.$loose>;
+        type: z.ZodEnum<{
+            favorite: "favorite";
+            wish: "wish";
+            requisition: "requisition";
+            shopping: "shopping";
+        }>;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        image: z.ZodOptional<z.ZodObject<{
+            sourceUrl: z.ZodDefault<z.ZodString>;
+            altText: z.ZodDefault<z.ZodString>;
+            width: z.ZodOptional<z.ZodNumber>;
+            height: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+        published: z.ZodDefault<z.ZodBoolean>;
+        publishDate: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    identifier: z.ZodObject<{
+        listType: z.ZodEnum<{
+            favorite: "favorite";
+            wish: "wish";
+            requisition: "requisition";
+            shopping: "shopping";
+        }>;
+        paginationOptions: z.ZodObject<{
+            pageNumber: z.ZodDefault<z.ZodNumber>;
+            pageSize: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$loose>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+export declare const ProductListItemPaginatedResultsSchema: z.ZodObject<{
+    pageNumber: z.ZodNumber;
+    pageSize: z.ZodNumber;
+    totalCount: z.ZodNumber;
+    totalPages: z.ZodNumber;
+    items: z.ZodArray<z.ZodObject<{
+        identifier: z.ZodObject<{
+            key: z.ZodString;
+            list: z.ZodObject<{
+                listType: z.ZodEnum<{
+                    favorite: "favorite";
+                    wish: "wish";
+                    requisition: "requisition";
+                    shopping: "shopping";
+                }>;
+                key: z.ZodString;
+            }, z.core.$loose>;
+        }, z.core.$loose>;
+        variant: z.ZodObject<{
+            sku: z.ZodString;
+        }, z.core.$loose>;
+        quantity: z.ZodNumber;
+        notes: z.ZodOptional<z.ZodString>;
+        order: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$loose>>;
+    identifier: z.ZodObject<{
+        list: z.ZodObject<{
+            listType: z.ZodEnum<{
+                favorite: "favorite";
+                wish: "wish";
+                requisition: "requisition";
+                shopping: "shopping";
+            }>;
+            key: z.ZodString;
+        }, z.core.$loose>;
+        paginationOptions: z.ZodObject<{
+            pageNumber: z.ZodDefault<z.ZodNumber>;
+            pageSize: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$loose>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+export type ProductList = InferType<typeof ProductListSchema>;
+export type ProductListItem = InferType<typeof ProductListItemSchema>;
+export type ProductListPaginatedResult = InferType<typeof ProductListPaginatedResultsSchema>;
+export type ProductListItemPaginatedResult = InferType<typeof ProductListItemPaginatedResultsSchema>;

package/src/schemas/mutations/index.d.ts

@@ -4,7 +4,7 @@ export * from './cart.mutation.js';
 export * from './identity.mutation.js';
 export * from './inventory.mutation.js';
 export * from './price.mutation.js';
-export * from './product.mutation.js';
+export * from './product-list.mutation.js';
 export * from './product-reviews.mutation.js';
 export * from './profile.mutation.js';
 export * from './search.mutation.js';

package/src/schemas/mutations/product-list.mutation.d.ts

@@ -0,0 +1,138 @@
+import * as z from 'zod';
+import type { InferType } from '../../zod-utils.js';
+export declare const ProductListCreateSchema: z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    type: z.ZodEnum<{
+        favorite: "favorite";
+        wish: "wish";
+        requisition: "requisition";
+        shopping: "shopping";
+    }>;
+    name: z.ZodString;
+    published: z.ZodDefault<z.ZodBoolean>;
+    image: z.ZodOptional<z.ZodObject<{
+        sourceUrl: z.ZodDefault<z.ZodString>;
+        altText: z.ZodDefault<z.ZodString>;
+        width: z.ZodOptional<z.ZodNumber>;
+        height: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+    publishDate: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const ProductListMutationCreateSchema: z.ZodObject<{
+    list: z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        type: z.ZodEnum<{
+            favorite: "favorite";
+            wish: "wish";
+            requisition: "requisition";
+            shopping: "shopping";
+        }>;
+        name: z.ZodString;
+        published: z.ZodDefault<z.ZodBoolean>;
+        image: z.ZodOptional<z.ZodObject<{
+            sourceUrl: z.ZodDefault<z.ZodString>;
+            altText: z.ZodDefault<z.ZodString>;
+            width: z.ZodOptional<z.ZodNumber>;
+            height: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+        publishDate: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export declare const ProductListMutationDeleteSchema: z.ZodObject<{
+    list: z.ZodObject<{
+        listType: z.ZodEnum<{
+            favorite: "favorite";
+            wish: "wish";
+            requisition: "requisition";
+            shopping: "shopping";
+        }>;
+        key: z.ZodString;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export declare const ProductListMutationUpdateSchema: z.ZodObject<{
+    list: z.ZodObject<{
+        listType: z.ZodEnum<{
+            favorite: "favorite";
+            wish: "wish";
+            requisition: "requisition";
+            shopping: "shopping";
+        }>;
+        key: z.ZodString;
+    }, z.core.$loose>;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    image: z.ZodOptional<z.ZodObject<{
+        sourceUrl: z.ZodDefault<z.ZodString>;
+        altText: z.ZodDefault<z.ZodString>;
+        width: z.ZodOptional<z.ZodNumber>;
+        height: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+    published: z.ZodOptional<z.ZodBoolean>;
+    publishDate: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const ProductListItemCreateSchema: z.ZodObject<{
+    variant: z.ZodObject<{
+        sku: z.ZodString;
+    }, z.core.$loose>;
+    quantity: z.ZodNumber;
+    notes: z.ZodOptional<z.ZodString>;
+    order: z.ZodDefault<z.ZodNumber>;
+}, z.core.$loose>;
+export declare const ProductListItemMutationCreateSchema: z.ZodObject<{
+    list: z.ZodObject<{
+        listType: z.ZodEnum<{
+            favorite: "favorite";
+            wish: "wish";
+            requisition: "requisition";
+            shopping: "shopping";
+        }>;
+        key: z.ZodString;
+    }, z.core.$loose>;
+    listItem: z.ZodObject<{
+        variant: z.ZodObject<{
+            sku: z.ZodString;
+        }, z.core.$loose>;
+        quantity: z.ZodNumber;
+        notes: z.ZodOptional<z.ZodString>;
+        order: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export declare const ProductListItemMutationDeleteSchema: z.ZodObject<{
+    listItem: z.ZodObject<{
+        key: z.ZodString;
+        list: z.ZodObject<{
+            listType: z.ZodEnum<{
+                favorite: "favorite";
+                wish: "wish";
+                requisition: "requisition";
+                shopping: "shopping";
+            }>;
+            key: z.ZodString;
+        }, z.core.$loose>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export declare const ProductListItemMutationUpdateSchema: z.ZodObject<{
+    listItem: z.ZodObject<{
+        key: z.ZodString;
+        list: z.ZodObject<{
+            listType: z.ZodEnum<{
+                favorite: "favorite";
+                wish: "wish";
+                requisition: "requisition";
+                shopping: "shopping";
+            }>;
+            key: z.ZodString;
+        }, z.core.$loose>;
+    }, z.core.$loose>;
+    quantity: z.ZodOptional<z.ZodNumber>;
+    notes: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+export type ProductListItemCreate = InferType<typeof ProductListItemCreateSchema>;
+export type ProductListItemMutationCreate = InferType<typeof ProductListItemMutationCreateSchema>;
+export type ProductListItemMutationDelete = InferType<typeof ProductListItemMutationDeleteSchema>;
+export type ProductListItemMutationUpdate = InferType<typeof ProductListItemMutationUpdateSchema>;
+export type ProductListCreate = InferType<typeof ProductListCreateSchema>;
+export type ProductListMutationCreate = InferType<typeof ProductListMutationCreateSchema>;
+export type ProductListMutationUpdate = InferType<typeof ProductListMutationUpdateSchema>;
+export type ProductListMutationDelete = InferType<typeof ProductListMutationDeleteSchema>;

package/src/schemas/queries/index.d.ts

@@ -15,3 +15,4 @@ export * from './checkout.query.js';
 export * from './order-search.query.js';
 export * from './product-recommendations.query.js';
 export * from './product-associations.query.js';
+export * from './product-list.query.js';

package/src/schemas/queries/product-associations.query.d.ts

@@ -1,19 +1,21 @@
 import * as z from "zod";
 export declare const ProductAssociationsGetAccessoriesQuerySchema: z.ZodObject<{
-    forProductVariant: z.ZodObject<{
-        sku: z.ZodString;
+    forProduct: z.ZodObject<{
+        key: z.ZodString;
     }, z.core.$loose>;
     numberOfAccessories: z.ZodNumber;
 }, z.core.$loose>;
 export declare const ProductAssociationsGetSparepartsQuerySchema: z.ZodObject<{
-    forProductVariant: z.ZodObject<{
-        sku: z.ZodString;
+    forProduct: z.ZodObject<{
+        key: z.ZodString;
     }, z.core.$loose>;
+    numberOfSpareparts: z.ZodNumber;
 }, z.core.$loose>;
 export declare const ProductAssociationsGetReplacementsQuerySchema: z.ZodObject<{
-    forProductVariant: z.ZodObject<{
-        sku: z.ZodString;
+    forProduct: z.ZodObject<{
+        key: z.ZodString;
     }, z.core.$loose>;
+    numberOfReplacements: z.ZodNumber;
 }, z.core.$loose>;
 export type ProductAssociationsGetAccessoriesQuery = z.infer<typeof ProductAssociationsGetAccessoriesQuerySchema>;
 export type ProductAssociationsGetSparepartsQuery = z.infer<typeof ProductAssociationsGetSparepartsQuerySchema>;

package/src/schemas/queries/product-list.query.d.ts

@@ -0,0 +1,46 @@
+import type { InferType } from "../../zod-utils.js";
+export declare const ProductListQueryByIdSchema: import("zod").ZodObject<{
+    identifier: import("zod").ZodObject<{
+        listType: import("zod").ZodEnum<{
+            favorite: "favorite";
+            wish: "wish";
+            requisition: "requisition";
+            shopping: "shopping";
+        }>;
+        key: import("zod").ZodString;
+    }, import("zod/v4/core").$loose>;
+}, import("zod/v4/core").$loose>;
+export declare const ProductListQuerySchema: import("zod").ZodObject<{
+    search: import("zod").ZodObject<{
+        listType: import("zod").ZodEnum<{
+            favorite: "favorite";
+            wish: "wish";
+            requisition: "requisition";
+            shopping: "shopping";
+        }>;
+        paginationOptions: import("zod").ZodObject<{
+            pageNumber: import("zod").ZodDefault<import("zod").ZodNumber>;
+            pageSize: import("zod").ZodDefault<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$loose>;
+    }, import("zod/v4/core").$loose>;
+}, import("zod/v4/core").$loose>;
+export declare const ProductListItemQuerySchema: import("zod").ZodObject<{
+    search: import("zod").ZodObject<{
+        list: import("zod").ZodObject<{
+            listType: import("zod").ZodEnum<{
+                favorite: "favorite";
+                wish: "wish";
+                requisition: "requisition";
+                shopping: "shopping";
+            }>;
+            key: import("zod").ZodString;
+        }, import("zod/v4/core").$loose>;
+        paginationOptions: import("zod").ZodObject<{
+            pageNumber: import("zod").ZodDefault<import("zod").ZodNumber>;
+            pageSize: import("zod").ZodDefault<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$loose>;
+    }, import("zod/v4/core").$loose>;
+}, import("zod/v4/core").$loose>;
+export type ProductListQueryById = InferType<typeof ProductListQueryByIdSchema>;
+export type ProductListQuery = InferType<typeof ProductListQuerySchema>;
+export type ProductListItemsQuery = InferType<typeof ProductListItemQuerySchema>;