@reactionary/lipscore 0.9.22

package/capabilities/index.js

@@ -0,0 +1 @@
+export * from "./product-reviews.capability.js";

package/capabilities/product-reviews.capability.js

@@ -0,0 +1,105 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import {
+  ProductReviewPaginatedResultSchema,
+  ProductRatingSummarySchema,
+  ProductReviewSchema,
+  ProductReviewsCapability,
+  Reactionary,
+  error,
+  success
+} from "@reactionary/core";
+import { LipscoreProductsResponseSchema } from "../schema/lipscore.schema.js";
+class LipscoreProductReviewsCapability extends ProductReviewsCapability {
+  constructor(cache, context, config, client, factory) {
+    super(cache, context);
+    this.config = config;
+    this.client = client;
+    this.factory = factory;
+  }
+  async getRatingSummary(query) {
+    const response = await this.client.callGet(
+      this.getReviewsUrl(),
+      this.getRatingSummaryParams(query.product.key),
+      LipscoreProductsResponseSchema
+    );
+    return success(this.factory.parseRatingSummary(this.context, response));
+  }
+  async findReviews(query) {
+    const pageSize = query.paginationOptions?.pageSize ?? 10;
+    const pageNumber = query.paginationOptions?.pageNumber ?? 1;
+    const response = await this.client.callGet(
+      this.getReviewsUrl(),
+      this.getReviewsParams(query.product.key),
+      LipscoreProductsResponseSchema
+    );
+    return success(
+      this.factory.parseReviewPaginatedResult(this.context, {
+        response,
+        productKey: query.product.key,
+        pageSize,
+        pageNumber
+      })
+    );
+  }
+  async submitReview(mutation) {
+    return error({
+      type: "InvalidInput",
+      error: "Review submission is handled via the Lipscore widget and is not available through this API."
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Extension points — override in subclasses to customise API calls
+  // ---------------------------------------------------------------------------
+  getReviewsUrl() {
+    return `${this.client.baseUrl}/products`;
+  }
+  getReviewsParams(productId) {
+    const params = new URLSearchParams();
+    params.set("internal_id[]", productId);
+    params.set("fields", "reviews");
+    return params;
+  }
+  getRatingSummaryParams(productId) {
+    return this.getReviewsParams(productId);
+  }
+}
+__decorateClass([
+  Reactionary({
+    outputSchema: ProductRatingSummarySchema,
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: false
+  })
+], LipscoreProductReviewsCapability.prototype, "getRatingSummary", 1);
+__decorateClass([
+  Reactionary({
+    outputSchema: ProductReviewPaginatedResultSchema,
+    cache: true,
+    cacheTimeToLiveInSeconds: 60,
+    currencyDependentCaching: false,
+    localeDependentCaching: false
+  })
+], LipscoreProductReviewsCapability.prototype, "findReviews", 1);
+__decorateClass([
+  Reactionary({
+    outputSchema: ProductReviewSchema,
+    cache: false,
+    cacheTimeToLiveInSeconds: 0,
+    currencyDependentCaching: false,
+    localeDependentCaching: false
+  })
+], LipscoreProductReviewsCapability.prototype, "submitReview", 1);
+export {
+  LipscoreProductReviewsCapability
+};

package/core/client.js

@@ -0,0 +1,38 @@
+class LipscoreClient {
+  constructor(config, context) {
+    this.config = config;
+    this.context = context;
+    this.baseUrl = config.apiUrl.replace(/\/+$/, "");
+  }
+  baseUrl;
+  async callGet(url, params, schema) {
+    const merged = this.buildParams(params);
+    const query = merged.toString() ? `?${merged.toString()}` : "";
+    const response = await fetch(`${url}${query}`, {
+      headers: this.buildHeaders()
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Lipscore GET ${url} error ${response.status} ${response.statusText}`
+      );
+    }
+    const json = await response.json();
+    return schema.parse(json);
+  }
+  buildParams(params) {
+    const merged = new URLSearchParams(params);
+    if (!merged.has("api_key"))
+      merged.set("api_key", this.config.apiKey);
+    return merged;
+  }
+  buildHeaders() {
+    const headers = {};
+    if (this.config.apiSecret) {
+      headers["X-Authorization"] = this.config.apiSecret;
+    }
+    return headers;
+  }
+}
+export {
+  LipscoreClient
+};

package/core/initialize.js

@@ -0,0 +1,51 @@
+import {
+  ProductRatingSummarySchema,
+  ProductReviewPaginatedResultSchema,
+  ProductReviewSchema
+} from "@reactionary/core";
+import { LipscoreProductReviewsCapability } from "../capabilities/product-reviews.capability.js";
+import { LipscoreProductReviewsFactory } from "../factories/product-reviews/product-reviews.factory.js";
+import { LipscoreCapabilitiesSchema } from "../schema/capabilities.schema.js";
+import { LipscoreConfigurationSchema } from "../schema/configuration.schema.js";
+import { LipscoreClient } from "./client.js";
+import {
+  resolveCapabilityWithFactory
+} from "./initialize.types.js";
+function withLipscoreCapabilities(configuration, capabilities) {
+  return (cache, context) => {
+    const client = {};
+    const config = LipscoreConfigurationSchema.parse(configuration);
+    const caps = LipscoreCapabilitiesSchema.parse(capabilities);
+    const lipscoreClient = new LipscoreClient(config, context);
+    if (caps.productReviews?.enabled) {
+      client.productReviews = resolveCapabilityWithFactory(
+        capabilities.productReviews,
+        {
+          factory: new LipscoreProductReviewsFactory(
+            ProductRatingSummarySchema,
+            ProductReviewSchema,
+            ProductReviewPaginatedResultSchema
+          ),
+          capability: (args) => new LipscoreProductReviewsCapability(
+            args.cache,
+            args.context,
+            args.config,
+            args.client,
+            args.factory
+          )
+        },
+        (factory) => ({
+          cache,
+          context,
+          config,
+          client: lipscoreClient,
+          factory
+        })
+      );
+    }
+    return client;
+  };
+}
+export {
+  withLipscoreCapabilities
+};

package/core/initialize.types.js

@@ -0,0 +1,8 @@
+function resolveCapabilityWithFactory(capability, defaults, buildCapabilityArgs) {
+  const factory = capability?.factory ?? defaults.factory;
+  const capabilityFactory = capability?.capability ?? defaults.capability;
+  return capabilityFactory(buildCapabilityArgs(factory));
+}
+export {
+  resolveCapabilityWithFactory
+};

package/factories/index.js

@@ -0,0 +1 @@
+export * from "./product-reviews/product-reviews.factory.js";

package/factories/product-reviews/product-reviews.factory.js

@@ -0,0 +1,79 @@
+class LipscoreProductReviewsFactory {
+  constructor(ratingSummarySchema, reviewSchema, reviewPaginatedSchema) {
+    this.ratingSummarySchema = ratingSummarySchema;
+    this.reviewSchema = reviewSchema;
+    this.reviewPaginatedSchema = reviewPaginatedSchema;
+  }
+  parseRatingSummary(_context, data) {
+    const product = data[0];
+    const reviews = product?.reviews ?? [];
+    if (reviews.length === 0) {
+      return this.ratingSummarySchema.parse({
+        identifier: { product: { key: String(product?.internal_id ?? "") } },
+        averageRating: 0,
+        totalRatings: void 0,
+        ratingDistribution: void 0
+      });
+    }
+    const total = reviews.length;
+    const sum = reviews.reduce((acc, r) => acc + r.rating, 0);
+    const averageRating = Math.round(sum / total * 100) / 100;
+    const distribution = {
+      "1": 0,
+      "2": 0,
+      "3": 0,
+      "4": 0,
+      "5": 0
+    };
+    for (const review of reviews) {
+      const key = String(Math.min(5, Math.max(1, Math.round(review.rating))));
+      distribution[key] = (distribution[key] ?? 0) + 1;
+    }
+    return this.ratingSummarySchema.parse({
+      identifier: { product: { key: String(product?.internal_id ?? "") } },
+      averageRating,
+      totalRatings: total,
+      ratingDistribution: distribution
+    });
+  }
+  parseReview(_context, data) {
+    return this.reviewSchema.parse({
+      identifier: { key: String(data.id) },
+      product: { key: String(data.id) },
+      authorName: data.displayed_name ?? data.user?.name ?? "Anonymous",
+      authorId: data.user?.id != null ? String(data.user.id) : void 0,
+      rating: data.rating,
+      title: "",
+      content: data.text ?? data.translated_text ?? "",
+      reply: typeof data.review_reply === "string" ? data.review_reply : void 0,
+      repliedAt: void 0,
+      createdAt: data.created_at,
+      updatedAt: void 0,
+      verified: data.testimonial ?? false
+    });
+  }
+  parseReviewPaginatedResult(context, data) {
+    const product = data.response[0];
+    const allReviews = product?.reviews ?? [];
+    const totalCount = allReviews.length;
+    const pageSize = data.pageSize > 0 ? data.pageSize : 10;
+    const pageNumber = data.pageNumber > 0 ? data.pageNumber : 1;
+    const totalPages = pageSize > 0 ? Math.ceil(totalCount / pageSize) : 1;
+    const offset = (pageNumber - 1) * pageSize;
+    const pageReviews = allReviews.slice(offset, offset + pageSize);
+    const items = pageReviews.map((r) => {
+      const parsed = this.parseReview(context, r);
+      return { ...parsed, product: { key: data.productKey } };
+    });
+    return this.reviewPaginatedSchema.parse({
+      items,
+      totalCount,
+      pageSize,
+      pageNumber,
+      totalPages
+    });
+  }
+}
+export {
+  LipscoreProductReviewsFactory
+};

package/index.js

@@ -0,0 +1,7 @@
+export * from "./core/initialize.js";
+export * from "./core/initialize.types.js";
+export * from "./capabilities/index.js";
+export * from "./factories/index.js";
+export * from "./schema/configuration.schema.js";
+export * from "./schema/capabilities.schema.js";
+export * from "./schema/lipscore.schema.js";

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@reactionary/lipscore",
+  "version": "0.9.22",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./src/index.d.ts",
+  "dependencies": {
+    "@reactionary/core": "0.9.22",
+    "zod": "4.1.9"
+  },
+  "devDependencies": {
+    "@nx/vite": "22.4.5",
+    "vitest": "^4.0.9"
+  },
+  "sideEffects": false
+}

package/schema/capabilities.schema.js

@@ -0,0 +1,15 @@
+import { CapabilitiesSchema } from "@reactionary/core";
+import * as z from "zod";
+const ProductReviewsCapabilitySchema = z.looseObject({
+  enabled: z.boolean(),
+  factory: z.unknown().optional(),
+  capability: z.unknown().optional()
+});
+const LipscoreCapabilitiesSchema = CapabilitiesSchema.pick({
+  productReviews: true
+}).extend({
+  productReviews: ProductReviewsCapabilitySchema.optional()
+}).partial();
+export {
+  LipscoreCapabilitiesSchema
+};

package/schema/configuration.schema.js

@@ -0,0 +1,11 @@
+import * as z from "zod";
+const LipscoreConfigurationSchema = z.looseObject({
+  apiKey: z.string().meta({ description: "Lipscore public API key." }),
+  apiSecret: z.string().optional().meta({
+    description: "Lipscore server-side API secret. When set it is sent as the X-Authorization header."
+  }),
+  apiUrl: z.string().default("https://api.lipscore.com").meta({ description: "Base Lipscore API URL." })
+});
+export {
+  LipscoreConfigurationSchema
+};

package/schema/lipscore.schema.js

@@ -0,0 +1,37 @@
+import * as z from "zod";
+const LipscoreReviewUserSchema = z.looseObject({
+  id: z.number().optional(),
+  name: z.string().optional(),
+  short_name: z.string().optional(),
+  email: z.string().optional()
+});
+const LipscoreReviewImageSchema = z.looseObject({
+  thumb_url: z.string().optional(),
+  image_url: z.string().optional()
+});
+const LipscoreReviewSchema = z.looseObject({
+  id: z.number(),
+  text: z.string().optional(),
+  translated_text: z.string().optional(),
+  created_at: z.string(),
+  votes_up: z.number().optional(),
+  votes_down: z.number().optional(),
+  purchase_date: z.string().optional(),
+  rating: z.number(),
+  user: LipscoreReviewUserSchema.optional(),
+  images: z.array(LipscoreReviewImageSchema).optional(),
+  review_reply: z.unknown().optional(),
+  displayed_name: z.string().optional(),
+  testimonial: z.boolean().optional(),
+  attributes: z.array(z.unknown()).optional()
+});
+const LipscoreProductSchema = z.looseObject({
+  internal_id: z.union([z.string(), z.number()]).optional(),
+  reviews: z.array(LipscoreReviewSchema).default([])
+});
+const LipscoreProductsResponseSchema = z.array(LipscoreProductSchema);
+export {
+  LipscoreProductSchema,
+  LipscoreProductsResponseSchema,
+  LipscoreReviewSchema
+};

package/src/capabilities/index.d.ts

@@ -0,0 +1 @@
+export * from './product-reviews.capability.js';

package/src/capabilities/product-reviews.capability.d.ts

@@ -0,0 +1,16 @@
+import { ProductReviewsCapability, type Cache, type ProductReviewMutationSubmit, type ProductReviewsFactory, type ProductReviewsFactoryRatingOutput, type ProductReviewsFactoryReviewOutput, type ProductReviewsFactoryReviewPaginatedOutput, type ProductReviewsFactoryWithOutput, type ProductReviewsGetRatingSummaryQuery, type ProductReviewsListQuery, type RequestContext, type Result } from '@reactionary/core';
+import type { LipscoreConfiguration } from '../schema/configuration.schema.js';
+import type { LipscoreClient } from '../core/client.js';
+import type { LipscoreProductReviewsFactory } from '../factories/product-reviews/product-reviews.factory.js';
+export declare class LipscoreProductReviewsCapability<TFactory extends ProductReviewsFactory = LipscoreProductReviewsFactory> extends ProductReviewsCapability<ProductReviewsFactoryRatingOutput<TFactory>, ProductReviewsFactoryReviewPaginatedOutput<TFactory>, ProductReviewsFactoryReviewOutput<TFactory>> {
+    protected readonly config: LipscoreConfiguration;
+    protected readonly client: LipscoreClient;
+    protected readonly factory: ProductReviewsFactoryWithOutput<TFactory>;
+    constructor(cache: Cache, context: RequestContext, config: LipscoreConfiguration, client: LipscoreClient, factory: ProductReviewsFactoryWithOutput<TFactory>);
+    getRatingSummary(query: ProductReviewsGetRatingSummaryQuery): Promise<Result<ProductReviewsFactoryRatingOutput<TFactory>>>;
+    findReviews(query: ProductReviewsListQuery): Promise<Result<ProductReviewsFactoryReviewPaginatedOutput<TFactory>>>;
+    submitReview(mutation: ProductReviewMutationSubmit): Promise<Result<ProductReviewsFactoryReviewOutput<TFactory>>>;
+    protected getReviewsUrl(): string;
+    protected getReviewsParams(productId: string): URLSearchParams;
+    protected getRatingSummaryParams(productId: string): URLSearchParams;
+}

package/src/core/client.d.ts

@@ -0,0 +1,13 @@
+import type { RequestContext } from '@reactionary/core';
+import type { LipscoreConfiguration } from '../schema/configuration.schema.js';
+export declare class LipscoreClient {
+    protected readonly config: LipscoreConfiguration;
+    protected readonly context: RequestContext;
+    readonly baseUrl: string;
+    constructor(config: LipscoreConfiguration, context: RequestContext);
+    callGet<T>(url: string, params: URLSearchParams, schema: {
+        parse(data: unknown): T;
+    }): Promise<T>;
+    protected buildParams(params: URLSearchParams): URLSearchParams;
+    protected buildHeaders(): Record<string, string>;
+}

package/src/core/initialize.d.ts

@@ -0,0 +1,5 @@
+import type { Cache, RequestContext } from '@reactionary/core';
+import type { LipscoreCapabilities } from '../schema/capabilities.schema.js';
+import type { LipscoreConfiguration } from '../schema/configuration.schema.js';
+import { type LipscoreClientFromCapabilities } from './initialize.types.js';
+export declare function withLipscoreCapabilities<T extends LipscoreCapabilities>(configuration: LipscoreConfiguration, capabilities: T): (cache: Cache, context: RequestContext) => LipscoreClientFromCapabilities<T>;

package/src/core/initialize.types.d.ts

@@ -0,0 +1,34 @@
+import type { ClientFromCapabilities, ProductReviewsFactory } from '@reactionary/core';
+import type { LipscoreCapabilities } from '../schema/capabilities.schema.js';
+import type { LipscoreProductReviewsFactory } from '../factories/product-reviews/product-reviews.factory.js';
+import type { LipscoreProductReviewsCapability } from '../capabilities/product-reviews.capability.js';
+type EnabledCapability<TCapability> = TCapability extends {
+    enabled: true;
+} ? true : false;
+type NormalizeConfiguredCapabilities<T extends LipscoreCapabilities> = Omit<T, 'productReviews'> & {
+    productReviews?: EnabledCapability<T['productReviews']>;
+};
+type ExtractCapabilityFactory<TCapability, TContract, TDefaultFactory> = TCapability extends {
+    enabled: true;
+    factory?: infer TFactory;
+} ? TFactory extends TContract ? TFactory : TDefaultFactory : TDefaultFactory;
+type ExtractCapabilityImplementation<TCapability, TDefaultCapability> = TCapability extends {
+    enabled: true;
+    capability?: infer TCapabilityFactory;
+} ? TCapabilityFactory extends (...args: unknown[]) => infer TResolvedCapability ? TResolvedCapability : TDefaultCapability : TDefaultCapability;
+type CapabilityOverride<TCapability, TKey extends string, TResolvedCapability> = TCapability extends {
+    enabled: true;
+} ? {
+    [K in TKey]: TResolvedCapability;
+} : Record<never, never>;
+type ProductReviewsFactoryFor<T extends LipscoreCapabilities> = ExtractCapabilityFactory<T['productReviews'], ProductReviewsFactory, LipscoreProductReviewsFactory>;
+type ProductReviewsCapabilityFor<T extends LipscoreCapabilities> = ExtractCapabilityImplementation<T['productReviews'], LipscoreProductReviewsCapability<ProductReviewsFactoryFor<T>>>;
+export type LipscoreClientFromCapabilities<T extends LipscoreCapabilities> = Omit<ClientFromCapabilities<NormalizeConfiguredCapabilities<T>>, 'productReviews'> & CapabilityOverride<T['productReviews'], 'productReviews', ProductReviewsCapabilityFor<T>>;
+export declare function resolveCapabilityWithFactory<TFactory, TResolvedCapability, TCapabilityArgs>(capability: {
+    factory?: TFactory;
+    capability?: (args: TCapabilityArgs) => TResolvedCapability;
+} | undefined, defaults: {
+    factory: TFactory;
+    capability: (args: TCapabilityArgs) => TResolvedCapability;
+}, buildCapabilityArgs: (factory: TFactory) => TCapabilityArgs): TResolvedCapability;
+export {};

package/src/factories/index.d.ts

@@ -0,0 +1 @@
+export * from './product-reviews/product-reviews.factory.js';

package/src/factories/product-reviews/product-reviews.factory.d.ts

@@ -0,0 +1,18 @@
+import type * as z from 'zod';
+import type { AnyProductRatingSummarySchema, AnyProductReviewPaginatedSchema, AnyProductReviewSchema, ProductReviewsFactory, RequestContext, ProductRatingSummarySchema, ProductReviewSchema, ProductReviewPaginatedResultSchema } from '@reactionary/core';
+import type { LipscoreReview, LipscoreProductsResponse } from '../../schema/lipscore.schema.js';
+export interface LipscoreReviewsPage {
+    response: LipscoreProductsResponse;
+    productKey: string;
+    pageSize: number;
+    pageNumber: number;
+}
+export declare class LipscoreProductReviewsFactory<TRatingSummarySchema extends AnyProductRatingSummarySchema = typeof ProductRatingSummarySchema, TReviewSchema extends AnyProductReviewSchema = typeof ProductReviewSchema, TReviewPaginatedSchema extends AnyProductReviewPaginatedSchema = typeof ProductReviewPaginatedResultSchema> implements ProductReviewsFactory<TRatingSummarySchema, TReviewSchema, TReviewPaginatedSchema> {
+    readonly ratingSummarySchema: TRatingSummarySchema;
+    readonly reviewSchema: TReviewSchema;
+    readonly reviewPaginatedSchema: TReviewPaginatedSchema;
+    constructor(ratingSummarySchema: TRatingSummarySchema, reviewSchema: TReviewSchema, reviewPaginatedSchema: TReviewPaginatedSchema);
+    parseRatingSummary(_context: RequestContext, data: LipscoreProductsResponse): z.output<TRatingSummarySchema>;
+    parseReview(_context: RequestContext, data: LipscoreReview): z.output<TReviewSchema>;
+    parseReviewPaginatedResult(context: RequestContext, data: LipscoreReviewsPage): z.output<TReviewPaginatedSchema>;
+}

package/src/index.d.ts

@@ -0,0 +1,7 @@
+export * from './core/initialize.js';
+export * from './core/initialize.types.js';
+export * from './capabilities/index.js';
+export * from './factories/index.js';
+export * from './schema/configuration.schema.js';
+export * from './schema/capabilities.schema.js';
+export * from './schema/lipscore.schema.js';

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

@@ -0,0 +1,26 @@
+import type { Cache, ProductReviewsCapability, ProductReviewsFactory, ProductReviewsFactoryWithOutput, RequestContext } from '@reactionary/core';
+import type { LipscoreConfiguration } from './configuration.schema.js';
+import type { LipscoreClient } from '../core/client.js';
+import * as z from 'zod';
+export declare const LipscoreCapabilitiesSchema: z.ZodObject<{
+    productReviews: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export type LipscoreCapabilities = z.infer<typeof LipscoreCapabilitiesSchema>;
+export interface LipscoreCapabilityFactoryArgs {
+    cache: Cache;
+    context: RequestContext;
+    config: LipscoreConfiguration;
+}
+export interface LipscoreProductReviewsCapabilityFactoryArgs<TFactory extends ProductReviewsFactory = ProductReviewsFactory> extends LipscoreCapabilityFactoryArgs {
+    client: LipscoreClient;
+    factory: ProductReviewsFactoryWithOutput<TFactory>;
+}
+export interface LipscoreProductReviewsCapabilityConfig<TFactory extends ProductReviewsFactory = ProductReviewsFactory, TCapability extends ProductReviewsCapability = ProductReviewsCapability> {
+    enabled: boolean;
+    factory?: ProductReviewsFactoryWithOutput<TFactory>;
+    capability?: (args: LipscoreProductReviewsCapabilityFactoryArgs<TFactory>) => TCapability;
+}

package/src/schema/configuration.schema.d.ts

@@ -0,0 +1,7 @@
+import * as z from 'zod';
+export declare const LipscoreConfigurationSchema: z.ZodObject<{
+    apiKey: z.ZodString;
+    apiSecret: z.ZodOptional<z.ZodString>;
+    apiUrl: z.ZodDefault<z.ZodString>;
+}, z.core.$loose>;
+export type LipscoreConfiguration = z.infer<typeof LipscoreConfigurationSchema>;

package/src/schema/lipscore.schema.d.ts

@@ -0,0 +1,82 @@
+import * as z from 'zod';
+export declare const LipscoreReviewSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    text: z.ZodOptional<z.ZodString>;
+    translated_text: z.ZodOptional<z.ZodString>;
+    created_at: z.ZodString;
+    votes_up: z.ZodOptional<z.ZodNumber>;
+    votes_down: z.ZodOptional<z.ZodNumber>;
+    purchase_date: z.ZodOptional<z.ZodString>;
+    rating: z.ZodNumber;
+    user: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodNumber>;
+        name: z.ZodOptional<z.ZodString>;
+        short_name: z.ZodOptional<z.ZodString>;
+        email: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    images: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        thumb_url: z.ZodOptional<z.ZodString>;
+        image_url: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+    review_reply: z.ZodOptional<z.ZodUnknown>;
+    displayed_name: z.ZodOptional<z.ZodString>;
+    testimonial: z.ZodOptional<z.ZodBoolean>;
+    attributes: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+}, z.core.$loose>;
+export type LipscoreReview = z.infer<typeof LipscoreReviewSchema>;
+export declare const LipscoreProductSchema: z.ZodObject<{
+    internal_id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    reviews: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        text: z.ZodOptional<z.ZodString>;
+        translated_text: z.ZodOptional<z.ZodString>;
+        created_at: z.ZodString;
+        votes_up: z.ZodOptional<z.ZodNumber>;
+        votes_down: z.ZodOptional<z.ZodNumber>;
+        purchase_date: z.ZodOptional<z.ZodString>;
+        rating: z.ZodNumber;
+        user: z.ZodOptional<z.ZodObject<{
+            id: z.ZodOptional<z.ZodNumber>;
+            name: z.ZodOptional<z.ZodString>;
+            short_name: z.ZodOptional<z.ZodString>;
+            email: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+        images: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            thumb_url: z.ZodOptional<z.ZodString>;
+            image_url: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>>;
+        review_reply: z.ZodOptional<z.ZodUnknown>;
+        displayed_name: z.ZodOptional<z.ZodString>;
+        testimonial: z.ZodOptional<z.ZodBoolean>;
+        attributes: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export type LipscoreProduct = z.infer<typeof LipscoreProductSchema>;
+export declare const LipscoreProductsResponseSchema: z.ZodArray<z.ZodObject<{
+    internal_id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    reviews: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        text: z.ZodOptional<z.ZodString>;
+        translated_text: z.ZodOptional<z.ZodString>;
+        created_at: z.ZodString;
+        votes_up: z.ZodOptional<z.ZodNumber>;
+        votes_down: z.ZodOptional<z.ZodNumber>;
+        purchase_date: z.ZodOptional<z.ZodString>;
+        rating: z.ZodNumber;
+        user: z.ZodOptional<z.ZodObject<{
+            id: z.ZodOptional<z.ZodNumber>;
+            name: z.ZodOptional<z.ZodString>;
+            short_name: z.ZodOptional<z.ZodString>;
+            email: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+        images: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            thumb_url: z.ZodOptional<z.ZodString>;
+            image_url: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>>;
+        review_reply: z.ZodOptional<z.ZodUnknown>;
+        displayed_name: z.ZodOptional<z.ZodString>;
+        testimonial: z.ZodOptional<z.ZodBoolean>;
+        attributes: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>>;
+export type LipscoreProductsResponse = z.infer<typeof LipscoreProductsResponseSchema>;