@reactionary/source 0.0.52 → 0.2.16

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

@@ -1,144 +1,184 @@
 import { z } from 'zod';
+import { PaginationOptionsSchema } from './base.model.js';
+import type { InferType } from '../../zod-utils.js';
+export const OrderStatusSchema = z.enum(['AwaitingPayment', 'ReleasedToFulfillment', 'Shipped', 'Cancelled']).describe('The current status of the order.');
+export const OrderInventoryStatusSchema = z.enum(['NotAllocated', 'Allocated', 'Backordered', 'Preordered']).describe('The inventory release status of the order.');
 
 export const FacetIdentifierSchema = z.looseObject({
-  key: z.string().default('').nonoptional(),
+  key: z.string(),
 });
 
-export const FacetValueIdentifierSchema = z.looseObject({
-  facet: FacetIdentifierSchema.default(() => FacetIdentifierSchema.parse({})),
-  key: z.string().default(''),
+export const FacetValueIdentifierSchema = z.object({
+  facet: FacetIdentifierSchema,
+  key: z.string(),
 });
 
-export const SKUIdentifierSchema = z.looseObject({
-  key: z.string().default('').nonoptional(),
+export const ProductVariantIdentifierSchema = z.looseObject({
+  sku: z.string(),
 });
 
-export const ProductIdentifierSchema = z.looseObject({
-  key: z.string().default(''),
+export const ProductAttributeIdentifierSchema = z.looseObject({
+  key: z.string().describe('The unique identifier for the product attribute.'),
+});
+
+export const ProductAttributeValueIdentifierSchema = z.looseObject({
+  key: z.string().describe('The unique identifier for the product attribute value.'),
+});
+
+export const ProductOptionIdentifierSchema = z.looseObject({
+  key: z.string().describe('The unique identifier for the product option.'),
 });
 
-export const SearchIdentifierSchema = z.looseObject({
-  term: z.string().default(''),
-  page: z.number().default(0),
-  pageSize: z.number().default(20),
-  facets: z.array(FacetValueIdentifierSchema.required()).default(() => []),
+export const ProductOptionValueIdentifierSchema = z.looseObject({
+  option: ProductOptionIdentifierSchema,
+  key: z.string().describe('The value of the product option, e.g., "Red" or "Large".'),
 });
 
+export const ProductIdentifierSchema = z.looseObject({
+  key: z.string()
+});
+
+
 export const CartIdentifierSchema = z.looseObject({
-  key: z.string().default(''),
+  key: z.string(),
 });
 
 export const CartItemIdentifierSchema = z.looseObject({
-  key: z.string().default(''),
+  key: z.string(),
 });
 
 export const PriceIdentifierSchema = z.looseObject({
-  sku: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({})),
+  variant: ProductVariantIdentifierSchema,
 });
 
 export const CategoryIdentifierSchema = z.looseObject({
-  key: z.string().default('').nonoptional(),
+  key: z.string(),
 });
 
 export const StoreIdentifierSchema = z.looseObject({
-  key: z.string().default('').optional(),
+  key: z.string(),
 });
 
 export const OrderIdentifierSchema = z.looseObject({
-  key: z.string().default('').nonoptional(),
+  key: z.string(),
 });
 
 export const OrderItemIdentifierSchema = z.looseObject({
-  key: z.string().default('').nonoptional(),
+  key: z.string(),
 });
 
 
 export const CheckoutIdentifierSchema = z.looseObject({
-    key: z.string().default('').nonoptional()
+    key: z.string(),
 });
 
 export const CheckoutItemIdentifierSchema = z.looseObject({
-    key: z.string().default('').nonoptional()
+    key: z.string(),
 });
 
 /**
  * The target store the user is interacting with. Can change over time, and is not necessarily the same as the default store.
  */
 export const WebStoreIdentifierSchema = z.looseObject({
-  key: z.string().default('').nonoptional(),
+  key: z.string(),
 });
 
 export const FulfillmentCenterIdentifierSchema = z.looseObject({
-  key: z.string().default('').nonoptional(),
+  key: z.string(),
 });
 
 export const InventoryIdentifierSchema = z.looseObject({
-  sku: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({})),
-  fulfillmentCenter: FulfillmentCenterIdentifierSchema.default(() =>
-    FulfillmentCenterIdentifierSchema.parse({})
-  ),
+  variant: ProductVariantIdentifierSchema,
+  fulfillmentCenter: FulfillmentCenterIdentifierSchema,
 });
 
 export const IdentityIdentifierSchema = z.looseObject({
-  userId: z.string().default('').nonoptional(),
+  userId: z.string(),
 });
 
 export const ShippingMethodIdentifierSchema = z.looseObject({
-    key: z.string().default('').nonoptional(),
+    key: z.string(),
 });
 
 export const PaymentMethodIdentifierSchema = z.looseObject({
-  method: z.string().default('').nonoptional(),
-  name: z.string().default('').nonoptional(),
-  paymentProcessor: z.string().default('').nonoptional(),
+  method: z.string(),
+  name: z.string(),
+  paymentProcessor: z.string(),
 });
 
 export const AddressIdentifierSchema = z.looseObject({
-  nickName: z.string().default('').nonoptional(),
+  nickName: z.string(),
 });
 
 export const PaymentInstructionIdentifierSchema = z.looseObject({
-  key: z.string().default('').nonoptional(),
+  key: z.string(),
 });
 
 export const PickupPointIdentifierSchema = z.looseObject({
-    key: z.string().default('').nonoptional()
-});
-
-export type ProductIdentifier = z.infer<typeof ProductIdentifierSchema>;
-export type SearchIdentifier = z.infer<typeof SearchIdentifierSchema>;
-export type FacetIdentifier = z.infer<typeof FacetIdentifierSchema>;
-export type FacetValueIdentifier = z.infer<typeof FacetValueIdentifierSchema>;
-export type CartIdentifier = z.infer<typeof CartIdentifierSchema>;
-export type CartItemIdentifier = z.infer<typeof CartItemIdentifierSchema>;
-export type PriceIdentifier = z.infer<typeof PriceIdentifierSchema>;
-export type CategoryIdentifier = z.infer<typeof CategoryIdentifierSchema>;
-export type WebStoreIdentifier = z.infer<typeof WebStoreIdentifierSchema>;
-export type InventoryIdentifier = z.infer<typeof InventoryIdentifierSchema>;
-export type FulfillmentCenterIdentifier = z.infer<
+    key: z.string(),
+});
+
+
+export const ProductSearchIdentifierSchema = z.looseObject({
+  term: z.string().describe('The search term used to find products.'),
+  facets: z.array(FacetValueIdentifierSchema).describe('The facets applied to filter the search results.'),
+  filters: z.array(z.string()).describe('Additional filters applied to the search results.'),
+  paginationOptions: PaginationOptionsSchema.describe('Pagination options for the search results.'),
+  categoryFilter: FacetValueIdentifierSchema.optional().describe('An optional category filter applied to the search results.'),
+});
+
+export const OrderSearchIdentifierSchema = z.looseObject({
+  term: z.string().describe('The search term used to find orders. Not all providers may support term-based search for orders.'),
+  partNumber: z.array(z.string()).optional().describe('An optional list part number to filter orders by specific products. Will be ANDed together.'),
+  orderStatus: z.array(OrderStatusSchema).optional().describe('An optional list of order statuses to filter the search results.'),
+  user: IdentityIdentifierSchema.optional().describe('An optional user ID to filter orders by specific users. Mostly for b2b usecases with hierachial order access.'),
+  startDate: z.string().optional().describe('An optional start date to filter orders from a specific date onwards. ISO8601'),
+  endDate: z.string().optional().describe('An optional end date to filter orders up to a specific date. ISO8601'),
+  filters: z.array(z.string()).describe('Additional filters applied to the search results.'),
+  paginationOptions: PaginationOptionsSchema.describe('Pagination options for the search results.'),
+});
+
+export type OrderSearchIdentifier = InferType<typeof OrderSearchIdentifierSchema>;
+export type ProductIdentifier = InferType<typeof ProductIdentifierSchema>;
+export type ProductVariantIdentifier = InferType<typeof ProductVariantIdentifierSchema>;
+export type SearchIdentifier = InferType<typeof ProductSearchIdentifierSchema>;
+export type FacetIdentifier = InferType<typeof FacetIdentifierSchema>;
+export type FacetValueIdentifier = InferType<typeof FacetValueIdentifierSchema>;
+export type CartIdentifier = InferType<typeof CartIdentifierSchema>;
+export type CartItemIdentifier = InferType<typeof CartItemIdentifierSchema>;
+export type PriceIdentifier = InferType<typeof PriceIdentifierSchema>;
+export type CategoryIdentifier = InferType<typeof CategoryIdentifierSchema>;
+export type WebStoreIdentifier = InferType<typeof WebStoreIdentifierSchema>;
+export type InventoryIdentifier = InferType<typeof InventoryIdentifierSchema>;
+export type FulfillmentCenterIdentifier = InferType<
   typeof FulfillmentCenterIdentifierSchema
 >;
-export type IdentityIdentifier = z.infer<typeof IdentityIdentifierSchema>;
-export type ShippingMethodIdentifier = z.infer<
+export type IdentityIdentifier = InferType<typeof IdentityIdentifierSchema>;
+export type ShippingMethodIdentifier = InferType<
   typeof ShippingMethodIdentifierSchema
 >;
-export type PaymentMethodIdentifier = z.infer<
+export type PaymentMethodIdentifier = InferType<
   typeof PaymentMethodIdentifierSchema
 >;
-export type AddressIdentifier = z.infer<typeof AddressIdentifierSchema>;
-export type PaymentInstructionIdentifier = z.infer<
+export type AddressIdentifier = InferType<typeof AddressIdentifierSchema>;
+export type PaymentInstructionIdentifier = InferType<
   typeof PaymentInstructionIdentifierSchema
 >;
-export type OrderIdentifier = z.infer<typeof OrderIdentifierSchema>;
-export type OrderItemIdentifier = z.infer<typeof OrderItemIdentifierSchema>;
-
-export type CheckoutIdentifier = z.infer<typeof CheckoutIdentifierSchema>;
-export type CheckoutItemIdentifier = z.infer<typeof CheckoutItemIdentifierSchema>;
-export type PickupPointIdentifier = z.infer<typeof PickupPointIdentifierSchema>;
-export type StoreIdentifier = z.infer<typeof StoreIdentifierSchema>;
+export type OrderIdentifier = InferType<typeof OrderIdentifierSchema>;
+export type OrderItemIdentifier = InferType<typeof OrderItemIdentifierSchema>;
+
+export type CheckoutIdentifier = InferType<typeof CheckoutIdentifierSchema>;
+export type CheckoutItemIdentifier = InferType<typeof CheckoutItemIdentifierSchema>;
+export type PickupPointIdentifier = InferType<typeof PickupPointIdentifierSchema>;
+export type StoreIdentifier = InferType<typeof StoreIdentifierSchema>;
+export type ProductOptionIdentifier = InferType<typeof ProductOptionIdentifierSchema>;
+export type ProductOptionValueIdentifier = InferType<typeof ProductOptionValueIdentifierSchema>;
+export type ProductAttributeIdentifier = InferType<typeof ProductAttributeIdentifierSchema>;
+export type ProductAttributeValueIdentifier = InferType<typeof ProductAttributeValueIdentifierSchema>;
 
 export type IdentifierType =
   | ProductIdentifier
+  | ProductVariantIdentifier
   | SearchIdentifier
   | FacetIdentifier
   | FacetValueIdentifier
@@ -159,4 +199,8 @@ export type IdentifierType =
   | CheckoutIdentifier
   | CheckoutItemIdentifier
   | StoreIdentifier
-  | PickupPointIdentifier;
+  | ProductOptionIdentifier
+  | ProductOptionValueIdentifier
+  | PickupPointIdentifier
+  | ProductAttributeIdentifier
+  | ProductAttributeValueIdentifier;

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

@@ -1,34 +1,25 @@
 import { z } from 'zod';
 import { BaseModelSchema } from './base.model.js';
 import { IdentityIdentifierSchema } from './identifiers.model.js';
+import type { InferType } from '../../zod-utils.js';
 
 export const AnonymousIdentitySchema = BaseModelSchema.extend({
-    type: z.literal('Anonymous').default('Anonymous'),
-    token: z.string().optional(),
-    refresh_token: z.string().optional(),
-    expiry: z.coerce.date().default(new Date())
+    type: z.literal('Anonymous'),
 });
 
 export const GuestIdentitySchema = BaseModelSchema.extend({
-    id: IdentityIdentifierSchema.default(() => IdentityIdentifierSchema.parse({})),
-    type: z.literal('Guest').default('Guest'),
-    token: z.string().optional(),
-    refresh_token: z.string().optional(),
-    expiry: z.coerce.date().default(new Date())
+    id: IdentityIdentifierSchema,
+    type: z.literal('Guest')
 });
 
 export const RegisteredIdentitySchema = BaseModelSchema.extend({
-    id: IdentityIdentifierSchema.default(() => IdentityIdentifierSchema.parse({})),
-    type: z.literal('Registered').default('Registered'),
-    logonId: z.string().default(''),
-    token: z.string().optional(),
-    refresh_token: z.string().optional(),
-    expiry: z.coerce.date().default(new Date())
+    id: IdentityIdentifierSchema,
+    type: z.literal('Registered'),
 });
 
 export const IdentitySchema = z.discriminatedUnion('type', [ AnonymousIdentitySchema, GuestIdentitySchema, RegisteredIdentitySchema]);
 
-export type AnonymousIdentity = z.infer<typeof AnonymousIdentitySchema>;
-export type GuestIdentity = z.infer<typeof GuestIdentitySchema>;
-export type RegisteredIdentity = z.infer<typeof RegisteredIdentitySchema>;
-export type Identity = z.infer<typeof IdentitySchema>;
+export type AnonymousIdentity = InferType<typeof AnonymousIdentitySchema>;
+export type GuestIdentity = InferType<typeof GuestIdentitySchema>;
+export type RegisteredIdentity = InferType<typeof RegisteredIdentitySchema>;
+export type Identity = InferType<typeof IdentitySchema>;

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

@@ -9,11 +9,12 @@ export * from './inventory.model.js';
 export * from './payment.model.js';
 export * from './price.model.js';
 export * from './product.model.js';
+export * from './product-search.model.js';
 export * from './profile.model.js';
-export * from './search.model.js';
 export * from './shipping-method.model.js';
 export * from './store.model.js';
 export * from './order.model.js';
 export * from './cost.model.js';
 export * from './checkout.model.js';
 export * from './payment.model.js';
+export * from './order-search.model.js'

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

@@ -1,12 +1,15 @@
 import { z } from 'zod';
 import { BaseModelSchema } from './base.model.js';
 import { InventoryIdentifierSchema } from './identifiers.model.js';
+import type { InferType } from '../../zod-utils.js';
+
+export const InventoryStatusSchema = z.enum(['inStock', 'outOfStock', 'onBackOrder', 'preOrder', 'discontinued']);
 
 export const InventorySchema = BaseModelSchema.extend({
-    identifier: InventoryIdentifierSchema.default(() => InventoryIdentifierSchema.parse({})),
-    sku: z.string().default(''),
-    quantity: z.number().default(0),
-    status: z.enum(['inStock', 'outOfStock', 'onBackOrder', 'preOrder', 'discontinued']).default('inStock'),
+    identifier: InventoryIdentifierSchema,
+    quantity: z.number(),
+    status: InventoryStatusSchema,
 });
 
-export type Inventory = z.infer<typeof InventorySchema>;
+export type InventoryStatus = InferType<typeof InventoryStatusSchema>;
+export type Inventory = InferType<typeof InventorySchema>;

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

@@ -0,0 +1,28 @@
+import z from "zod";
+import { BaseModelSchema, createPaginatedResponseSchema } from "./base.model.js";
+import { IdentityIdentifierSchema, OrderIdentifierSchema, OrderInventoryStatusSchema, OrderSearchIdentifierSchema, OrderStatusSchema } from "./identifiers.model.js";
+import type { InferType } from "../../zod-utils.js";
+import { MonetaryAmountSchema } from "./price.model.js";
+import { AddressSchema } from "./profile.model.js";
+
+
+export const OrderSearchResultItemSchema = BaseModelSchema.extend({
+    identifier: OrderIdentifierSchema,
+    userId: IdentityIdentifierSchema,
+    customerName: z.string(),
+    shippingAddress: AddressSchema.optional(),
+    orderDate: z.string(),
+    orderStatus: OrderStatusSchema,
+    inventoryStatus: OrderInventoryStatusSchema,
+    totalAmount: MonetaryAmountSchema
+});
+
+
+
+export const OrderSearchResultSchema = createPaginatedResponseSchema(OrderSearchResultItemSchema).extend({
+    identifier: OrderSearchIdentifierSchema,
+});
+
+
+export type OrderSearchResult = InferType<typeof OrderSearchResultSchema>;
+export type OrderSearchResultItem = InferType<typeof OrderSearchResultItemSchema>;

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

@@ -1,46 +1,40 @@
 import { z } from 'zod';
-import { CartIdentifierSchema, CartItemIdentifierSchema, IdentityIdentifierSchema, SKUIdentifierSchema } from '../models/identifiers.model.js';
+import { CartIdentifierSchema, CartItemIdentifierSchema, IdentityIdentifierSchema, OrderIdentifierSchema, OrderInventoryStatusSchema, OrderItemIdentifierSchema, OrderStatusSchema, ProductVariantIdentifierSchema } from '../models/identifiers.model.js';
 import { BaseModelSchema } from './base.model.js';
 import { AddressSchema } from './profile.model.js';
 import { ShippingMethodSchema } from './shipping-method.model.js';
 import { CostBreakDownSchema, ItemCostBreakdownSchema } from './cost.model.js';
 import { PaymentInstructionSchema } from './payment.model.js';
+import type { InferType } from '../../zod-utils.js';
 
-export const OrderStatusSchema = z.enum(['AwaitingPayment', 'ReleasedToFulfillment', 'Shipped', 'Cancelled']).default('AwaitingPayment').describe('The current status of the order.');
-export const OrderInventoryStatusSchema = z.enum(['NotAllocated', 'Allocated', 'Backordered', 'Preordered']).default('Allocated').describe('The inventory release status of the order.');
 
 
 export const OrderItemSchema = z.looseObject({
-    identifier: CartItemIdentifierSchema.default(() => CartItemIdentifierSchema.parse({})),
-    sku: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({})),
-    quantity: z.number().default(0),
-    price: ItemCostBreakdownSchema.default(() => ItemCostBreakdownSchema.parse({})),
-
-    inventoryStatus: OrderInventoryStatusSchema.default('Allocated').describe('The inventory release status of the order item.'),
+    identifier: OrderItemIdentifierSchema,
+    variant: ProductVariantIdentifierSchema,
+    quantity: z.number(),
+    price: ItemCostBreakdownSchema,
+    inventoryStatus: OrderInventoryStatusSchema.describe('The inventory release status of the order item.'),
 });
 
 export const OrderSchema = BaseModelSchema.extend({
-    identifier: CartIdentifierSchema.default(() => CartIdentifierSchema.parse({})),
-
-    userId: IdentityIdentifierSchema.default(() => IdentityIdentifierSchema.parse({})),
-
-    items: z.array(OrderItemSchema).default(() => []),
-    price: CostBreakDownSchema.default(() => CostBreakDownSchema.parse({})),
-    name: z.string().default(''),
-    description: z.string().default(''),
-
+    identifier: OrderIdentifierSchema,
+    userId: IdentityIdentifierSchema,
+    items: z.array(OrderItemSchema),
+    price: CostBreakDownSchema,
+    name: z.string().optional(),
+    description: z.string().optional(),
     shippingAddress: AddressSchema.optional(),
     billingAddress: AddressSchema.optional(),
     shippingMethod: ShippingMethodSchema.optional(),
-
-    orderStatus: OrderStatusSchema.default('AwaitingPayment'),
-    inventoryStatus: OrderInventoryStatusSchema.default('Allocated'),
-
-    paymentInstructions: z.array(PaymentInstructionSchema).default(() => []),
+    orderStatus: OrderStatusSchema,
+    inventoryStatus: OrderInventoryStatusSchema,
+    paymentInstructions: z.array(PaymentInstructionSchema),
     cartReference: CartIdentifierSchema.optional().describe('Reference to the cart from which this order was created.'),
 });
 
 
-
-export type OrderItem = z.infer<typeof OrderItemSchema>;
-export type Order = z.infer<typeof OrderSchema>;
+export type OrderStatus = InferType<typeof OrderStatusSchema>;
+export type OrderInventoryStatus = InferType<typeof OrderInventoryStatusSchema>;
+export type OrderItem = InferType<typeof OrderItemSchema>;
+export type Order = InferType<typeof OrderSchema>;

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

@@ -2,33 +2,30 @@ import { z } from 'zod';
 import { BaseModelSchema, ImageSchema } from './base.model.js';
 import { PaymentInstructionIdentifierSchema, PaymentMethodIdentifierSchema } from './identifiers.model.js';
 import { MonetaryAmountSchema } from './price.model.js';
+import type { InferType } from '../../zod-utils.js';
 
 export const PaymentStatusSchema = z.enum(['pending', 'authorized', 'canceled', 'capture', 'partial_capture', 'refunded', 'partial_refund']);
 
 export const PaymentProtocolDataSchema = z.looseObject({
-    key: z.string().default(''),
-    value: z.string().default(''),
+    key: z.string(),
+    value: z.string(),
 });
 
-
 export const PaymentMethodSchema = BaseModelSchema.extend({
-    identifier: PaymentMethodIdentifierSchema.default(() => PaymentMethodIdentifierSchema.parse({})),
+    identifier: PaymentMethodIdentifierSchema,
     logo: ImageSchema.optional(),
-    description: z.string().default(''),
-    isPunchOut: z.boolean().default(true)
+    description: z.string(),
+    isPunchOut: z.boolean()
 });
 
 export const PaymentInstructionSchema = BaseModelSchema.extend({
-    identifier: PaymentInstructionIdentifierSchema.default(() => PaymentInstructionIdentifierSchema.parse({})),
-    amount: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})),
-    paymentMethod: PaymentMethodIdentifierSchema.default(() => PaymentMethodIdentifierSchema.parse({})),
-    protocolData: z.array(PaymentProtocolDataSchema).default(() => []).describe('Additional protocol-specific data for processing the payment.'),
-    status: PaymentStatusSchema.default('pending'),
+    identifier: PaymentInstructionIdentifierSchema,
+    amount: MonetaryAmountSchema,
+    paymentMethod: PaymentMethodIdentifierSchema,
+    protocolData: z.array(PaymentProtocolDataSchema).describe('Additional protocol-specific data for processing the payment.'),
+    status: PaymentStatusSchema,
 });
 
