@reactionary/feeds 0.0.1

package/lib/transformers/acp-product-feed.transformer.js

@@ -0,0 +1,128 @@
+import {
+  getTargetCountry
+} from "../feed-generator.js";
+import {
+  formatMoney,
+  primaryImage,
+  productDescription
+} from "./shared.js";
+const acpProductFeedTransformer = {
+  id: "acp-product-feed",
+  title: "ACP Product Feed",
+  description: "Agentic Commerce Protocol product feed output.",
+  output: {
+    contentType: "application/x-ndjson; charset=utf-8",
+    fileExtension: "jsonl"
+  },
+  defaultOptions: {
+    format: "jsonl"
+  },
+  async *transform(products, context) {
+    if (context.options.format === "json") {
+      const collected = [];
+      for await (const product of products) {
+        collected.push(...toACPRows(product, context.feed));
+      }
+      yield JSON.stringify({
+        ...getTargetCountry(context.feed.languageContext) ? { target_country: getTargetCountry(context.feed.languageContext) } : {},
+        products: collected
+      });
+      return;
+    }
+    for await (const product of products) {
+      for (const row of toACPRows(product, context.feed)) {
+        yield `${JSON.stringify(row)}
+`;
+      }
+    }
+  }
+};
+function toACPRows(product, feed) {
+  return product.variants.map(
+    (variant) => toACPRow(product, variant, feed)
+  );
+}
+function toACPRow(product, variant, feed) {
+  const primaryImageUrl = primaryImage(product, variant);
+  const additionalImageUrls = getAdditionalImageUrls(product, variant, primaryImageUrl);
+  const variation = getVariationFields(product, variant);
+  const priceFields = getPriceFields(variant);
+  const gtin = variant.gtin || variant.ean || variant.upc || void 0;
+  return {
+    item_id: variant.id,
+    ...variation,
+    title: variant.title || product.title,
+    description: variant.description ?? productDescription(product),
+    ...variant.url ?? product.url ? { url: variant.url ?? product.url } : {},
+    ...product.brand ? { brand: product.brand } : {},
+    is_eligible_search: true,
+    ...feed.sellerName ? { seller_name: feed.sellerName } : {},
+    ...product.manufacturer ? { manufacturer: product.manufacturer } : {},
+    ...product.categoryPath?.length ? {
+      product_category: product.categoryPath.map((category) => category.name).join(" > ")
+    } : {},
+    ...product.ratingSummary ? {
+      ...product.ratingSummary.totalRatings !== void 0 ? { review_count: product.ratingSummary.totalRatings } : {},
+      ...product.ratingSummary.totalRatings ? { star_rating: product.ratingSummary.averageRating.toFixed(2) } : {}
+    } : {},
+    ...primaryImageUrl ? { image_url: primaryImageUrl } : {},
+    ...additionalImageUrls.length > 0 ? { additional_image_urls: additionalImageUrls } : {},
+    availability: toACPAvailability(variant.availability?.status),
+    ...priceFields,
+    ...gtin ? { gtin } : {},
+    ...variant.manufacturerPartNumber ? { mpn: variant.manufacturerPartNumber } : {}
+  };
+}
+function getVariationFields(product, variant) {
+  if (product.variants.length <= 1 || product.id === variant.id || variant.options.length === 0) {
+    return {};
+  }
+  const variantDict = Object.fromEntries(
+    variant.options.map((option) => [option.name, option.value])
+  );
+  return {
+    group_id: product.id,
+    listing_has_variations: true,
+    variant_dict: variantDict
+  };
+}
+function getPriceFields(variant) {
+  if (variant.price && variant.listPrice && variant.price.currency.toUpperCase() === variant.listPrice.currency.toUpperCase() && variant.price.value > 0 && variant.listPrice.value > variant.price.value) {
+    return {
+      price: formatMoney(variant.listPrice),
+      sale_price: formatMoney(variant.price)
+    };
+  }
+  return {
+    ...variant.price ?? variant.listPrice ? { price: formatMoney(variant.price ?? variant.listPrice) } : {}
+  };
+}
+function toACPAvailability(status) {
+  switch (status) {
+    case "in_stock":
+    case "out_of_stock":
+    case "backorder":
+      return status;
+    case "preorder":
+      return "pre_order";
+    default:
+      return "unknown";
+  }
+}
+function getAdditionalImageUrls(product, variant, primaryImageUrl) {
+  const urls = [
+    ...variant.images.map((image) => image.url),
+    ...product.images.map((image) => image.url)
+  ];
+  const unique = /* @__PURE__ */ new Set();
+  return urls.filter((url) => {
+    if (url === primaryImageUrl || unique.has(url)) {
+      return false;
+    }
+    unique.add(url);
+    return true;
+  });
+}
+export {
+  acpProductFeedTransformer
+};

