@reactionary/core 0.3.11 → 0.3.12

package/package.json

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

package/providers/index.js

@@ -11,6 +11,7 @@ export * from "./profile.provider.js";
 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 "./store.provider.js";
 export * from "./order.provider.js";
 export * from "./order-search.provider.js";

package/providers/product-reviews.provider.js

@@ -0,0 +1,9 @@
+import { BaseProvider } from "./base.provider.js";
+class ProductReviewsProvider extends BaseProvider {
+  getResourceName() {
+    return "product-reviews";
+  }
+}
+export {
+  ProductReviewsProvider
+};

package/schemas/capabilities.schema.js

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

package/schemas/models/identifiers.model.js

@@ -89,6 +89,15 @@ const ProductRecommendationIdentifierSchema = z.looseObject({
   key: z.string(),
   algorithm: z.string()
 });
+const ProductAssociationsIdentifierSchema = z.looseObject({
+  key: z.string()
+});
+const ProductRatingIdentifierSchema = z.looseObject({
+  product: ProductIdentifierSchema.meta({ description: "The product this rating summary is for." })
+});
+const ProductReviewIdentifierSchema = z.looseObject({
+  key: z.string().meta({ description: "The unique identifier for the product review." })
+});
 const ProductSearchIdentifierSchema = z.looseObject({
   term: z.string().meta({ description: "The search term used to find products." }),
   facets: z.array(FacetValueIdentifierSchema).meta({ description: "The facets applied to filter the search results." }),
@@ -127,12 +136,15 @@ export {
   PaymentMethodIdentifierSchema,
   PickupPointIdentifierSchema,
   PriceIdentifierSchema,
+  ProductAssociationsIdentifierSchema,
   ProductAttributeIdentifierSchema,
   ProductAttributeValueIdentifierSchema,
   ProductIdentifierSchema,
   ProductOptionIdentifierSchema,
   ProductOptionValueIdentifierSchema,
+  ProductRatingIdentifierSchema,
   ProductRecommendationIdentifierSchema,
+  ProductReviewIdentifierSchema,
   ProductSearchIdentifierSchema,
   ProductVariantIdentifierSchema,
   ShippingMethodIdentifierSchema,

package/schemas/models/index.js

@@ -10,6 +10,7 @@ export * from "./payment.model.js";
 export * from "./price.model.js";
 export * from "./product.model.js";
 export * from "./product-search.model.js";
+export * from "./product-reviews.model.js";
 export * from "./profile.model.js";
 export * from "./shipping-method.model.js";
 export * from "./store.model.js";

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

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

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

@@ -0,0 +1,33 @@
+import * as z from "zod";
+import { BaseModelSchema } from "./base.model.js";
+import { ProductIdentifierSchema, ProductRatingIdentifierSchema, ProductReviewIdentifierSchema } from "./identifiers.model.js";
+const ProductRatingSummarySchema = BaseModelSchema.extend({
+  identifier: ProductRatingIdentifierSchema,
+  averageRating: z.number().min(0).max(5).meta({ description: "The average rating for the product." }),
+  totalRatings: z.number().min(0).optional().meta({ description: "The total number of ratings for the product." }),
+  ratingDistribution: z.looseObject({
+    "1": z.number().min(0).meta({ description: "Number of 1-star ratings." }),
+    "2": z.number().min(0).meta({ description: "Number of 2-star ratings." }),
+    "3": z.number().min(0).meta({ description: "Number of 3-star ratings." }),
+    "4": z.number().min(0).meta({ description: "Number of 4-star ratings." }),
+    "5": z.number().min(0).meta({ description: "Number of 5-star ratings." })
+  }).optional().meta({ description: "Distribution of ratings across different star levels." })
+});
+const ProductReviewSchema = BaseModelSchema.extend({
+  identifier: ProductReviewIdentifierSchema,
+  product: ProductIdentifierSchema.meta({ description: "The product this review is for." }),
+  authorName: z.string().meta({ description: "The name of the review author." }),
+  authorId: z.string().optional().meta({ description: "Optional unique identifier for the review author." }),
+  rating: z.number().min(0).max(5).meta({ description: "The rating given by the reviewer (0-5)." }),
+  title: z.string().meta({ description: "The title or headline of the review." }),
+  content: z.string().meta({ description: "The main content/body of the review." }),
+  reply: z.string().optional().meta({ description: "Optional reply from the store to this review." }),
+  repliedAt: z.string().optional().meta({ description: "ISO8601 timestamp when the reply was made." }),
+  createdAt: z.string().meta({ description: "ISO8601 timestamp when the review was created." }),
+  updatedAt: z.string().optional().meta({ description: "ISO8601 timestamp when the review was last updated." }),
+  verified: z.boolean().meta({ description: "Whether this is a verified purchase review." })
+});
+export {
+  ProductRatingSummarySchema,
+  ProductReviewSchema
+};

package/schemas/mutations/index.js

@@ -5,6 +5,7 @@ export * from "./identity.mutation.js";
 export * from "./inventory.mutation.js";
 export * from "./price.mutation.js";
 export * from "./product.mutation.js";
+export * from "./product-reviews.mutation.js";
 export * from "./profile.mutation.js";
 export * from "./search.mutation.js";
 export * from "./checkout.mutation.js";

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

@@ -0,0 +1,13 @@
+import * as z from "zod";
+import { BaseMutationSchema } from "./base.mutation.js";
+import { ProductIdentifierSchema } from "../models/identifiers.model.js";
+const ProductReviewMutationSubmitSchema = BaseMutationSchema.extend({
+  product: ProductIdentifierSchema.meta({ description: "The product to review." }),
+  rating: z.number().min(1).max(5).meta({ description: "The rating value from 1 to 5." }),
+  title: z.string().meta({ description: "The title or headline of the review." }),
+  content: z.string().meta({ description: "The main content/body of the review." }),
+  authorName: z.string().meta({ description: "The name of the review author." })
+});
+export {
+  ProductReviewMutationSubmitSchema
+};

package/schemas/queries/index.js

@@ -8,6 +8,7 @@ export * from "./price.query.js";
 export * from "./product.query.js";
 export * from "./profile.query.js";
 export * from "./product-search.query.js";
+export * from "./product-reviews.query.js";
 export * from "./store.query.js";
 export * from "./order.query.js";
 export * from "./checkout.query.js";

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

@@ -0,0 +1,14 @@
+import * as z from "zod";
+import { BaseQuerySchema } from "./base.query.js";
+import { PaginationOptionsSchema, ProductIdentifierSchema } from "../models/index.js";
+const ProductReviewsListQuerySchema = BaseQuerySchema.extend({
+  product: ProductIdentifierSchema.meta({ description: "The product to list reviews for." }),
+  paginationOptions: PaginationOptionsSchema.optional().meta({ description: "Optional pagination options for the review list." })
+});
+const ProductReviewsGetRatingSummaryQuerySchema = BaseQuerySchema.extend({
+  product: ProductIdentifierSchema.meta({ description: "The product to get rating summary for." })
+});
+export {
+  ProductReviewsGetRatingSummaryQuerySchema,
+  ProductReviewsListQuerySchema
+};

package/src/client/client.d.ts

@@ -10,11 +10,13 @@ import type { AnalyticsProvider, CheckoutProvider, OrderProvider, ProfileProvide
 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";
+import type { ProductReviewsProvider } from "../providers/product-reviews.provider.js";
 export interface Client {
     product: ProductProvider;
     productSearch: ProductSearchProvider;
     productRecommendations: ProductRecommendationsProvider;
     productAssociations: ProductAssociationsProvider;
+    productReviews: ProductReviewsProvider;
     identity: IdentityProvider;
     cache: Cache;
     cart: CartProvider;

package/src/providers/index.d.ts

@@ -11,6 +11,7 @@ export * from './profile.provider.js';
 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 './store.provider.js';
 export * from './order.provider.js';
 export * from './order-search.provider.js';

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

@@ -0,0 +1,33 @@
+import type { Result, ProductReview, ProductRatingSummary } from '../schemas/index.js';
+import type { ProductReviewsListQuery, ProductReviewsGetRatingSummaryQuery } from '../schemas/queries/product-reviews.query.js';
+import type { ProductReviewMutationSubmit } from '../schemas/mutations/product-reviews.mutation.js';
+import { BaseProvider } from './base.provider.js';
+/**
+ * The product reviews provider is responsible for providing detailed product reviews from customers.
+ * Reviews contain ratings along with textual feedback, author information, and verification status.
+ * This provider also handles aggregated rating summaries for products.
+ */
+export declare abstract class ProductReviewsProvider extends BaseProvider {
+    /**
+     * Get the rating summary for a product, including average rating and distribution.
+     *
+     * Usecase: Display rating summary on product detail pages or product listing pages.
+     * @param query The product to get ratings for
+     */
+    abstract getRatingSummary(query: ProductReviewsGetRatingSummaryQuery): Promise<Result<ProductRatingSummary>>;
+    /**
+     * Get a paginated list of reviews for a product.
+     *
+     * Usecase: Display customer reviews on product detail pages with filtering and sorting options.
+     * @param query The query parameters including product, pagination, sorting, and filtering options
+     */
+    abstract listReviews(query: ProductReviewsListQuery): Promise<Result<ProductReview[]>>;
+    /**
+     * Submit a review for a product.
+     *
+     * Usecase: Allow customers to submit detailed reviews with ratings for products they have purchased.
+     * @param mutation The review submission data including rating, title, and content
+     */
+    abstract submitReview(mutation: ProductReviewMutationSubmit): Promise<Result<ProductReview>>;
+    getResourceName(): string;
+}

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

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

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

@@ -112,6 +112,17 @@ export declare const ProductRecommendationIdentifierSchema: z.ZodObject<{
     key: z.ZodString;
     algorithm: z.ZodString;
 }, z.core.$loose>;
+export declare const ProductAssociationsIdentifierSchema: z.ZodObject<{
+    key: z.ZodString;
+}, z.core.$loose>;
+export declare const ProductRatingIdentifierSchema: z.ZodObject<{
+    product: z.ZodObject<{
+        key: z.ZodString;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export declare const ProductReviewIdentifierSchema: z.ZodObject<{
+    key: z.ZodString;
+}, z.core.$loose>;
 export declare const ProductSearchIdentifierSchema: z.ZodObject<{
     term: z.ZodString;
     facets: z.ZodArray<z.ZodObject<{
@@ -184,4 +195,7 @@ export type ProductOptionValueIdentifier = InferType<typeof ProductOptionValueId
 export type ProductAttributeIdentifier = InferType<typeof ProductAttributeIdentifierSchema>;
 export type ProductAttributeValueIdentifier = InferType<typeof ProductAttributeValueIdentifierSchema>;
 export type ProductRecommendationIdentifier = InferType<typeof ProductRecommendationIdentifierSchema>;
-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;
+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;

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

@@ -10,6 +10,7 @@ export * from './payment.model.js';
 export * from './price.model.js';
 export * from './product.model.js';
 export * from './product-search.model.js';
+export * from './product-reviews.model.js';
 export * from './profile.model.js';
 export * from './shipping-method.model.js';
 export * from './store.model.js';

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

@@ -0,0 +1,105 @@
+import * as z from "zod";
+import type { InferType } from "../../zod-utils.js";
+export declare const BaseProductAssociationsSchema: z.ZodObject<{
+    associationIdentifier: z.ZodObject<{
+        key: z.ZodString;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export declare const ProductAssociationsIdOnlySchema: z.ZodObject<{
+    associationIdentifier: z.ZodObject<{
+        key: z.ZodString;
+    }, z.core.$loose>;
+    associationReturnType: z.ZodLiteral<"idOnly">;
+    product: z.ZodObject<{
+        key: z.ZodString;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export declare const ProductAssociationsProductSearchResultItemSchema: z.ZodObject<{
+    associationIdentifier: z.ZodObject<{
+        key: z.ZodString;
+    }, z.core.$loose>;
+    associationReturnType: z.ZodLiteral<"productSearchResultItem">;
+    product: z.ZodObject<{
+        identifier: z.ZodObject<{
+            key: z.ZodString;
+        }, z.core.$loose>;
+        name: z.ZodString;
+        slug: z.ZodString;
+        variants: z.ZodArray<z.ZodObject<{
+            variant: z.ZodObject<{
+                sku: z.ZodString;
+            }, 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.core.$loose>;
+            options: z.ZodOptional<z.ZodObject<{
+                identifier: z.ZodObject<{
+                    key: z.ZodString;
+                }, z.core.$loose>;
+                name: z.ZodString;
+                value: z.ZodObject<{
+                    identifier: z.ZodObject<{
+                        option: z.ZodObject<{
+                            key: z.ZodString;
+                        }, z.core.$loose>;
+                        key: z.ZodString;
+                    }, z.core.$loose>;
+                    label: z.ZodString;
+                }, z.core.$loose>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export declare const ProductAssociationsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    associationIdentifier: z.ZodObject<{
+        key: z.ZodString;
+    }, z.core.$loose>;
+    associationReturnType: z.ZodLiteral<"idOnly">;
+    product: z.ZodObject<{
+        key: z.ZodString;
+    }, z.core.$loose>;
+}, z.core.$loose>, z.ZodObject<{
+    associationIdentifier: z.ZodObject<{
+        key: z.ZodString;
+    }, z.core.$loose>;
+    associationReturnType: z.ZodLiteral<"productSearchResultItem">;
+    product: z.ZodObject<{
+        identifier: z.ZodObject<{
+            key: z.ZodString;
+        }, z.core.$loose>;
+        name: z.ZodString;
+        slug: z.ZodString;
+        variants: z.ZodArray<z.ZodObject<{
+            variant: z.ZodObject<{
+                sku: z.ZodString;
+            }, 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.core.$loose>;
+            options: z.ZodOptional<z.ZodObject<{
+                identifier: z.ZodObject<{
+                    key: z.ZodString;
+                }, z.core.$loose>;
+                name: z.ZodString;
+                value: z.ZodObject<{
+                    identifier: z.ZodObject<{
+                        option: z.ZodObject<{
+                            key: z.ZodString;
+                        }, z.core.$loose>;
+                        key: z.ZodString;
+                    }, z.core.$loose>;
+                    label: z.ZodString;
+                }, z.core.$loose>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>;
+}, z.core.$loose>], "associationReturnType">;
+export type ProductAssociationsIdOnly = InferType<typeof ProductAssociationsIdOnlySchema>;
+export type ProductAssociationsSearchItem = InferType<typeof ProductAssociationsProductSearchResultItemSchema>;
+export type ProductAssociations = InferType<typeof ProductAssociationsSchema>;

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

@@ -0,0 +1,41 @@
+import * as z from 'zod';
+import type { InferType } from '../../zod-utils.js';
+/**
+ * All our reviews are normalized to 1-5 star ratings
+ */
+export declare const ProductRatingSummarySchema: z.ZodObject<{
+    identifier: z.ZodObject<{
+        product: z.ZodObject<{
+            key: z.ZodString;
+        }, z.core.$loose>;
+    }, z.core.$loose>;
+    averageRating: z.ZodNumber;
+    totalRatings: z.ZodOptional<z.ZodNumber>;
+    ratingDistribution: z.ZodOptional<z.ZodObject<{
+        '1': z.ZodNumber;
+        '2': z.ZodNumber;
+        '3': z.ZodNumber;
+        '4': z.ZodNumber;
+        '5': z.ZodNumber;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export declare const ProductReviewSchema: z.ZodObject<{
+    identifier: z.ZodObject<{
+        key: z.ZodString;
+    }, z.core.$loose>;
+    product: z.ZodObject<{
+        key: z.ZodString;
+    }, z.core.$loose>;
+    authorName: z.ZodString;
+    authorId: z.ZodOptional<z.ZodString>;
+    rating: z.ZodNumber;
+    title: z.ZodString;
+    content: z.ZodString;
+    reply: z.ZodOptional<z.ZodString>;
+    repliedAt: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodOptional<z.ZodString>;
+    verified: z.ZodBoolean;
+}, z.core.$loose>;
+export type ProductReview = InferType<typeof ProductReviewSchema>;
+export type ProductRatingSummary = InferType<typeof ProductRatingSummarySchema>;

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

@@ -5,6 +5,7 @@ export * from './identity.mutation.js';
 export * from './inventory.mutation.js';
 export * from './price.mutation.js';
 export * from './product.mutation.js';
+export * from './product-reviews.mutation.js';
 export * from './profile.mutation.js';
 export * from './search.mutation.js';
 export * from './checkout.mutation.js';

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

@@ -0,0 +1,12 @@
+import * as z from 'zod';
+import type { InferType } from '../../zod-utils.js';
+export declare const ProductReviewMutationSubmitSchema: z.ZodObject<{
+    product: z.ZodObject<{
+        key: z.ZodString;
+    }, z.core.$loose>;
+    rating: z.ZodNumber;
+    title: z.ZodString;
+    content: z.ZodString;
+    authorName: z.ZodString;
+}, z.core.$loose>;
+export type ProductReviewMutationSubmit = InferType<typeof ProductReviewMutationSubmitSchema>;

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

@@ -8,6 +8,7 @@ export * from './price.query.js';
 export * from './product.query.js';
 export * from './profile.query.js';
 export * from './product-search.query.js';
+export * from './product-reviews.query.js';
 export * from './store.query.js';
 export * from './order.query.js';
 export * from './checkout.query.js';

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

@@ -0,0 +1,18 @@
+import * as z from 'zod';
+import type { InferType } from '../../zod-utils.js';
+export declare const ProductReviewsListQuerySchema: z.ZodObject<{
+    product: z.ZodObject<{
+        key: z.ZodString;
+    }, z.core.$loose>;
+    paginationOptions: z.ZodOptional<z.ZodObject<{
+        pageNumber: z.ZodDefault<z.ZodNumber>;
+        pageSize: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export declare const ProductReviewsGetRatingSummaryQuerySchema: z.ZodObject<{
+    product: z.ZodObject<{
+        key: z.ZodString;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export type ProductReviewsListQuery = InferType<typeof ProductReviewsListQuerySchema>;
+export type ProductReviewsGetRatingSummaryQuery = InferType<typeof ProductReviewsGetRatingSummaryQuerySchema>;