-
-
-
-export type PaymentInstruction = z.infer<typeof PaymentInstructionSchema>;
-export type PaymentStatus = z.infer<typeof PaymentStatusSchema>;
-export type PaymentMethod = z.infer<typeof PaymentMethodSchema>;
+export type PaymentInstruction = InferType<typeof PaymentInstructionSchema>;
+export type PaymentStatus = InferType<typeof PaymentStatusSchema>;
+export type PaymentMethod = InferType<typeof PaymentMethodSchema>;

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

@@ -2,24 +2,24 @@ import { z } from 'zod';
 import { BaseModelSchema } from './base.model.js';
 import { PriceIdentifierSchema } from './identifiers.model.js';
 import { CurrencySchema } from './currency.model.js';
+import type { InferType } from '../../zod-utils.js';
 
 export const MonetaryAmountSchema = z.looseObject({
-    value: z.number().default(0).describe('The monetary amount in decimal-precision.'),
-    currency: CurrencySchema.default("XXX").describe('The currency associated with the amount, as a ISO 4217 standardized code.')
+    value: z.number().describe('The monetary amount in decimal-precision.'),
+    currency: CurrencySchema.describe('The currency associated with the amount, as a ISO 4217 standardized code.')
 });
 
 export const TieredPriceSchema = z.looseObject({
-    minimumQuantity: z.number().default(0).describe('The minimum quantity required to be eligible for the tiered price.'),
-    price: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe('The monetary amount for the tiered price.'),
+    minimumQuantity: z.number().describe('The minimum quantity required to be eligible for the tiered price.'),
+    price: MonetaryAmountSchema.describe('The monetary amount for the tiered price.'),
 });
 