package/lib/transformers/google-merchant-feed.transformer.js

@@ -0,0 +1,60 @@
+import { create } from "xmlbuilder2";
+import {
+  googleMoney,
+  primaryImage,
+  productDescription
+} from "./shared.js";
+const googleMerchantFeedTransformer = {
+  id: "google-merchant-feed",
+  title: "Google Merchant Feed",
+  description: "Google Merchant Center RSS XML feed.",
+  output: {
+    contentType: "application/xml; charset=utf-8",
+    fileExtension: "xml"
+  },
+  async *transform(products) {
+    const document = create({ version: "1.0", encoding: "UTF-8" });
+    const channel = document.ele("rss", {
+      version: "2.0",
+      "xmlns:g": "http://base.google.com/ns/1.0"
+    }).ele("channel");
+    channel.ele("title").txt("Reactionary Product Feed").up();
+    for await (const product of products) {
+      for (const variant of product.variants) {
+        appendGoogleItem(channel, product, variant);
+      }
+    }
+    yield `${document.end({ prettyPrint: true })}
+`;
+  }
+};
+function appendGoogleItem(channel, product, variant) {
+  const item = channel.ele("item");
+  const image = primaryImage(product, variant);
+  const link = variant.url ?? product.url;
+  const gtin = variant.barcodes.find((barcode) => barcode.type === "gtin")?.value;
+  item.ele("g:id").txt(variant.id).up();
+  item.ele("g:item_group_id").txt(product.id).up();
+  item.ele("title").txt(variant.title || product.title).up();
+  item.ele("description").txt(variant.description ?? productDescription(product)).up();
+  if (link) {
+    item.ele("link").txt(link).up();
+  }
+  if (image) {
+    item.ele("g:image_link").txt(image).up();
+  }
+  item.ele("g:availability").txt(variant.availability?.available ? "in stock" : "out of stock").up();
+  if (variant.price) {
+    item.ele("g:price").txt(googleMoney(variant.price) ?? "").up();
+  }
+  if (product.brand) {
+    item.ele("g:brand").txt(product.brand).up();
+  }
+  if (gtin) {
+    item.ele("g:gtin").txt(gtin).up();
+  }
+  item.ele("g:condition").txt("new").up();
+}
+export {
+  googleMerchantFeedTransformer
+};

package/lib/transformers/pricerunner-feed.transformer.js

