@reactionary/core 0.0.80 → 0.0.82

package/schemas/models/product.model.js

@@ -2,53 +2,53 @@ import { z } from "zod";
 import { CategoryIdentifierSchema, ProductAttributeIdentifierSchema, ProductAttributeValueIdentifierSchema, ProductIdentifierSchema, ProductOptionIdentifierSchema, ProductOptionValueIdentifierSchema, ProductVariantIdentifierSchema } from "./identifiers.model.js";
 import { BaseModelSchema, ImageSchema } from "./base.model.js";
 const ProductOptionValueSchema = z.looseObject({
-  identifier: ProductOptionValueIdentifierSchema.default(() => ProductOptionValueIdentifierSchema.parse({})).describe("The unique identifier for the product option value."),
+  identifier: ProductOptionValueIdentifierSchema.describe("The unique identifier for the product option value."),
   label: z.string().describe("The human-friendly label for the product option value.")
 });
 const ProductOptionSchema = z.looseObject({
-  identifier: ProductOptionIdentifierSchema.default(() => ProductOptionIdentifierSchema.parse({})).describe("The unique identifier for the option."),
+  identifier: ProductOptionIdentifierSchema.describe("The unique identifier for the option."),
   name: z.string().describe("The name of the option, e.g., Size or Color."),
-  values: z.array(ProductOptionValueSchema).default(() => []).describe("A list of possible values for the option.")
+  values: z.array(ProductOptionValueSchema).describe("A list of possible values for the option.")
 });
 const ProductVariantOptionSchema = z.looseObject({
-  identifier: ProductOptionIdentifierSchema.default(() => ProductOptionIdentifierSchema.parse({})).describe("The unique identifier for the option."),
+  identifier: ProductOptionIdentifierSchema.describe("The unique identifier for the option."),
   name: z.string().describe("The name of the option, e.g., Size or Color."),
-  value: ProductOptionValueSchema.default(() => ProductOptionValueSchema.parse({})).describe("The unique identifier for the option value.")
+  value: ProductOptionValueSchema.describe("The unique identifier for the option value.")
 });
 const ProductVariantSchema = z.looseObject({
-  identifier: ProductVariantIdentifierSchema.default(() => ProductVariantIdentifierSchema.parse({})).describe("The unique identifier for the variant. Often its SKU"),
-  name: z.string().default(""),
-  images: z.array(ImageSchema).default(() => []).describe("A list of images associated with the product variant"),
-  ean: z.string().default("").describe("The European Article Number identifier for the product variant"),
-  gtin: z.string().default("").describe("The Global Trade Item Number identifier for the product variant"),
-  upc: z.string().default("").describe("The Universal Product Code identifier for the product variant"),
-  barcode: z.string().default("").describe("The barcode identifier for the product variant"),
-  options: z.array(ProductVariantOptionSchema).default(() => []).describe("A list of option identifiers that define this variant")
+  identifier: ProductVariantIdentifierSchema.describe("The unique identifier for the variant. Often its SKU"),
+  name: z.string(),
+  images: z.array(ImageSchema).describe("A list of images associated with the product variant"),
+  ean: z.string().describe("The European Article Number identifier for the product variant"),
+  gtin: z.string().describe("The Global Trade Item Number identifier for the product variant"),
+  upc: z.string().describe("The Universal Product Code identifier for the product variant"),
+  barcode: z.string().describe("The barcode identifier for the product variant"),
+  options: z.array(ProductVariantOptionSchema).describe("A list of option identifiers that define this variant")
 });
 const ProductAttributeValueSchema = z.looseObject({
-  identifier: ProductAttributeValueIdentifierSchema.default(() => ProductAttributeValueIdentifierSchema.parse({})).describe("The unique identifier for the attribute value."),
-  value: z.string().default("").describe("The value of the attribute. Typically a language independent string"),
-  label: z.string().default("").describe("The human friendly label for the attribute value. Typically a language dependent string")
+  identifier: ProductAttributeValueIdentifierSchema.describe("The unique identifier for the attribute value."),
+  value: z.string().describe("The value of the attribute. Typically a language independent string"),
+  label: z.string().describe("The human friendly label for the attribute value. Typically a language dependent string")
 });
 const ProductAttributeSchema = z.looseObject({
-  identifier: ProductAttributeIdentifierSchema.default(() => ProductAttributeIdentifierSchema.parse({})).describe("The unique identifier for the attribute, also typically used as the facet key if the attribute is filterable."),
-  group: z.string().default(""),
-  name: z.string().default(""),
-  values: z.array(ProductAttributeValueSchema).default(() => [])
+  identifier: ProductAttributeIdentifierSchema.describe("The unique identifier for the attribute, also typically used as the facet key if the attribute is filterable."),
+  group: z.string(),
+  name: z.string(),
+  values: z.array(ProductAttributeValueSchema)
 });
 const ProductSchema = BaseModelSchema.extend({
-  identifier: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({})),
-  name: z.string().default("").describe("The name of the product"),
-  slug: z.string().default("").describe("The URL-friendly identifier for the product"),
-  description: z.string().default("").describe("A brief description of the product"),
-  longDescription: z.string().default("").describe("A detailed description of the product"),
-  brand: z.string().default("").describe("The brand associated with the product"),
-  manufacturer: z.string().default("").describe("The manufacturer of the product"),
-  parentCategories: z.array(CategoryIdentifierSchema).default(() => []).describe("A list of parent categories the product belongs to"),
-  published: z.boolean().default(false).describe("Indicates whether the product is published and visible to customers"),
-  sharedAttributes: z.array(ProductAttributeSchema).default(() => []).describe("A list of technical attributes associated with the product"),
-  options: z.array(ProductOptionSchema).default(() => []).describe("A list of options available for the product, such as size or color. Can be empty if product is single-sku"),
-  mainVariant: ProductVariantSchema.default(() => ProductVariantSchema.parse({})).describe("The primary SKU for the product")
+  identifier: ProductIdentifierSchema,
+  name: z.string().describe("The name of the product"),
+  slug: z.string().describe("The URL-friendly identifier for the product"),
+  description: z.string().describe("A brief description of the product"),
+  longDescription: z.string().describe("A detailed description of the product"),
+  brand: z.string().describe("The brand associated with the product"),
+  manufacturer: z.string().describe("The manufacturer of the product"),
+  parentCategories: z.array(CategoryIdentifierSchema).describe("A list of parent categories the product belongs to"),
+  published: z.boolean().describe("Indicates whether the product is published and visible to customers"),
+  sharedAttributes: z.array(ProductAttributeSchema).describe("A list of technical attributes associated with the product"),
+  options: z.array(ProductOptionSchema).describe("A list of options available for the product, such as size or color. Can be empty if product is single-sku"),
+  mainVariant: ProductVariantSchema.describe("The primary SKU for the product")
 }).describe("A product is a wrapper around sellable items. It contains all the shared information for a set of SKUs. All products have at least one SKU, but can potentially have hundreds.");
 export {
   ProductAttributeSchema,

package/schemas/models/profile.model.js

@@ -3,26 +3,26 @@ import { AddressIdentifierSchema, IdentityIdentifierSchema } from "./identifiers
 import { BaseModelSchema } from "./base.model.js";
 const AddressSchema = BaseModelSchema.extend({
   identifier: AddressIdentifierSchema.default(() => AddressIdentifierSchema.parse({})),
-  firstName: z.string().default(""),
-  lastName: z.string().default(""),
-  streetAddress: z.string().default(""),
-  streetNumber: z.string().default(""),
-  city: z.string().default(""),
-  region: z.string().default(""),
-  postalCode: z.string().default(""),
-  countryCode: z.string().default("US")
+  firstName: z.string(),
+  lastName: z.string(),
+  streetAddress: z.string(),
+  streetNumber: z.string(),
+  city: z.string(),
+  region: z.string(),
+  postalCode: z.string(),
+  countryCode: z.string()
 });
 const ProfileSchema = BaseModelSchema.extend({
-  identifier: IdentityIdentifierSchema.default(() => IdentityIdentifierSchema.parse({})),
-  email: z.string().email().default(""),
-  phone: z.string().default(""),
-  emailVerified: z.boolean().default(false),
-  phoneVerified: z.boolean().default(false),
-  createdAt: z.string().default(() => (/* @__PURE__ */ new Date()).toISOString()),
-  updatedAt: z.string().default(() => (/* @__PURE__ */ new Date()).toISOString()),
+  identifier: IdentityIdentifierSchema,
+  email: z.email(),
+  phone: z.string(),
+  emailVerified: z.boolean(),
+  phoneVerified: z.boolean(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
   shippingAddress: AddressSchema.optional(),
   billingAddress: AddressSchema.optional(),
-  alternateShippingAddresses: z.array(AddressSchema).default(() => [])
+  alternateShippingAddresses: z.array(AddressSchema)
 });
 export {
   AddressSchema,

package/schemas/models/shipping-method.model.js

@@ -5,30 +5,30 @@ import { BaseModelSchema, ImageSchema } from "./base.model.js";
 import { AddressSchema } from "./profile.model.js";
 const PickupPointSchema = z.looseObject({
   identifier: z.object({
-    key: z.string().default("").nonoptional()
-  }).default(() => ({ key: "" })),
-  name: z.string().default(""),
-  description: z.string().default(""),
-  address: AddressSchema.default(() => AddressSchema.parse({})),
-  openingHours: z.string().default("").optional().describe('The opening hours of the pickup point, if applicable. This could be a string like "Mon-Fri 9am-5pm".'),
-  contactPhone: z.string().default("").optional().describe("The contact phone number for the pickup point, if applicable."),
-  contactEmail: z.string().default("").optional().describe("The contact email for the pickup point, if applicable."),
-  instructions: z.string().default("").optional().describe("Any special instructions for picking up from this point.")
+    key: z.string()
+  }),
+  name: z.string(),
+  description: z.string(),
+  address: AddressSchema,
+  openingHours: z.string().optional().describe('The opening hours of the pickup point, if applicable. This could be a string like "Mon-Fri 9am-5pm".'),
+  contactPhone: z.string().optional().describe("The contact phone number for the pickup point, if applicable."),
+  contactEmail: z.string().optional().describe("The contact email for the pickup point, if applicable."),
+  instructions: z.string().optional().describe("Any special instructions for picking up from this point.")
 });
 const ShippingMethodSchema = z.looseObject({
-  identifier: ShippingMethodIdentifierSchema.default(() => ShippingMethodIdentifierSchema.parse({})),
-  name: z.string().default(""),
-  description: z.string().default(""),
+  identifier: ShippingMethodIdentifierSchema,
+  name: z.string(),
+  description: z.string(),
   logo: ImageSchema.optional(),
-  price: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})),
-  deliveryTime: z.string().default(""),
-  carrier: z.string().default("").optional()
+  price: MonetaryAmountSchema,
+  deliveryTime: z.string(),
+  carrier: z.string().optional()
 });
 const ShippingInstructionSchema = BaseModelSchema.extend({
-  shippingMethod: ShippingMethodIdentifierSchema.default(() => ShippingMethodIdentifierSchema.parse({})),
-  pickupPoint: z.string().default("").describe("An optional pickup point for the shipping method. This could be a physical store, a locker, or similar. If not set, it means home delivery to the shipping address."),
-  instructions: z.string().default("").describe("Optional instructions for the shipping. This could be delivery instructions, or similar."),
-  consentForUnattendedDelivery: z.boolean().default(false).describe("Indicates if the customer has given consent for unattended delivery, if applicable.")
+  shippingMethod: ShippingMethodIdentifierSchema,
+  pickupPoint: z.string().describe("An optional pickup point for the shipping method. This could be a physical store, a locker, or similar. If not set, it means home delivery to the shipping address."),
+  instructions: z.string().describe("Optional instructions for the shipping. This could be delivery instructions, or similar."),
+  consentForUnattendedDelivery: z.boolean().describe("Indicates if the customer has given consent for unattended delivery, if applicable.")
 });
 export {
   PickupPointSchema,

package/schemas/models/store.model.js

@@ -1,10 +1,13 @@
 import { z } from "zod";
 import { BaseModelSchema } from "./base.model.js";
-import { FulfillmentCenterIdentifierSchema, StoreIdentifierSchema } from "./identifiers.model.js";
+import {
+  FulfillmentCenterIdentifierSchema,
+  StoreIdentifierSchema
+} from "./identifiers.model.js";
 const StoreSchema = BaseModelSchema.extend({
-  identifier: StoreIdentifierSchema.default(() => StoreIdentifierSchema.parse({})),
-  name: z.string().default(""),
-  fulfillmentCenter: FulfillmentCenterIdentifierSchema.default(() => FulfillmentCenterIdentifierSchema.parse({}))
+  identifier: StoreIdentifierSchema,
+  name: z.string(),
+  fulfillmentCenter: FulfillmentCenterIdentifierSchema
 });
 export {
   StoreSchema

package/schemas/mutations/analytics.mutation.js

@@ -3,13 +3,13 @@ import { BaseMutationSchema } from "./base.mutation.js";
 import { ProductIdentifierSchema, ProductSearchIdentifierSchema } from "../models/identifiers.model.js";
 const AnalyticsMutationSearchEventSchema = BaseMutationSchema.extend({
   mutation: z.literal("search"),
-  search: ProductSearchIdentifierSchema.required(),
+  search: ProductSearchIdentifierSchema,
   products: z.array(ProductIdentifierSchema)
 });
 const AnalyticsMutationSearchProductClickEventSchema = BaseMutationSchema.extend({
   mutation: z.literal("product-search-click"),
-  search: ProductSearchIdentifierSchema.required(),
-  product: ProductIdentifierSchema.required(),
+  search: ProductSearchIdentifierSchema,
+  product: ProductIdentifierSchema,
   position: z.number().min(0)
 });
 const AnalyticsMutationSchema = z.union([AnalyticsMutationSearchEventSchema, AnalyticsMutationSearchProductClickEventSchema]);

package/schemas/mutations/cart.mutation.js

@@ -5,55 +5,55 @@ import { AddressSchema } from "../models/profile.model.js";
 import { CurrencySchema } from "../models/currency.model.js";
 import { MonetaryAmountSchema } from "../models/price.model.js";
 const CartMutationItemAddSchema = BaseMutationSchema.extend({
-  cart: CartIdentifierSchema.nonoptional(),
-  variant: ProductVariantIdentifierSchema.nonoptional(),
+  cart: CartIdentifierSchema,
+  variant: ProductVariantIdentifierSchema,
   quantity: z.number()
 });
 const CartMutationItemRemoveSchema = BaseMutationSchema.extend({
-  cart: CartIdentifierSchema.nonoptional(),
-  item: CartItemIdentifierSchema.nonoptional()
+  cart: CartIdentifierSchema,
+  item: CartItemIdentifierSchema
 });
 const CartMutationItemQuantityChangeSchema = BaseMutationSchema.extend({
-  cart: CartIdentifierSchema.nonoptional(),
-  item: CartItemIdentifierSchema.nonoptional(),
+  cart: CartIdentifierSchema,
+  item: CartItemIdentifierSchema,
   quantity: z.number()
 });
 const CartMutationDeleteCartSchema = BaseMutationSchema.extend({
-  cart: CartIdentifierSchema.required()
+  cart: CartIdentifierSchema
 });
 const CartMutationSetShippingInfoSchema = BaseMutationSchema.extend({
-  cart: CartIdentifierSchema.required(),
+  cart: CartIdentifierSchema,
   shippingMethod: ShippingMethodIdentifierSchema.optional(),
   shippingAddress: AddressSchema.optional()
 });
 const CartMutationSetBillingAddressSchema = BaseMutationSchema.extend({
-  cart: CartIdentifierSchema.required(),
-  billingAddress: AddressSchema.required(),
+  cart: CartIdentifierSchema,
+  billingAddress: AddressSchema,
   notificationEmailAddress: z.string().optional(),
   notificationPhoneNumber: z.string().optional()
 });
 const CartMutationApplyCouponSchema = BaseMutationSchema.extend({
-  cart: CartIdentifierSchema.required(),
-  couponCode: z.string().default("").nonoptional()
+  cart: CartIdentifierSchema,
+  couponCode: z.string()
 });
 const CartMutationRemoveCouponSchema = BaseMutationSchema.extend({
-  cart: CartIdentifierSchema.required(),
-  couponCode: z.string().default("").nonoptional()
+  cart: CartIdentifierSchema,
+  couponCode: z.string()
 });
 const CartMutationCheckoutSchema = BaseMutationSchema.extend({
-  cart: CartIdentifierSchema.required()
+  cart: CartIdentifierSchema
 });
 const CartMutationAddPaymentMethodSchema = BaseMutationSchema.extend({
-  cart: CartIdentifierSchema.required(),
-  paymentMethodId: PaymentMethodIdentifierSchema.required(),
+  cart: CartIdentifierSchema,
+  paymentMethodId: PaymentMethodIdentifierSchema,
   amount: MonetaryAmountSchema.optional().describe("The amount to authorize for the payment method. If not provided, the full remaining balance of the cart will be authorized.")
 });
 const CartMutationRemovePaymentMethodSchema = BaseMutationSchema.extend({
-  cart: CartIdentifierSchema.required()
+  cart: CartIdentifierSchema
 });
 const CartMutationChangeCurrencySchema = BaseMutationSchema.extend({
   cart: CartIdentifierSchema.required(),
-  newCurrency: CurrencySchema.default(() => CurrencySchema.parse({})).describe("The new currency to set for the cart.")
+  newCurrency: CurrencySchema.describe("The new currency to set for the cart.")
 });
 export {
   CartMutationAddPaymentMethodSchema,

package/schemas/mutations/checkout.mutation.js

@@ -2,29 +2,29 @@ import { z } from "zod";
 import { CartIdentifierSchema, AddressSchema, PaymentInstructionIdentifierSchema, PaymentInstructionSchema, ShippingInstructionSchema, CartSchema } from "../models/index.js";
 import { BaseMutationSchema } from "./base.mutation.js";
 const CheckoutMutationInitiateCheckoutSchema = BaseMutationSchema.extend({
-  cart: CartSchema.required(),
+  cart: CartSchema,
   billingAddress: AddressSchema.omit({ identifier: true, meta: true }).optional(),
   notificationEmail: z.string().optional(),
   notificationPhone: z.string().optional()
 });
 const CheckoutMutationSetShippingAddressSchema = BaseMutationSchema.extend({
-  checkout: CartIdentifierSchema.required(),
-  shippingAddress: AddressSchema.omit({ identifier: true, meta: true }).required()
+  checkout: CartIdentifierSchema,
+  shippingAddress: AddressSchema.omit({ identifier: true, meta: true })
 });
 const CheckoutMutationFinalizeCheckoutSchema = BaseMutationSchema.extend({
-  checkout: CartIdentifierSchema.required()
+  checkout: CartIdentifierSchema
 });
 const CheckoutMutationAddPaymentInstructionSchema = BaseMutationSchema.extend({
-  paymentInstruction: PaymentInstructionSchema.omit({ meta: true, status: true, identifier: true }).required(),
-  checkout: CartIdentifierSchema.required()
+  paymentInstruction: PaymentInstructionSchema.omit({ meta: true, status: true, identifier: true }),
+  checkout: CartIdentifierSchema
 });
 const CheckoutMutationRemovePaymentInstructionSchema = BaseMutationSchema.extend({
-  paymentInstruction: PaymentInstructionIdentifierSchema.required(),
-  checkout: CartIdentifierSchema.required()
+  paymentInstruction: PaymentInstructionIdentifierSchema,
+  checkout: CartIdentifierSchema
 });
 const CheckoutMutationSetShippingInstructionSchema = BaseMutationSchema.extend({
-  shippingInstruction: ShippingInstructionSchema.omit({ meta: true }).required(),
-  checkout: CartIdentifierSchema.required()
+  shippingInstruction: ShippingInstructionSchema.omit({ meta: true }),
+  checkout: CartIdentifierSchema
 });
 export {
   CheckoutMutationAddPaymentInstructionSchema,

package/schemas/mutations/profile.mutation.js

@@ -1,8 +1,8 @@
 import { z } from "zod";
 import { BaseMutationSchema } from "./base.mutation.js";
 const ProfileMutationUpdateSchema = BaseMutationSchema.extend({
-  email: z.email().default("base@example.com"),
-  phone: z.string().default("")
+  email: z.email(),
+  phone: z.string()
 });
 export {
   ProfileMutationUpdateSchema

package/schemas/queries/cart.query.js

@@ -1,7 +1,7 @@
 import { BaseQuerySchema } from "./base.query.js";
 import { CartIdentifierSchema } from "../models/identifiers.model.js";
 const CartQueryByIdSchema = BaseQuerySchema.extend({
-  cart: CartIdentifierSchema.required()
+  cart: CartIdentifierSchema
 });
 export {
   CartQueryByIdSchema

package/schemas/queries/category.query.js

@@ -3,20 +3,20 @@ import { CategoryIdentifierSchema } from "../models/identifiers.model.js";
 import { BaseQuerySchema } from "./base.query.js";
 import { PaginationOptionsSchema } from "../models/base.model.js";
 const CategoryQueryByIdSchema = BaseQuerySchema.extend({
-  id: CategoryIdentifierSchema.default(() => CategoryIdentifierSchema.parse({}))
+  id: CategoryIdentifierSchema
 });
 const CategoryQueryBySlugSchema = BaseQuerySchema.extend({
-  slug: z.string().default("")
+  slug: z.string()
 });
 const CategoryQueryForBreadcrumbSchema = BaseQuerySchema.extend({
-  id: CategoryIdentifierSchema.default(() => CategoryIdentifierSchema.parse({}))
+  id: CategoryIdentifierSchema
 });
 const CategoryQueryForChildCategoriesSchema = BaseQuerySchema.extend({
-  parentId: CategoryIdentifierSchema.default(() => CategoryIdentifierSchema.parse({})),
-  paginationOptions: PaginationOptionsSchema.default(() => PaginationOptionsSchema.parse({}))
+  parentId: CategoryIdentifierSchema,
+  paginationOptions: PaginationOptionsSchema
 });
 const CategoryQueryForTopCategoriesSchema = BaseQuerySchema.extend({
-  paginationOptions: PaginationOptionsSchema.default(() => PaginationOptionsSchema.parse({}))
+  paginationOptions: PaginationOptionsSchema
 });
 export {
   CategoryQueryByIdSchema,

package/schemas/queries/checkout.query.js

@@ -1,13 +1,13 @@
 import { BaseQuerySchema } from "./base.query.js";
 import { CheckoutIdentifierSchema } from "../models/identifiers.model.js";
 const CheckoutQueryByIdSchema = BaseQuerySchema.extend({
-  identifier: CheckoutIdentifierSchema.required()
+  identifier: CheckoutIdentifierSchema
 });
 const CheckoutQueryForAvailableShippingMethodsSchema = BaseQuerySchema.extend({
-  checkout: CheckoutIdentifierSchema.required()
+  checkout: CheckoutIdentifierSchema
 });
 const CheckoutQueryForAvailablePaymentMethodsSchema = BaseQuerySchema.extend({
-  checkout: CheckoutIdentifierSchema.required()
+  checkout: CheckoutIdentifierSchema
 });
 export {
   CheckoutQueryByIdSchema,

package/schemas/queries/inventory.query.js

@@ -1,8 +1,8 @@
 import { BaseQuerySchema } from "./base.query.js";
-import { FulfillmentCenterIdentifierSchema, ProductIdentifierSchema, ProductVariantIdentifierSchema } from "../models/identifiers.model.js";
+import { FulfillmentCenterIdentifierSchema, ProductVariantIdentifierSchema } from "../models/identifiers.model.js";
 const InventoryQueryBySKUSchema = BaseQuerySchema.extend({
-  variant: ProductVariantIdentifierSchema.default(() => ProductVariantIdentifierSchema.parse({})).describe("The unique identifier for the product variant (SKU)."),
-  fulfilmentCenter: FulfillmentCenterIdentifierSchema.default(() => FulfillmentCenterIdentifierSchema.parse({})).nonoptional()
+  variant: ProductVariantIdentifierSchema.describe("The unique identifier for the product variant (SKU)."),
+  fulfilmentCenter: FulfillmentCenterIdentifierSchema
 });
 export {
   InventoryQueryBySKUSchema

package/schemas/queries/order.query.js

@@ -1,7 +1,7 @@
 import { BaseQuerySchema } from "./base.query.js";
 import { OrderIdentifierSchema } from "../models/identifiers.model.js";
 const OrderQueryByIdSchema = BaseQuerySchema.extend({
-  order: OrderIdentifierSchema.required()
+  order: OrderIdentifierSchema
 });
 export {
   OrderQueryByIdSchema

package/schemas/queries/price.query.js

@@ -1,10 +1,10 @@
 import { BaseQuerySchema } from "./base.query.js";
 import { ProductVariantIdentifierSchema } from "../models/identifiers.model.js";
 const ListPriceQuerySchema = BaseQuerySchema.extend({
-  variant: ProductVariantIdentifierSchema.required()
+  variant: ProductVariantIdentifierSchema
 });
 const CustomerPriceQuerySchema = BaseQuerySchema.extend({
-  variant: ProductVariantIdentifierSchema.required()
+  variant: ProductVariantIdentifierSchema
 });
 export {
   CustomerPriceQuerySchema,

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

@@ -1,7 +1,7 @@
 import { BaseQuerySchema } from "./base.query.js";
 import { ProductSearchIdentifierSchema } from "../models/identifiers.model.js";
 const ProductSearchQueryByTermSchema = BaseQuerySchema.extend({
-  search: ProductSearchIdentifierSchema.required()
+  search: ProductSearchIdentifierSchema
 });
 export {
   ProductSearchQueryByTermSchema

package/schemas/queries/product.query.js

@@ -5,14 +5,14 @@ const ProductQueryBySlugSchema = BaseQuerySchema.extend({
   slug: z.string()
 });
 const ProductQueryByIdSchema = BaseQuerySchema.extend({
-  identifier: ProductIdentifierSchema.required()
+  identifier: ProductIdentifierSchema
 });
 const ProductQueryBySKUSchema = BaseQuerySchema.extend({
-  variant: ProductVariantIdentifierSchema.default(() => ProductVariantIdentifierSchema.parse({}))
+  variant: ProductVariantIdentifierSchema
 });
 const ProductQueryVariantsSchema = BaseQuerySchema.extend({
-  parentId: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({})),
-  paginationOptions: PaginationOptionsSchema.default(() => PaginationOptionsSchema.parse({}))
+  parentId: ProductIdentifierSchema,
+  paginationOptions: PaginationOptionsSchema
 });
 export {
   ProductQueryByIdSchema,

package/schemas/queries/store.query.js

@@ -1,10 +1,10 @@
 import { z } from "zod";
 import { BaseQuerySchema } from "./base.query.js";
 const StoreQueryByProximitySchema = BaseQuerySchema.extend({
-  longitude: z.number().default(0),
-  latitude: z.number().default(0),
-  distance: z.number().default(0),
-  limit: z.number().default(10)
+  longitude: z.number(),
+  latitude: z.number(),
+  distance: z.number(),
+  limit: z.number()
 });
 export {
   StoreQueryByProximitySchema

package/src/providers/analytics.provider.d.ts

@@ -1,5 +1,4 @@
-import type { AnalyticsEvent } from '../schemas/models/analytics.model.js';
 import { BaseProvider } from './base.provider.js';
-export declare abstract class AnalyticsProvider<T extends AnalyticsEvent = AnalyticsEvent> extends BaseProvider<T> {
+export declare abstract class AnalyticsProvider extends BaseProvider {
     protected getResourceName(): string;
 }

package/src/providers/base.provider.d.ts

@@ -1,6 +1,3 @@
-import type { z } from 'zod';
-import type { BaseModel } from '../schemas/models/base.model.js';
-import { createPaginatedResponseSchema } from '../schemas/models/base.model.js';
 import type { Cache } from '../cache/cache.interface.js';
 import { type RequestContext } from '../schemas/session.schema.js';
 import type { IdentifierType } from '../schemas/models/identifiers.model.js';
@@ -8,29 +5,13 @@ import type { IdentifierType } from '../schemas/models/identifiers.model.js';
  * Base capability provider, responsible for mutations (changes) and queries (fetches)
  * for a given business object domain.
  */
-export declare abstract class BaseProvider<T extends BaseModel = BaseModel> {
-    readonly schema: z.ZodType<T>;
+export declare abstract class BaseProvider {
     protected cache: Cache;
     protected context: RequestContext;
-    constructor(schema: z.ZodType<T>, cache: Cache, context: RequestContext);
-    /**
-     * Validates that the final domain model constructed by the provider
-     * fulfills the schema as defined. This will throw an exception.
-     */
-    protected assert(value: T): T;
-    /**
-     * Creates a new model entity based on the schema defaults.
-     */
-    protected newModel(): T;
-    /**
-     * Handler for parsing a response from a remote provider and converting it
-     * into the typed domain model.
-     */
-    protected parseSingle(_body: unknown): T;
-    protected parsePaginatedResult(_body: unknown): z.infer<ReturnType<typeof createPaginatedResponseSchema<typeof this.schema>>>;
+    constructor(cache: Cache, context: RequestContext);
     generateDependencyIdsForModel(model: unknown): Array<string>;
     protected generateCacheKeyForQuery(scope: string, query: object): string;
-    protected generateCacheKeyPaginatedResult(resultSetName: string, res: ReturnType<typeof this.parsePaginatedResult>): string;
+    protected generateCacheKeyPaginatedResult(resultSetName: string, res: any): string;
     protected generateCacheKeySingle(identifier: IdentifierType): string;
     /**
      * Returns the abstract resource name provided by the remote system.

package/src/providers/cart.provider.d.ts

@@ -3,7 +3,7 @@ import type { CartIdentifier } from "../schemas/models/identifiers.model.js";
 import type { CartMutationApplyCoupon, CartMutationChangeCurrency, CartMutationDeleteCart, CartMutationItemAdd, CartMutationItemQuantityChange, CartMutationItemRemove, CartMutationRemoveCoupon } from "../schemas/mutations/cart.mutation.js";
 import type { CartQueryById } from "../schemas/queries/cart.query.js";
 import { BaseProvider } from "./base.provider.js";
-export declare abstract class CartProvider<T extends Cart = Cart> extends BaseProvider<T> {
+export declare abstract class CartProvider extends BaseProvider {
     /**
      * Get cart by ID.
      *
@@ -11,7 +11,7 @@ export declare abstract class CartProvider<T extends Cart = Cart> extends BasePr
      * @param payload
      * @param session
      */
-    abstract getById(payload: CartQueryById): Promise<T>;
+    abstract getById(payload: CartQueryById): Promise<Cart>;
     /**
      * Get the active cart id for the user.
      *
@@ -28,7 +28,7 @@ export declare abstract class CartProvider<T extends Cart = Cart> extends BasePr
      * @param payload
      * @param session
      */
-    abstract add(payload: CartMutationItemAdd): Promise<T>;
+    abstract add(payload: CartMutationItemAdd): Promise<Cart>;
     /**
      * Remove item from cart. If the cart is empty after removal, delete the cart. Returns the updated and recalculated cart.
      *
@@ -36,7 +36,7 @@ export declare abstract class CartProvider<T extends Cart = Cart> extends BasePr
      * @param payload
      * @param session
      */
-    abstract remove(payload: CartMutationItemRemove): Promise<T>;
+    abstract remove(payload: CartMutationItemRemove): Promise<Cart>;
     /**
      * Change quantity of item in cart. If the cart is empty after change, delete the cart. Returns the updated and recalculated cart.
      * Changing quantity to 0 is not allowed. Use the remove call instead. This is done to avoid accidental removal of item.
@@ -46,7 +46,7 @@ export declare abstract class CartProvider<T extends Cart = Cart> extends BasePr
      * @param payload
      * @param session
      */
-    abstract changeQuantity(payload: CartMutationItemQuantityChange): Promise<T>;
+    abstract changeQuantity(payload: CartMutationItemQuantityChange): Promise<Cart>;
     /**
      * Deletes the entire cart.
      *
@@ -54,7 +54,7 @@ export declare abstract class CartProvider<T extends Cart = Cart> extends BasePr
      * @param payload
      * @param session
      */
-    abstract deleteCart(payload: CartMutationDeleteCart): Promise<T>;
+    abstract deleteCart(payload: CartMutationDeleteCart): Promise<Cart>;
     /**
      * Applies a coupon code to the cart. Returns the updated and recalculated cart.
      *
@@ -62,7 +62,7 @@ export declare abstract class CartProvider<T extends Cart = Cart> extends BasePr
      * @param payload
      * @param session
      */
-    abstract applyCouponCode(payload: CartMutationApplyCoupon): Promise<T>;
+    abstract applyCouponCode(payload: CartMutationApplyCoupon): Promise<Cart>;
     /**
      * Removes a coupon code from the cart. Returns the updated and recalculated cart.
      *
@@ -70,7 +70,7 @@ export declare abstract class CartProvider<T extends Cart = Cart> extends BasePr
      * @param payload
      * @param session
      */
-    abstract removeCouponCode(payload: CartMutationRemoveCoupon): Promise<T>;
+    abstract removeCouponCode(payload: CartMutationRemoveCoupon): Promise<Cart>;
     /**
      * Changes the currency of the cart.
      *
@@ -78,7 +78,7 @@ export declare abstract class CartProvider<T extends Cart = Cart> extends BasePr
      * @param newCurrency
      * @param session
      */
-    abstract changeCurrency(payload: CartMutationChangeCurrency): Promise<T>;
-    protected createEmptyCart(): T;
+    abstract changeCurrency(payload: CartMutationChangeCurrency): Promise<Cart>;
+    protected createEmptyCart(): Cart;
     protected getResourceName(): string;
 }