-
 export const PriceSchema = BaseModelSchema.extend({
-    identifier: PriceIdentifierSchema.default(() => PriceIdentifierSchema.parse({})),
-    unitPrice: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})),
-    tieredPrices: z.array(TieredPriceSchema).default(() => []),
+    identifier: PriceIdentifierSchema,
+    unitPrice: MonetaryAmountSchema,
+    tieredPrices: z.array(TieredPriceSchema)
 });
 
-export type MonetaryAmount = z.infer<typeof MonetaryAmountSchema>;
-export type Price = z.infer<typeof PriceSchema>;
-export type TieredPrice = z.infer<typeof TieredPriceSchema>;
+export type MonetaryAmount = InferType<typeof MonetaryAmountSchema>;
+export type Price = InferType<typeof PriceSchema>;
+export type TieredPrice = InferType<typeof TieredPriceSchema>;

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

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import { ProductIdentifierSchema, FacetValueIdentifierSchema, FacetIdentifierSchema, ProductSearchIdentifierSchema, ProductVariantIdentifierSchema } from './identifiers.model.js';
+import { BaseModelSchema, createPaginatedResponseSchema, ImageSchema } from './base.model.js';
+import { ProductVariantOptionSchema } from './product.model.js';
+import type { InferType } from '../../zod-utils.js';
+
+export const ProductSearchResultItemVariantSchema = z.looseObject({
+    variant: ProductVariantIdentifierSchema.describe('The specific variant of the product'),
+    image: ImageSchema.describe('The image representing this variant in the search results'),
+    options: ProductVariantOptionSchema.optional().describe('The subset of options that can reasonably be applied on a PLP'),
+});
+
+export const ProductSearchResultItemSchema = BaseModelSchema.extend({
+    identifier: ProductIdentifierSchema,
+    name: z.string(),
+    slug: z.string(),
+    variants: z.array(ProductSearchResultItemVariantSchema).describe('A list of variants associated with the product in the search results. If exactly one is present, you can use add-to-cart directly from PLP. If none are present, you must direct to PDP. If mulitple are present, and no options are set, you must direct to PDP. If multiple are present, and they have options, you can render swatches on PLP and allow customer to flip between variants.'),
+});
+
+export const ProductSearchResultFacetValueSchema = z.looseObject({
+    identifier: FacetValueIdentifierSchema,
+    name: z.string(),
+    count: z.number(),
+    active: z.boolean(),
+});
+
+export const ProductSearchResultFacetSchema = z.looseObject({
+    identifier: FacetIdentifierSchema,
+    name: z.string(),
+    values: z.array(ProductSearchResultFacetValueSchema),
+});
+
+export const ProductSearchResultSchema = createPaginatedResponseSchema(ProductSearchResultItemSchema).extend({
+    identifier: ProductSearchIdentifierSchema,
+    facets: z.array(ProductSearchResultFacetSchema),
+});
+
+export type ProductSearchResultItemVariant = InferType<typeof ProductSearchResultItemVariantSchema>;
+export type ProductSearchResultItem = InferType<typeof ProductSearchResultItemSchema>;
+export type ProductSearchResult = InferType<typeof ProductSearchResultSchema>;
+export type ProductSearchResultFacet = InferType<typeof ProductSearchResultFacetSchema>;
+export type ProductSearchResultFacetValue = InferType<typeof ProductSearchResultFacetValueSchema>;