@@ -0,0 +1,60 @@
+import { create } from "xmlbuilder2";
+import {
+  formatMoney,
+  primaryImage,
+  productDescription
+} from "./shared.js";
+const pricerunnerFeedTransformer = {
+  id: "pricerunner-feed",
+  title: "PriceRunner XML Feed",
+  description: "PriceRunner Products XML feed.",
+  output: {
+    contentType: "application/xml; charset=utf-8",
+    fileExtension: "xml"
+  },
+  async *transform(products) {
+    const document = create({ version: "1.0", encoding: "UTF-8" });
+    const root = document.ele("Products");
+    for await (const product of products) {
+      for (const variant of product.variants) {
+        appendPriceRunnerProduct(root, product, variant);
+      }
+    }
+    yield `${document.end({ prettyPrint: true })}
+`;
+  }
+};
+function appendPriceRunnerProduct(root, product, variant) {
+  const ean = variant.barcodes.find((barcode) => barcode.type === "ean")?.value ?? variant.barcodes.find((barcode) => barcode.type === "gtin")?.value;
+  const url = variant.url ?? product.url;
+  const image = primaryImage(product, variant);
+  const productElement = root.ele("Product");
+  productElement.ele("ProductId").txt(variant.id).up();
+  productElement.ele("ProductName").dat(variant.title || product.title).up();
+  if (variant.price) {
+    productElement.ele("Price").txt(formatMoney(variant.price) ?? "").up();
+  }
+  productElement.ele("StockStatus").txt(variant.availability?.available ? "in stock" : "out of stock").up();
+  if (product.brand) {
+    productElement.ele("Brand").dat(product.brand).up();
+  }
+  productElement.ele("Msku").txt(variant.id).up();
+  if (ean) {
+    productElement.ele("Ean").txt(ean).up();
+  }
+  if (url) {
+    productElement.ele("Url").txt(url).up();
+  }
+  if (image) {
+    productElement.ele("ImageUrl").txt(image).up();
+  }
+  productElement.ele("Description").dat(variant.description ?? productDescription(product)).up();
+  productElement.ele("Condition").txt("New").up();
+  productElement.ele("GroupId").txt(product.id).up();
+  for (const option of variant.options) {
+    productElement.ele(option.name).dat(option.value).up();
+  }
+}
+export {
+  pricerunnerFeedTransformer
+};

package/lib/transformers/shared.js

@@ -0,0 +1,25 @@
+function toMinorUnits(value) {
+  return Math.max(Math.round(value * 100), 0);
+}
+function formatMoney(money) {
+  if (!money) {
+    return void 0;
+  }
+  return `${money.value.toFixed(2)} ${money.currency.toUpperCase()}`;
+}
+function googleMoney(money) {
+  return formatMoney(money);
+}
+function primaryImage(product, variant) {
+  return variant?.images[0]?.url ?? product.images[0]?.url;
+}
+function productDescription(product) {
+  return product.description ?? product.title;
+}
+export {
+  formatMoney,
+  googleMoney,
+  primaryImage,
+  productDescription,
+  toMinorUnits
+};

package/lib/transformers/sitemap-feed.transformer.js

@@ -0,0 +1,26 @@
+import { toSitemapXml } from "../sitemap-xml.js";
+const sitemapFeedTransformer = {
+  id: "sitemap-feed",
+  title: "Sitemap XML Feed",
+  description: "XML sitemap of product URLs.",
+  output: {
+    contentType: "application/xml; charset=utf-8",
+    fileExtension: "xml"
+  },
+  async *transform(products) {
+    yield toSitemapXml(toProductSitemapEntries(products));
+  }
+};
+async function* toProductSitemapEntries(products) {
+  for await (const product of products) {
+    if (!product.url) {
+      continue;
+    }
+    yield {
+      url: product.url
+    };
+  }
+}
+export {
+  sitemapFeedTransformer
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@reactionary/feeds",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./src/index.d.ts",
+  "bin": {
+    "reactionary-feeds": "./bin/reactionary-feeds"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Solteq/reactionary.git"
+  },
+  "dependencies": {
+    "@reactionary/algolia": "0.0.1",
+    "@reactionary/commercetools": "0.0.1",
+    "@reactionary/core": "0.0.1",
+    "@reactionary/fake": "0.0.1",
+    "@reactionary/magento": "0.0.1",
+    "@reactionary/medusa": "0.0.1",
+    "@reactionary/meilisearch": "0.0.1",
+    "@reactionary/unomi": "0.0.1",
+    "commander": "^15.0.0",
+    "dotenv": "^17.2.2",
+    "sitemap": "^9.0.1",
+    "xmlbuilder2": "^4.0.3"
+  },
+  "devDependencies": {
+    "vitest": "^4.0.9"
+  },
+  "sideEffects": false
+}

package/src/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/src/index.d.ts

