@reactionary/core 0.3.8 → 0.3.10

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

@@ -1,39 +1,39 @@
-import z from "zod";
+import * as z from "zod";
 import { CategoryIdentifierSchema, ProductIdentifierSchema } from "../models/identifiers.model.js";
 import { BaseQuerySchema } from "./base.query.js";
 const ProductRecommendationBaseQuerySchema = BaseQuerySchema.extend({
-  numberOfRecommendations: z.number().min(1).max(12).describe("The number of recommendations requested. The provider may return fewer than this number, but should not return more."),
-  labels: z.array(z.string()).optional().describe("The customer segments, quirks, chirps or other labels to which the recommendations can optimize themselves to be relevant. This can be used by the provider to personalize the recommendations based on the preferences and behaviors of users in these segments.")
+  numberOfRecommendations: z.number().min(1).max(12).meta({ description: "The number of recommendations requested. The provider may return fewer than this number, but should not return more." }),
+  labels: z.array(z.string()).optional().meta({ description: "The customer segments, quirks, chirps or other labels to which the recommendations can optimize themselves to be relevant. This can be used by the provider to personalize the recommendations based on the preferences and behaviors of users in these segments." })
 });
 const ProductRecommendationsByCollectionQuerySchema = ProductRecommendationBaseQuerySchema.extend({
-  collectionName: z.string().describe("The name of the collection for which to get product recommendations. This is to access either manually curated lists, or interface marketing rules engines that define zones by name"),
-  sourceProduct: z.array(ProductIdentifierSchema).optional().describe("The products on screen or in the context you are asking for the recommendations. Could be all the variants from the current cart (resolved into their products), or just the variant of the PDP, or the 4 first products of a category."),
+  collectionName: z.string().meta({ description: "The name of the collection for which to get product recommendations. This is to access either manually curated lists, or interface marketing rules engines that define zones by name" }),
+  sourceProduct: z.array(ProductIdentifierSchema).optional().meta({ description: "The products on screen or in the context you are asking for the recommendations. Could be all the variants from the current cart (resolved into their products), or just the variant of the PDP, or the 4 first products of a category." }),
   sourceCategory: CategoryIdentifierSchema.optional().describe("The category identifier to use as a seed for the recommendations. The provider should return recommendations that are relevant to this category, 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. This is optional, as the collection may already be curated to be relevant to a specific product or category, but it can be used by the provider to further personalize the recommendations based on the preferences and behaviors of users who have interacted with this category.")
 });
 const ProductRecommendationProductBasedBaseQuerySchema = ProductRecommendationBaseQuerySchema.extend({
   sourceProduct: ProductIdentifierSchema.describe("The product identifiers for which to get recommendations. The provider should return recommendations that are relevant to these products, 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.")
 });
 const ProductRecommendationAlgorithmFrequentlyBoughtTogetherQuerySchema = ProductRecommendationProductBasedBaseQuerySchema.extend({
-  algorithm: z.literal("frequentlyBoughtTogether").describe("The provider should return recommendations based on products that are frequently bought together with the source products. The provider should leverage the Request Context to personalize the recommendations as much as possible, taking into account factors such as the user's browsing history, purchase history, and demographic information.")
+  algorithm: z.literal("frequentlyBoughtTogether").meta({ description: "The provider should return recommendations based on products that are frequently bought together with the source products. The provider should leverage the Request Context to personalize the recommendations as much as possible, taking into account factors such as the user's browsing history, purchase history, and demographic information." })
 });
 const ProductRecommendationAlgorithmSimilarProductsQuerySchema = ProductRecommendationProductBasedBaseQuerySchema.extend({
-  algorithm: z.literal("similar").describe("The provider should return recommendations based on products that are similar to the source products either visually or data wise")
+  algorithm: z.literal("similar").meta({ description: "The provider should return recommendations based on products that are similar to the source products either visually or data wise" })
 });
 const ProductRecommendationAlgorithmRelatedProductsQuerySchema = ProductRecommendationProductBasedBaseQuerySchema.extend({
-  algorithm: z.literal("related").describe("The provider should return recommendations based on products that are related to the source products. ")
+  algorithm: z.literal("related").meta({ description: "The provider should return recommendations based on products that are related to the source products. " })
 });
 const ProductRecommendationAlgorithmTrendingInCategoryQuerySchema = ProductRecommendationBaseQuerySchema.extend({
-  algorithm: z.literal("trendingInCategory").describe("The provider should return recommendations based on products that are trending in the specified category. The provider should leverage the Request Context to personalize the recommendations as much as possible, taking into account factors such as the user's browsing history, purchase history, and demographic information."),
+  algorithm: z.literal("trendingInCategory").meta({ description: "The provider should return recommendations based on products that are trending in the specified category. The provider should leverage the Request Context to personalize the recommendations as much as possible, taking into account factors such as the user's browsing history, purchase history, and demographic information." }),
   sourceCategory: CategoryIdentifierSchema.describe("The category identifier for which to get trending product recommendations. The provider should return recommendations that are relevant to this category, 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.")
 });
 const ProductRecommendationAlgorithmPopuplarProductsQuerySchema = ProductRecommendationBaseQuerySchema.extend({
-  algorithm: z.literal("popular").describe("The provider should return recommendations based on products that are popular among users. The provider should leverage the Request Context to personalize the recommendations as much as possible, taking into account factors such as the user's browsing history, purchase history, and demographic information.")
+  algorithm: z.literal("popular").meta({ description: "The provider should return recommendations based on products that are popular among users. The provider should leverage the Request Context to personalize the recommendations as much as possible, taking into account factors such as the user's browsing history, purchase history, and demographic information." })
 });
 const ProductRecommendationAlgorithmTopPicksProductsQuerySchema = ProductRecommendationBaseQuerySchema.extend({
-  algorithm: z.literal("topPicks").describe("The provider should return recommendations based on products that are top picks among users. The provider should leverage the Request Context to personalize the recommendations as much as possible, taking into account factors such as the user's browsing history, purchase history, and demographic information.")
+  algorithm: z.literal("topPicks").meta({ description: "The provider should return recommendations based on products that are top picks among users. The provider should leverage the Request Context to personalize the recommendations as much as possible, taking into account factors such as the user's browsing history, purchase history, and demographic information." })
 });
 const ProductRecommendationAlgorithmAlsoViewedProductsQuerySchema = ProductRecommendationProductBasedBaseQuerySchema.extend({
-  algorithm: z.literal("alsoViewed").describe("The provider should return recommendations based on products that are also viewed by users. The provider should leverage the Request Context to personalize the recommendations as much as possible, taking into account factors such as the user's browsing history, purchase history, and demographic information.")
+  algorithm: z.literal("alsoViewed").meta({ description: "The provider should return recommendations based on products that are also viewed by users. The provider should leverage the Request Context to personalize the recommendations as much as possible, taking into account factors such as the user's browsing history, purchase history, and demographic information." })
 });
 const ProductRecommendationsQuerySchema = z.discriminatedUnion("algorithm", [
   ProductRecommendationAlgorithmFrequentlyBoughtTogetherQuerySchema,

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

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 import { CategorySchema } from "../models/category.model.js";
 import { ProductSearchIdentifierSchema } from "../models/identifiers.model.js";
 import { BaseQuerySchema } from "./base.query.js";
@@ -6,8 +6,8 @@ const ProductSearchQueryByTermSchema = BaseQuerySchema.extend({
   search: ProductSearchIdentifierSchema
 });
 const ProductSearchQueryCreateNavigationFilterSchema = z.looseObject({
-  categoryPath: z.array(CategorySchema).describe("An array representing the breadcrumb path to a category, from root to the specific category.")
-}).describe("Payload to create a category navigation filter from a breadcrumb path.");
+  categoryPath: z.array(CategorySchema).meta({ description: "An array representing the breadcrumb path to a category, from root to the specific category." })
+}).meta({ description: "Payload to create a category navigation filter from a breadcrumb path." });
 export {
   ProductSearchQueryByTermSchema,
   ProductSearchQueryCreateNavigationFilterSchema

package/schemas/queries/product.query.js

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 import { BaseQuerySchema } from "./base.query.js";
 import { PaginationOptionsSchema, ProductIdentifierSchema, ProductVariantIdentifierSchema } from "../models/index.js";
 const ProductQueryBySlugSchema = BaseQuerySchema.extend({

package/schemas/queries/store.query.js

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 import { BaseQuerySchema } from "./base.query.js";
 const StoreQueryByProximitySchema = BaseQuerySchema.extend({
   longitude: z.number(),

package/schemas/session.schema.js

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 import { WebStoreIdentifierSchema } from "./models/identifiers.model.js";
 import { CurrencySchema } from "./models/currency.model.js";
 import { IdentitySchema } from "./models/identity.model.js";
@@ -25,11 +25,11 @@ const RequestContextSchema = z.looseObject({
   languageContext: LanguageContextSchema.default(() => LanguageContextSchema.parse({})).describe("ReadOnly. The language and locale context for the current request."),
   storeIdentifier: WebStoreIdentifierSchema.default(() => WebStoreIdentifierSchema.parse({})).describe("ReadOnly. The identifier of the current web store making the request."),
   taxJurisdiction: TaxJurisdictionSchema.default(() => TaxJurisdictionSchema.parse({})).describe("ReadOnly. The tax jurisdiction for the current request, typically derived from the store location or carts billing address"),
-  correlationId: z.string().default("").describe("A unique identifier for the request, can be used for tracing and logging purposes."),
-  isBot: z.boolean().default(false).describe("Indicates if the request is made by a bot or crawler."),
-  clientIp: z.string().default("").describe("The IP address of the client making the request, if available. Mostly for logging purposes"),
-  userAgent: z.string().default("").describe("The user agent string of the client making the request, if available."),
-  referrer: z.string().default("").describe("The referrer URL, if available.")
+  correlationId: z.string().default("").meta({ description: "A unique identifier for the request, can be used for tracing and logging purposes." }),
+  isBot: z.boolean().default(false).meta({ description: "Indicates if the request is made by a bot or crawler." }),
+  clientIp: z.string().default("").meta({ description: "The IP address of the client making the request, if available. Mostly for logging purposes" }),
+  userAgent: z.string().default("").meta({ description: "The user agent string of the client making the request, if available." }),
+  referrer: z.string().default("").meta({ description: "The referrer URL, if available." })
 });
 export {
   IdentityContextSchema,

package/src/cache/cache.interface.d.ts

@@ -1,4 +1,4 @@
-import type { z } from 'zod';
+import type * as z from 'zod';
 import type { BaseModel } from '../schemas/models/index.js';
 export interface CacheEntryOptions {
     ttlSeconds: number;

package/src/cache/memory-cache.d.ts

@@ -1,7 +1,7 @@
 import type { BaseModel } from '../schemas/models/index.js';
 import type { Result } from '../schemas/result.js';
 import type { Cache, CacheEntryOptions } from './cache.interface.js';
-import type z from 'zod';
+import type * as z from 'zod';
 /**
  * Memory version of the cache. Primarily useful for local development.
  * This is NOT suited for production use.

package/src/cache/noop-cache.d.ts

@@ -1,5 +1,5 @@
 import type { Cache, CacheEntryOptions } from './cache.interface.js';
-import type z from 'zod';
+import type * as z from 'zod';
 /**
  * No-op cache implementation that never stores or returns data.
  * Useful for testing or when caching should be disabled.

package/src/cache/redis-cache.d.ts

@@ -1,6 +1,6 @@
 import { Redis } from '@upstash/redis';
 import type { Cache, CacheEntryOptions } from './cache.interface.js';
-import type z from 'zod';
+import type * as z from 'zod';
 export declare class RedisCache implements Cache {
     protected redis: Redis;
     protected meter: import("../metrics/metrics.js").ReactionaryCacheMetrics;

package/src/decorators/reactionary.decorator.d.ts

@@ -1,5 +1,5 @@
 import type { Tracer } from '@opentelemetry/api';
-import { z } from 'zod';
+import * as z from 'zod';
 import type { BaseProvider } from '../providers/index.js';
 import { type Result } from '../schemas/result.js';
 export declare function getTracer(): Tracer;

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import * as z from 'zod';
 import type { InferType } from '../zod-utils.js';
 import type { Client } from '../client/client.js';
 export declare const CapabilitiesSchema: z.ZodObject<{

package/src/schemas/errors/generic.error.d.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import * as z from 'zod';
 import type { InferType } from '../../zod-utils.js';
 export declare const GenericErrorSchema: z.ZodObject<{
     type: z.ZodLiteral<"Generic">;

package/src/schemas/errors/invalid-input.error.d.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import * as z from 'zod';
 import type { InferType } from '../../zod-utils.js';
 export declare const InvalidInputErrorSchema: z.ZodObject<{
     type: z.ZodLiteral<"InvalidInput">;

package/src/schemas/errors/invalid-output.error.d.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import * as z from 'zod';
 import type { InferType } from '../../zod-utils.js';
 export declare const InvalidOutputErrorSchema: z.ZodObject<{
     type: z.ZodLiteral<"InvalidOutput">;

package/src/schemas/errors/not-found.error.d.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import * as z from 'zod';
 import type { InferType } from '../../zod-utils.js';
 export declare const NotFoundErrorSchema: z.ZodObject<{
     type: z.ZodLiteral<"NotFound">;

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

@@ -1,4 +1,4 @@
-import type { z } from 'zod';
+import type * as z from 'zod';
 import type { InferType } from '../../zod-utils.js';
 export declare const AnalyticsEventSchema: z.ZodObject<{}, z.core.$loose>;
 export type AnalyticsEvent = InferType<typeof AnalyticsEventSchema>;

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import * as z from 'zod';
 import type { InferType } from '../../zod-utils.js';
 export declare const BaseModelSchema: z.ZodObject<{}, z.core.$loose>;
 export declare const PaginationOptionsSchema: z.ZodObject<{

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import * as z from 'zod';
 import type { InferType } from '../../zod-utils.js';
 export declare const CartItemSchema: z.ZodObject<{
     identifier: z.ZodDefault<z.ZodObject<{

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import * as z from 'zod';
 import type { InferType } from '../../zod-utils.js';
 export declare const CategorySchema: z.ZodObject<{
     identifier: z.ZodDefault<z.ZodObject<{

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import * as z from 'zod';
 import type { InferType } from '../../zod-utils.js';
 export declare const CheckoutItemSchema: z.ZodObject<{
     identifier: z.ZodDefault<z.ZodObject<{

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

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 import type { InferType } from '../../zod-utils.js';
 export declare const CostBreakDownSchema: z.ZodObject<{
     totalTax: z.ZodDefault<z.ZodObject<{

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import * as z from 'zod';
 import type { InferType } from '../../zod-utils.js';
 export declare const CurrencySchema: z.ZodEnum<{
     AED: "AED";

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import * as z from 'zod';
 import type { InferType } from '../../zod-utils.js';
 export declare const OrderStatusSchema: z.ZodEnum<{
     AwaitingPayment: "AwaitingPayment";

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import * as z from 'zod';
 import type { InferType } from '../../zod-utils.js';
 export declare const AnonymousIdentitySchema: z.ZodObject<{
     type: z.ZodLiteral<"Anonymous">;

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import * as z from 'zod';
 import type { InferType } from '../../zod-utils.js';
 export declare const InventoryStatusSchema: z.ZodEnum<{
     inStock: "inStock";

package/src/schemas/models/order-search.model.d.ts

@@ -1,17 +1,17 @@
-import z from "zod";
+import * as z from "zod";
 import type { InferType } from "../../zod-utils.js";
 export declare const OrderSearchResultItemSchema: z.ZodObject<{
     identifier: z.ZodObject<{
         key: z.ZodString;
-    }, z.z.core.$loose>;
+    }, z.core.$loose>;
     userId: z.ZodObject<{
         userId: z.ZodString;
-    }, z.z.core.$loose>;
+    }, z.core.$loose>;
     customerName: z.ZodString;
     shippingAddress: z.ZodOptional<z.ZodObject<{
         identifier: z.ZodDefault<z.ZodObject<{
             nickName: z.ZodString;
-        }, z.z.core.$loose>>;
+        }, z.core.$loose>>;
         firstName: z.ZodString;
         lastName: z.ZodString;
         streetAddress: z.ZodString;
@@ -20,7 +20,7 @@ export declare const OrderSearchResultItemSchema: z.ZodObject<{
         region: z.ZodString;
         postalCode: z.ZodString;
         countryCode: z.ZodString;
-    }, z.z.core.$loose>>;
+    }, z.core.$loose>>;
     orderDate: z.ZodString;
     orderStatus: z.ZodEnum<{
         AwaitingPayment: "AwaitingPayment";
@@ -219,8 +219,8 @@ export declare const OrderSearchResultItemSchema: z.ZodObject<{
             ZMW: "ZMW";
             ZWL: "ZWL";
         }>;
-    }, z.z.core.$loose>;
-}, z.z.core.$loose>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
 export declare const OrderSearchResultSchema: z.ZodObject<{
     pageNumber: z.ZodNumber;
     pageSize: z.ZodNumber;
@@ -229,15 +229,15 @@ export declare const OrderSearchResultSchema: z.ZodObject<{
     items: z.ZodArray<z.ZodObject<{
         identifier: z.ZodObject<{
             key: z.ZodString;
-        }, z.z.core.$loose>;
+        }, z.core.$loose>;
         userId: z.ZodObject<{
             userId: z.ZodString;
-        }, z.z.core.$loose>;
+        }, z.core.$loose>;
         customerName: z.ZodString;
         shippingAddress: z.ZodOptional<z.ZodObject<{
             identifier: z.ZodDefault<z.ZodObject<{
                 nickName: z.ZodString;
-            }, z.z.core.$loose>>;
+            }, z.core.$loose>>;
             firstName: z.ZodString;
             lastName: z.ZodString;
             streetAddress: z.ZodString;
@@ -246,7 +246,7 @@ export declare const OrderSearchResultSchema: z.ZodObject<{
             region: z.ZodString;
             postalCode: z.ZodString;
             countryCode: z.ZodString;
-        }, z.z.core.$loose>>;
+        }, z.core.$loose>>;
         orderDate: z.ZodString;
         orderStatus: z.ZodEnum<{
             AwaitingPayment: "AwaitingPayment";
@@ -445,8 +445,8 @@ export declare const OrderSearchResultSchema: z.ZodObject<{
                 ZMW: "ZMW";
                 ZWL: "ZWL";
             }>;
-        }, z.z.core.$loose>;
-    }, z.z.core.$loose>>;
+        }, z.core.$loose>;
+    }, z.core.$loose>>;
     identifier: z.ZodObject<{
         term: z.ZodString;
         partNumber: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -458,15 +458,15 @@ export declare const OrderSearchResultSchema: z.ZodObject<{
         }>>>;
         user: z.ZodOptional<z.ZodObject<{
             userId: z.ZodString;
-        }, z.z.core.$loose>>;
+        }, z.core.$loose>>;
         startDate: z.ZodOptional<z.ZodString>;
         endDate: z.ZodOptional<z.ZodString>;
         filters: z.ZodArray<z.ZodString>;
         paginationOptions: z.ZodObject<{
             pageNumber: z.ZodDefault<z.ZodNumber>;
             pageSize: z.ZodDefault<z.ZodNumber>;
-        }, z.z.core.$loose>;
-    }, z.z.core.$loose>;
-}, z.z.core.$strip>;
+        }, z.core.$loose>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
 export type OrderSearchResult = InferType<typeof OrderSearchResultSchema>;
 export type OrderSearchResultItem = InferType<typeof OrderSearchResultItemSchema>;

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import * as z from 'zod';
 import { OrderInventoryStatusSchema, OrderStatusSchema } from '../models/identifiers.model.js';
 import type { InferType } from '../../zod-utils.js';
 export declare const OrderItemSchema: z.ZodObject<{

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import * as z from 'zod';
 import type { InferType } from '../../zod-utils.js';
 export declare const PaymentStatusSchema: z.ZodEnum<{
     pending: "pending";

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import * as z from 'zod';
 import type { InferType } from '../../zod-utils.js';
 export declare const MonetaryAmountSchema: z.ZodObject<{
     value: z.ZodNumber;

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

@@ -1,109 +1,110 @@
-import z from "zod";
+import * as z from "zod";
+import type { InferType } from "../../zod-utils.js";
 export declare const BaseProductRecommendationSchema: z.ZodObject<{
     recommendationIdentifier: z.ZodObject<{
         key: z.ZodString;
         algorithm: z.ZodString;
-    }, z.z.core.$loose>;
-}, z.z.core.$loose>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
 export declare const ProductRecommendationIdOnlySchema: z.ZodObject<{
     recommendationIdentifier: z.ZodObject<{
         key: z.ZodString;
         algorithm: z.ZodString;
-    }, z.z.core.$loose>;
+    }, z.core.$loose>;
     recommendationReturnType: z.ZodLiteral<"idOnly">;
     product: z.ZodObject<{
         key: z.ZodString;
-    }, z.z.core.$loose>;
-}, z.z.core.$loose>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
 export declare const ProductRecommendationProductSearchResultItemSchema: z.ZodObject<{
     recommendationIdentifier: z.ZodObject<{
         key: z.ZodString;
         algorithm: z.ZodString;
-    }, z.z.core.$loose>;
+    }, z.core.$loose>;
     recommendationReturnType: z.ZodLiteral<"productSearchResultItem">;
     product: z.ZodObject<{
         identifier: z.ZodObject<{
             key: z.ZodString;
-        }, z.z.core.$loose>;
+        }, z.core.$loose>;
         name: z.ZodString;
         slug: z.ZodString;
         variants: z.ZodArray<z.ZodObject<{
             variant: z.ZodObject<{
                 sku: z.ZodString;
-            }, z.z.core.$loose>;
+            }, z.core.$loose>;
             image: z.ZodObject<{
                 sourceUrl: z.ZodDefault<z.ZodString>;
                 altText: z.ZodDefault<z.ZodString>;
                 width: z.ZodOptional<z.ZodNumber>;
                 height: z.ZodOptional<z.ZodNumber>;
-            }, z.z.core.$loose>;
+            }, z.core.$loose>;
             options: z.ZodOptional<z.ZodObject<{
                 identifier: z.ZodObject<{
                     key: z.ZodString;
-                }, z.z.core.$loose>;
+                }, z.core.$loose>;
                 name: z.ZodString;
                 value: z.ZodObject<{
                     identifier: z.ZodObject<{
                         option: z.ZodObject<{
                             key: z.ZodString;
-                        }, z.z.core.$loose>;
+                        }, z.core.$loose>;
                         key: z.ZodString;
-                    }, z.z.core.$loose>;
+                    }, z.core.$loose>;
                     label: z.ZodString;
-                }, z.z.core.$loose>;
-            }, z.z.core.$loose>>;
-        }, z.z.core.$loose>>;
-    }, z.z.core.$loose>;
-}, z.z.core.$loose>;
+                }, z.core.$loose>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
 export declare const ProductRecommendationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     recommendationIdentifier: z.ZodObject<{
         key: z.ZodString;
         algorithm: z.ZodString;
-    }, z.z.core.$loose>;
+    }, z.core.$loose>;
     recommendationReturnType: z.ZodLiteral<"idOnly">;
     product: z.ZodObject<{
         key: z.ZodString;
-    }, z.z.core.$loose>;
-}, z.z.core.$loose>, z.ZodObject<{
+    }, z.core.$loose>;
+}, z.core.$loose>, z.ZodObject<{
     recommendationIdentifier: z.ZodObject<{
         key: z.ZodString;
         algorithm: z.ZodString;
-    }, z.z.core.$loose>;
+    }, z.core.$loose>;
     recommendationReturnType: z.ZodLiteral<"productSearchResultItem">;
     product: z.ZodObject<{
         identifier: z.ZodObject<{
             key: z.ZodString;
-        }, z.z.core.$loose>;
+        }, z.core.$loose>;
         name: z.ZodString;
         slug: z.ZodString;
         variants: z.ZodArray<z.ZodObject<{
             variant: z.ZodObject<{
                 sku: z.ZodString;
-            }, z.z.core.$loose>;
+            }, z.core.$loose>;
             image: z.ZodObject<{
                 sourceUrl: z.ZodDefault<z.ZodString>;
                 altText: z.ZodDefault<z.ZodString>;
                 width: z.ZodOptional<z.ZodNumber>;
                 height: z.ZodOptional<z.ZodNumber>;
-            }, z.z.core.$loose>;
+            }, z.core.$loose>;
             options: z.ZodOptional<z.ZodObject<{
                 identifier: z.ZodObject<{
                     key: z.ZodString;
-                }, z.z.core.$loose>;
+                }, z.core.$loose>;
                 name: z.ZodString;
                 value: z.ZodObject<{
                     identifier: z.ZodObject<{
                         option: z.ZodObject<{
                             key: z.ZodString;
-                        }, z.z.core.$loose>;
+                        }, z.core.$loose>;
                         key: z.ZodString;
-                    }, z.z.core.$loose>;
+                    }, z.core.$loose>;
                     label: z.ZodString;
-                }, z.z.core.$loose>;
-            }, z.z.core.$loose>>;
-        }, z.z.core.$loose>>;
-    }, z.z.core.$loose>;
-}, z.z.core.$loose>], "recommendationReturnType">;
-export type ProductRecommendationIdOnly = z.infer<typeof ProductRecommendationIdOnlySchema>;
-export type ProductRecommendationSearchItem = z.infer<typeof ProductRecommendationProductSearchResultItemSchema>;
-export type ProductRecommendation = z.infer<typeof ProductRecommendationSchema>;
+                }, z.core.$loose>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>;
+}, z.core.$loose>], "recommendationReturnType">;
+export type ProductRecommendationIdOnly = InferType<typeof ProductRecommendationIdOnlySchema>;
+export type ProductRecommendationSearchItem = InferType<typeof ProductRecommendationProductSearchResultItemSchema>;
+export type ProductRecommendation = InferType<typeof ProductRecommendationSchema>;

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import * as z from 'zod';
 import type { InferType } from '../../zod-utils.js';
 export declare const ProductSearchResultItemVariantSchema: z.ZodObject<{
     variant: z.ZodObject<{

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import * as z from 'zod';
 import type { InferType } from '../../zod-utils.js';
 export declare const ProductOptionValueSchema: z.ZodObject<{
     identifier: z.ZodObject<{

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

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 import type { InferType } from '../../zod-utils.js';
 export declare const AddressSchema: z.ZodObject<{
     identifier: z.ZodDefault<z.ZodObject<{

package/src/schemas/models/shipping-method.model.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 import type { InferType } from '../../zod-utils.js';
 export declare const PickupPointSchema: z.ZodObject<{
     identifier: z.ZodObject<{

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import * as z from 'zod';
 import type { InferType } from '../../zod-utils.js';
 export declare const StoreSchema: z.ZodObject<{
     identifier: z.ZodObject<{