@reactionary/core 0.3.15 → 0.3.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactionary/core",
-  "version": "0.3.15",
+  "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

@@ -21,3 +21,4 @@ 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-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-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-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

@@ -21,3 +21,4 @@ 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-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-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>;