@@ -0,0 +1,13 @@
+export * from './lib/default-registry.js';
+export * from './lib/env-client-builder.js';
+export * from './lib/feed-generator.js';
+export * from './lib/feed-server.js';
+export * from './lib/feed-transformer.js';
+export * from './lib/feed-types.js';
+export * from './lib/sitemap-generator.js';
+export * from './lib/sitemap-xml.js';
+export * from './lib/load-cwd-env.js';
+export * from './lib/transformers/acp-product-feed.transformer.js';
+export * from './lib/transformers/google-merchant-feed.transformer.js';
+export * from './lib/transformers/pricerunner-feed.transformer.js';
+export * from './lib/transformers/sitemap-feed.transformer.js';

package/src/lib/default-registry.d.ts

@@ -0,0 +1,2 @@
+import { ReactionaryFeedTransformerRegistry } from './feed-transformer.js';
+export declare function createDefaultFeedRegistry(): ReactionaryFeedTransformerRegistry;

package/src/lib/env-client-builder.d.ts

@@ -0,0 +1,18 @@
+import { type Cache, type RequestContext } from '@reactionary/core';
+import type { ReactionaryFeedClient, ReactionaryFeedClientFactory } from './feed-types.js';
+export type ReactionaryFeedProviderSystem = 'ALGOLIA' | 'COMMERCETOOLS' | 'FAKE' | 'MAGENTO' | 'MEDUSA' | 'MEILISEARCH' | 'UNOMI';
+export interface CreateReactionaryFeedClientFromEnvOptions {
+    env?: NodeJS.ProcessEnv;
+    contextOverrides?: Partial<RequestContext>;
+    cache?: Cache;
+    loadEnv?: boolean;
+}
+export interface ReactionaryFeedClientFromEnv {
+    client: ReactionaryFeedClient;
+    enabledSystems: ReactionaryFeedProviderSystem[];
+}
+export declare function createReactionaryFeedClientFromEnv(options?: CreateReactionaryFeedClientFromEnvOptions): ReactionaryFeedClientFromEnv;
+export declare function createReactionaryFeedClientFactoryFromEnv(options?: Omit<CreateReactionaryFeedClientFromEnvOptions, 'contextOverrides'>): ReactionaryFeedClientFactory;
+export declare function getEnabledReactionaryFeedProviderSystems(env?: NodeJS.ProcessEnv): ReactionaryFeedProviderSystem[];
+export declare function getNoEnabledProviderSystemsMessage(): string;
+export declare function parseCommaSeparatedEnvList(value: string | undefined): string[];

package/src/lib/feed-generator.d.ts

@@ -0,0 +1,17 @@
+import type { RequestContext } from '@reactionary/core';
+import { type ReactionaryFeedClient, type ReactionaryFeedDefinition, type ReactionaryFeedGeneratorOptions, type ReactionaryFeedProduct } from './feed-types.js';
+export declare class ReactionaryFeedGenerator {
+    private readonly options;
+    private readonly client;
+    constructor(client: ReactionaryFeedClient, options?: ReactionaryFeedGeneratorOptions);
+    products(feed: ReactionaryFeedDefinition, requestContext: RequestContext): AsyncGenerator<ReactionaryFeedProduct>;
+    private toFeedProduct;
+    private toFeedVariant;
+    private getInventoryBySKU;
+    private getCategoryPath;
+    private getReviewData;
+    private reportProgress;
+}
+export declare function toProductUrl(slug: string | undefined, feed: ReactionaryFeedDefinition): string | undefined;
+export declare function getLanguage(feed: ReactionaryFeedDefinition['languageContext']): string;
+export declare function getTargetCountry(feed: ReactionaryFeedDefinition['languageContext']): string | undefined;

package/src/lib/feed-server.d.ts

@@ -0,0 +1,28 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { ReactionaryFeedTransformerRegistry } from './feed-transformer.js';
+import type { ReactionaryFeedClient, ReactionaryFeedClientFactory, ReactionaryFeedDefinition, ReactionaryFeedInventoryOptions, ReactionaryFeedProcessingOptions, ReactionarySitemapOptions } from './feed-types.js';
+export interface ReactionaryFeedServerOptions extends ReactionaryFeedInventoryOptions, ReactionaryFeedProcessingOptions {
+    basePath?: string;
+    feeds: Record<string, ReactionaryFeedDefinition>;
+    sitemaps?: ReactionarySitemapOptions;
+    registry?: ReactionaryFeedTransformerRegistry;
+}
+export interface ReactionaryFeedHttpHandler {
+    fetch(request: Request): Promise<Response>;
+    close(): Promise<void>;
+}
+export type ReactionaryFeedNodeRequestHandler = (request: IncomingMessage, response: ServerResponse) => Promise<void>;
+export declare class ReactionaryFeedServer<TClient extends ReactionaryFeedClient = ReactionaryFeedClient> {
+    private readonly clientFactory;
+    private readonly options;
+    private readonly registry;
+    constructor(clientFactory: ReactionaryFeedClientFactory<TClient>, options: ReactionaryFeedServerOptions);
+    fetch(request: Request): Promise<Response>;
+    getHandler(): ReactionaryFeedHttpHandler;
+    toNodeHandler(): ReactionaryFeedNodeRequestHandler;
+    close(): Promise<void>;
+    private handleRequest;
+    private generateFeedResponse;
+    private generateSitemapIndexResponse;
+    private generateSitemapResponse;
+}

package/src/lib/feed-transformer.d.ts

@@ -0,0 +1,30 @@
+import type { ReactionaryFeedDefinition, ReactionaryFeedProduct } from './feed-types.js';
+export interface ReactionaryFeedTransformContext<TOptions = unknown> {
+    feedId: string;
+    feed: ReactionaryFeedDefinition;
+    options: TOptions;
+}
+export interface ReactionaryFeedTransformer<TOptions = unknown> {
+    id: string;
+    title: string;
+    description?: string;
+    output: {
+        contentType: string;
+        fileExtension: string;
+    };
+    defaultOptions?: TOptions;
+    transform(products: AsyncIterable<ReactionaryFeedProduct>, context: ReactionaryFeedTransformContext<TOptions>): AsyncIterable<string | Uint8Array>;
+}
+export interface ReactionaryFeedTransformerSummary {
+    id: string;
+    title: string;
+    description?: string;
+    contentType: string;
+    fileExtension: string;
+}
+export declare class ReactionaryFeedTransformerRegistry {
+    private readonly transformers;
+    register(transformer: ReactionaryFeedTransformer): void;
+    get(id: string): ReactionaryFeedTransformer | undefined;
+    list(): ReactionaryFeedTransformerSummary[];
+}

package/src/lib/feed-types.d.ts

@@ -0,0 +1,185 @@
+import type { Category, CategoryPaginatedResult, Cache, Inventory, LanguageContext, Price, Product, ProductRatingSummary, ProductReviewPaginatedResult, ProductSearchResult, RequestContext, Result, SearchIdentifier, Store } from '@reactionary/core';
+export interface ReactionaryFeedClient {
+    cache?: Cache;
+    productSearch?: {
+        queryByTerm(payload: unknown): Promise<Result<ProductSearchResult>>;
+    };
+    product?: {
+        getBySKU(payload: unknown): Promise<Result<Product>>;
+    };
+    productReviews?: {
+        getRatingSummary(payload: unknown): Promise<Result<ProductRatingSummary>>;
+        findReviews(payload: unknown): Promise<Result<ProductReviewPaginatedResult>>;
+    };
+    price?: {
+        getCustomerPrice(payload: unknown): Promise<Result<Price>>;
+        getListPrice(payload: unknown): Promise<Result<Price>>;
+    };
+    inventory?: {
+        getBySKU(payload: unknown): Promise<Result<Inventory>>;
+    };
+    category?: {
+        getBreadcrumbPathToCategory?(payload: unknown): Promise<Result<Category[]>>;
+        findTopCategories(payload: unknown): Promise<Result<CategoryPaginatedResult>>;
+        findChildCategories(payload: unknown): Promise<Result<CategoryPaginatedResult>>;
+    };
+    store?: {
+        queryByProximity(payload: unknown): Promise<Result<Store[]>>;
+    };
+}
+export type ValidatedReactionaryFeedClient = ReactionaryFeedClient & {
+    productSearch: NonNullable<ReactionaryFeedClient['productSearch']>;
+    product: NonNullable<ReactionaryFeedClient['product']>;
+    price: NonNullable<ReactionaryFeedClient['price']>;
+    inventory: NonNullable<ReactionaryFeedClient['inventory']>;
+};
+export type ReactionaryFeedClientFactory<TClient extends ReactionaryFeedClient = ReactionaryFeedClient> = (requestContext: RequestContext) => TClient;
+export interface ReactionaryFeedInventoryOptions {
+    defaultFulfillmentCenterKeys?: string[];
+}
+export interface ReactionaryFeedProcessingOptions {
+    productConcurrency?: number;
+}
+export interface ReactionaryFeedProgress {
+    phase: 'searching' | 'generating' | 'completed';
+    processedProducts: number;
+    totalProducts?: number;
+    pageNumber?: number;
+    totalPages?: number;
+    elapsedMs: number;
+}
+export interface ReactionaryFeedGeneratorOptions extends ReactionaryFeedInventoryOptions, ReactionaryFeedProcessingOptions {
+    onProgress?: (progress: ReactionaryFeedProgress) => void;
+}
+export interface ReactionaryFeedDefinition {
+    languageContext: LanguageContext;
+    search: SearchIdentifier;
+    pageSize?: number;
+    maxPages?: number;
+    fulfillmentCenterKeys?: string[];
+    fulfillmentCenterKey?: string;
+    productUrlBase?: string;
+    sellerName?: string;
+    metadata?: Record<string, unknown>;
+}
+export type ReactionarySitemapChangeFrequency = 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never';
+export interface ReactionarySitemapEntry {
+    url: string;
+    lastmod?: Date | string;
+    changefreq?: ReactionarySitemapChangeFrequency;
+    priority?: number;
+}
+export interface ReactionarySitemapBaseDefinition {
+    languageContext: LanguageContext;
+    changefreq?: ReactionarySitemapChangeFrequency;
+    priority?: number;
+}
+export interface ReactionaryProductSitemapDefinition extends Partial<ReactionarySitemapBaseDefinition> {
+    type: 'products';
+    feed: string;
+}
+export interface ReactionaryCategorySitemapDefinition extends ReactionarySitemapBaseDefinition {
+    type: 'categories';
+    urlTemplate: string;
+    pageSize?: number;
+    maxPagesPerLevel?: number;
+    maxDepth?: number;
+    includeChildren?: boolean;
+}
+export interface ReactionaryStoreSitemapDefinition extends ReactionarySitemapBaseDefinition {
+    type: 'stores';
+    urlTemplate: string;
+    proximity: {
+        longitude: number;
+        latitude: number;
+        distance: number;
+        limit: number;
+    };
+}
+export type ReactionarySitemapDefinition = ReactionaryProductSitemapDefinition | ReactionaryCategorySitemapDefinition | ReactionaryStoreSitemapDefinition;
+export interface ReactionarySitemapOptions {
+    baseUrl: string;
+    sources: Record<string, ReactionarySitemapDefinition>;
+    include?: string[];
+}
+export interface ReactionaryFeedImage {
+    url: string;
+    altText?: string;
+}
+export interface ReactionaryFeedMoney {
+    value: number;
+    currency: string;
+}
+export interface ReactionaryFeedBarcode {
+    type: 'ean' | 'gtin' | 'upc' | 'barcode';
+    value: string;
+}
+export interface ReactionaryFeedVariantOption {
+    name: string;
+    value: string;
+}
+export interface ReactionaryFeedAvailability {
+    available: boolean;
+    status: 'in_stock' | 'out_of_stock' | 'backorder' | 'preorder' | 'discontinued';
+    quantity?: number;
+}
+export interface ReactionaryFeedCategory {
+    id: string;
+    name: string;
+    slug?: string;
+}
+export interface ReactionaryFeedRatingSummary {
+    averageRating: number;
+    totalRatings?: number;
+    ratingDistribution?: Record<string, number>;
+}
+export interface ReactionaryFeedReview {
+    id: string;
+    authorName: string;
+    rating: number;
+    title: string;
+    content: string;
+    createdAt: string;
+    verified: boolean;
+}
+export interface ReactionaryFeedVariant {
+    id: string;
+    title: string;
+    description?: string;
+    url?: string;
+    ean?: string;
+    gtin?: string;
+    upc?: string;
+    barcode?: string;
+    manufacturerPartNumber?: string;
+    images: ReactionaryFeedImage[];
+    price?: ReactionaryFeedMoney;
+    listPrice?: ReactionaryFeedMoney;
+    availability?: ReactionaryFeedAvailability;
+    barcodes: ReactionaryFeedBarcode[];
+    options: ReactionaryFeedVariantOption[];
+    metadata?: Record<string, unknown>;
+}
+export interface ReactionaryFeedProduct {
+    id: string;
+    title: string;
+    description?: string;
+    url?: string;
+    brand?: string;
+    manufacturer?: string;
+    categoryPath?: ReactionaryFeedCategory[];
+    ratingSummary?: ReactionaryFeedRatingSummary;
+    reviews?: ReactionaryFeedReview[];
+    images: ReactionaryFeedImage[];
+    variants: ReactionaryFeedVariant[];
+    metadata?: Record<string, unknown>;
+}
+export interface ReactionaryFeedGenerateInput {
+    feedId: string;
+    feed: ReactionaryFeedDefinition;
+    requestContext: RequestContext;
+}
+export declare function assertReactionaryFeedClient(client: ReactionaryFeedClient): asserts client is ValidatedReactionaryFeedClient;
+export declare function getMissingFeedClientOperations(client: ReactionaryFeedClient): string[];
+export declare function getMissingSitemapClientOperations(client: ReactionaryFeedClient, source: ReactionarySitemapDefinition): string[];
+export declare function assertReactionarySitemapClient(client: ReactionaryFeedClient, source: ReactionarySitemapDefinition): void;

package/src/lib/load-cwd-env.d.ts

@@ -0,0 +1,4 @@
+export interface LoadCwdEnvOptions {
+    env?: NodeJS.ProcessEnv;
+}
+export declare function loadCwdEnv(options?: LoadCwdEnvOptions): void;

package/src/lib/sitemap-generator.d.ts

@@ -0,0 +1,20 @@
+import type { RequestContext } from '@reactionary/core';
+import type { ReactionaryFeedClient, ReactionaryFeedDefinition, ReactionaryFeedGeneratorOptions, ReactionarySitemapDefinition, ReactionarySitemapEntry } from './feed-types.js';
+export declare class ReactionarySitemapGenerator {
+    private readonly client;
+    private readonly feeds;
+    private readonly options;
+    constructor(client: ReactionaryFeedClient, feeds: Record<string, ReactionaryFeedDefinition>, options?: ReactionaryFeedGeneratorOptions);
+    entries(source: ReactionarySitemapDefinition, requestContext: RequestContext): AsyncGenerator<ReactionarySitemapEntry>;
+    private productEntries;
+    private categoryEntries;
+    private categoryWithChildrenEntries;
+    private iterCategoryPageResults;
+    private storeEntries;
+}
+export declare function toTemplatedUrl(urlTemplate: string, languageContext: {
+    locale: string;
+}, values: {
+    id: string;
+    slug?: string;
+}): string | undefined;

package/src/lib/sitemap-xml.d.ts

@@ -0,0 +1,3 @@
+import type { ReactionarySitemapEntry } from './feed-types.js';
+export declare function toSitemapXml(entries: AsyncIterable<ReactionarySitemapEntry>): Promise<string>;
+export declare function toSitemapIndexXml(urls: Iterable<string>): Promise<string>;

package/src/lib/transformers/acp-product-feed.transformer.d.ts

@@ -0,0 +1,4 @@
+import type { ReactionaryFeedTransformer } from '../feed-transformer.js';
+export declare const acpProductFeedTransformer: ReactionaryFeedTransformer<{
+    format?: 'jsonl' | 'json';
+}>;