@stacksjs/commerce 0.75.37 → 0.75.40

package/dist/imports/http.d.ts

@@ -0,0 +1,36 @@
+import type { FetchLike } from './types';
+/**
+ * A store URL as a base to append API paths to.
+ *
+ * Accepts a bare host (`shop.example.com`), a full URL, or a WordPress install
+ * in a subdirectory (`https://example.com/shop`), whose path must be kept for
+ * `/wp-json` to resolve. Query string and fragment are dropped.
+ */
+export declare function normalizeStoreUrl(input: string): string;
+/** The lowercased host of a normalized store URL, used to scope identities. */
+export declare function storeHost(storeUrl: string): string;
+/** Fetch a URL and parse it as JSON (GET unless `request` says otherwise), or throw a `CatalogFetchError` naming it. */
+export declare function fetchJson<T = unknown>(url: string, fetcher?: FetchLike, hint?: string, request?: JsonRequest): Promise<JsonResponse<T>>;
+export declare interface JsonResponse<T> {
+  data: T
+  headers: Headers
+}
+/** A request other than a plain GET: Shopware's Store API takes criteria as a POST body. */
+export declare interface JsonRequest {
+  method?: 'GET' | 'POST'
+  headers?: Record<string, string>
+  json?: unknown
+}
+/**
+ * The importer's only network primitive.
+ *
+ * Every failure names the URL that failed. "fetch failed" on its own leaves
+ * the operator guessing which of forty pages broke, and whether it was the
+ * store, the network or the importer.
+ */
+export declare class CatalogFetchError extends Error {
+  public readonly url: string;
+  public readonly status?: number;
+  public readonly body?: string;
+  constructor(url: string, message: string, status?: number, body?: string);
+}

package/dist/imports/identity.d.ts

@@ -0,0 +1,22 @@
+/** RFC 9562 version 5 (SHA-1, name-based) UUID. */
+export declare function uuidV5(name: string, namespace?: string): string;
+/** The deterministic `uuid` for one imported record. */
+export declare function catalogUuid(source: string, host: string, kind: CatalogRecordKind, externalId: string): string;
+/**
+ * Stable row identities for imported records, without a schema change.
+ *
+ * Re-running an import must update what the last run wrote rather than add a
+ * second copy, so every imported row needs a key that survives between runs.
+ * `products` has no slug, SKU or external-id column to hold one, and names
+ * are not unique on any platform.
+ *
+ * Every commerce table already has a unique `uuid` column (the `useUuid`
+ * trait). A name-based UUID (RFC 9562 version 5) of
+ * `<source>:<store host>:<kind>:<external id>` is the same value on every run
+ * and unique per source record, so the existing column doubles as the
+ * external-id index. Rows created any other way keep their random v7 UUIDs and
+ * can never collide with these.
+ */
+/** Namespace for every UUID the catalog importer derives. Never change it. */
+export declare const CATALOG_IMPORT_NAMESPACE: '5d0c8a3e-6f1b-4c2a-9e47-b18f3d2a6c90';
+export type CatalogRecordKind = 'product' | 'variant';

package/dist/imports/index.d.ts

@@ -0,0 +1,37 @@
+import type { CatalogAdapter } from './types';
+export type {
+  CatalogAdapter,
+  CatalogCategory,
+  CatalogFetchOptions,
+  CatalogImage,
+  CatalogPage,
+  CatalogProduct,
+  CatalogSourceName,
+  CatalogVariant,
+  CatalogWarning,
+  FetchLike,
+  MappedProduct,
+} from './types';
+/** The adapter registered under `name`, case-insensitively. */
+export declare function catalogAdapter(name: string): CatalogAdapter | undefined;
+/**
+ * Catalog import from other commerce platforms (stacksjs/stacks#1319, #1320,
+ * #1321).
+ *
+ * Catalog only, from each platform's public storefront API: no credentials
+ * (Shopware's Store API wants its public sales channel access key), and
+ * therefore no customers or orders. Run it with
+ * `buddy commerce:import <store-url> --from shopify|woocommerce|shopware`.
+ *
+ * Adding a platform means writing a `CatalogAdapter` (a pure payload mapper
+ * plus a pager) and registering it in `catalogAdapters`.
+ */
+export declare const catalogAdapters: Readonly<Record<string, CatalogAdapter>>;
+export * from './http';
+export * from './identity';
+export * from './money';
+export * from './shopify';
+export * from './shopware';
+export * from './text';
+export * from './woocommerce';
+export * from './writer';

package/dist/imports/money.d.ts

@@ -0,0 +1,40 @@
+import { decimalToMinor, PriceFormatError } from '../money';
+/**
+ * A JSON number as the plain decimal string it was written as.
+ *
+ * `String()` gives the shortest decimal that parses back to the same double,
+ * which is the literal the source serialized: `19.99` is `"19.99"`, not the
+ * `19.989999999999998` the double actually holds. Only the exponent form
+ * (`1e-7`, `1e+21`) needs expanding, and that is done on the digits, not by
+ * arithmetic.
+ */
+export declare function numberToDecimalString(value: number): string;
+/**
+ * A decimal amount that arrived as a JSON number (or a numeric string) as
+ * integer minor units, or null when it is missing.
+ */
+export declare function numberToMinor(value: number | string | null | undefined, exponent?: number): number | null;
+/**
+ * Money at the import boundary.
+ *
+ * Sources hand prices over in three shapes. Shopify sends decimal strings in
+ * the shop's currency (`"19.99"`); the WooCommerce Store API sends an integer
+ * string already in minor units, plus how many decimals the STORE is
+ * configured with (`currency_minor_unit`), which is not always the ISO number;
+ * the Shopware Store API sends JSON numbers (`19.99`, `0.1`, `1999.5`).
+ *
+ * Both string shapes are converted by the commerce-wide money module
+ * (`../money`), which the dashboard and the order export use as well, so an
+ * imported `1999` and a dashboard-entered `19.99` land as the same integer and
+ * read back the same way (stacksjs/stacks#2851). JSON numbers are first
+ * written out as the decimal string they were parsed from, then go the same
+ * way, so no amount is ever multiplied as a float.
+ */
+export {
+  currencyExponent,
+  decimalToMinor,
+  formatMinor,
+  minorToDecimal,
+  PriceFormatError,
+  rescaleMinor,
+} from '../money';

package/dist/imports/shopify.d.ts

@@ -0,0 +1,40 @@
+import type { CatalogAdapter, CatalogFetchOptions, MappedProduct } from './types';
+declare function price(value: unknown, exponent: number, label: string, externalId: string, warnings: CatalogWarning[]): number | null;
+/** One `products.json` entry as a normalized catalog product. Pure. */
+export declare function mapShopifyProduct(raw: ShopifyProductPayload, context: ShopifyMapContext): MappedProduct;
+/** The shop's currency from `/meta.json`, or null if the store will not say. */
+export declare function detectShopifyCurrency(storeUrl: string, fetcher?: CatalogFetchOptions['fetch']): Promise<string | null>;
+export declare const shopifyAdapter: CatalogAdapter;
+export declare interface ShopifyVariantPayload {
+  id: number | string
+  title?: string | null
+  sku?: string | null
+  price?: string | number | null
+  compare_at_price?: string | number | null
+  available?: boolean | null
+  inventory_quantity?: number | null
+  option1?: string | null
+  option2?: string | null
+  option3?: string | null
+}
+export declare interface ShopifyImagePayload {
+  src?: string | null
+  position?: number | null
+  alt?: string | null
+}
+export declare interface ShopifyProductPayload {
+  id: number | string
+  title?: string | null
+  handle?: string | null
+  body_html?: string | null
+  vendor?: string | null
+  product_type?: string | null
+  tags?: string[] | string | null
+  variants?: ShopifyVariantPayload[] | null
+  images?: ShopifyImagePayload[] | null
+  options?: Array<{ name?: string | null, values?: string[] | null }> | null
+}
+export declare interface ShopifyMapContext {
+  storeUrl: string
+  currency: string | null
+}

package/dist/imports/shopware.d.ts

@@ -0,0 +1,80 @@
+import type { CatalogAdapter, FetchLike, MappedProduct } from './types';
+/**
+ * `translated.<field>` (the value in the sales channel's language, with
+ * inheritance from the parent already applied), else the entity's own field.
+ * Shopware serializes an empty `translated` as `[]`, hence the object check.
+ */
+declare function translated(entity: object | null | undefined, field: string): string | null;
+/** One Store API parent product, plus its children, as a catalog product. Pure. */
+export declare function mapShopwareProduct(raw: ShopwareProductPayload, context: ShopwareMapContext): MappedProduct;
+/**
+ * A store URL as the base the Store API hangs off. Accepts the storefront URL
+ * or the API endpoint itself (`https://shop.example.com/store-api`), which is
+ * what headless storefront configs list.
+ */
+export declare function shopwareBaseUrl(storeUrl: string): string;
+/** Why `--access-key` is needed, before any request is made. */
+export declare function missingAccessKeyMessage(): string;
+/** The sales channel currency from `/store-api/context`, or null if it will not say. */
+export declare function detectShopwareCurrency(base: string, accessKey: string, fetcher?: FetchLike): Promise<string | null>;
+/** Criteria for one page of parent products (variants come separately). */
+export declare function shopwareProductCriteria(page: number, limit: number): Record<string, unknown>;
+/** Criteria for one page of the variants of `parentIds`. */
+export declare function shopwareVariantCriteria(parentIds: string[], page: number): Record<string, unknown>;
+/** Where an operator finds the key, for every message that asks for it. */
+export declare const SHOPWARE_ACCESS_KEY_HELP: 'Find it in the Shopware Administration under Sales Channels: open the storefront or headless sales channel and copy the key from its "API access" card. A headless storefront also ships it in its page source.';
+export declare const shopwareAdapter: CatalogAdapter;
+export declare interface ShopwareNamedPayload {
+  id?: string | null
+  name?: string | null
+  translated?: { name?: string | null } | unknown[] | null
+}
+export declare interface ShopwarePropertyGroupPayload extends ShopwareNamedPayload {
+  position?: number | null
+}
+export declare interface ShopwareOptionPayload extends ShopwareNamedPayload {
+  groupId?: string | null
+  position?: number | null
+  group?: ShopwarePropertyGroupPayload | null
+}
+export declare interface ShopwareMediaPayload {
+  url?: string | null
+  alt?: string | null
+  title?: string | null
+  translated?: { alt?: string | null, title?: string | null } | unknown[] | null
+}
+export declare interface ShopwareProductMediaPayload {
+  position?: number | null
+  media?: ShopwareMediaPayload | null
+}
+export declare interface ShopwareCalculatedPricePayload {
+  unitPrice?: number | string | null
+  quantity?: number | null
+  listPrice?: { price?: number | string | null } | null
+}
+export declare interface ShopwareProductPayload {
+  id: string
+  parentId?: string | null
+  productNumber?: string | null
+  name?: string | null
+  description?: string | null
+  translated?: { name?: string | null, description?: string | null } | unknown[] | null
+  calculatedPrice?: ShopwareCalculatedPricePayload | null
+  stock?: number | null
+  availableStock?: number | null
+  available?: boolean | null
+  active?: boolean | null
+  childCount?: number | null
+  manufacturer?: ShopwareNamedPayload | null
+  seoCategory?: ShopwareNamedPayload | null
+  categories?: ShopwareNamedPayload[] | null
+  tags?: Array<{ name?: string | null }> | null
+  cover?: ShopwareProductMediaPayload | null
+  media?: ShopwareProductMediaPayload[] | null
+  options?: ShopwareOptionPayload[] | null
+}
+export declare interface ShopwareMapContext {
+  storeUrl: string
+  currency: string | null
+  children?: ShopwareProductPayload[]
+}

package/dist/imports/text.d.ts

@@ -0,0 +1,6 @@
+/** Decode HTML character references (named, decimal and hex) in one pass. */
+export declare function decodeHtmlEntities(input: string): string;
+/** A name for storage: entities decoded, whitespace collapsed, trimmed. */
+export declare function cleanName(input: unknown): string;
+/** A non-empty string, or null. */
+export declare function optionalString(input: unknown): string | null;

package/dist/imports/types.d.ts

@@ -0,0 +1,79 @@
+export declare interface CatalogImage {
+  src: string
+  alt: string | null
+}
+export declare interface CatalogCategory {
+  name: string
+  slug: string
+}
+export declare interface CatalogVariant {
+  externalId: string
+  title: string
+  sku: string | null
+  priceMinor: number | null
+  compareAtMinor: number | null
+  available: boolean
+  inventory: number | null
+  optionValues: string[]
+}
+export declare interface CatalogProduct {
+  source: CatalogSourceName
+  externalId: string
+  name: string
+  handle: string
+  descriptionHtml: string | null
+  vendor: string | null
+  categories: CatalogCategory[]
+  tags: string[]
+  currency: string | null
+  images: CatalogImage[]
+  optionNames: string[]
+  variants: CatalogVariant[]
+  hasOptions: boolean
+  url: string | null
+}
+/** A non-fatal problem found while mapping or fetching. */
+export declare interface CatalogWarning {
+  externalId?: string
+  message: string
+}
+/** A source payload mapped to a product, with what the mapping noticed. */
+export declare interface MappedProduct {
+  product: CatalogProduct
+  warnings: CatalogWarning[]
+}
+/** One page of a source's catalog, already normalized. */
+export declare interface CatalogPage {
+  url: string
+  products: CatalogProduct[]
+  warnings: CatalogWarning[]
+}
+export declare interface CatalogFetchOptions {
+  limit?: number
+  fetch?: FetchLike
+  currency?: string
+  accessKey?: string
+}
+/**
+ * A source of catalog data. Implement this to add a platform: map its payload
+ * to `CatalogProduct` in a pure function, and page through it here.
+ */
+export declare interface CatalogAdapter {
+  name: CatalogSourceName
+  pages: (storeUrl: string, options?: CatalogFetchOptions) => AsyncIterable<CatalogPage>
+}
+/**
+ * The normalized catalog every import source maps into.
+ *
+ * Each source (Shopify, WooCommerce, and whatever comes next) is an adapter
+ * that turns its own payloads into these records. The writer only ever sees
+ * this shape, so adding a source never touches the code that talks to the
+ * database, and the mapping is testable from recorded JSON with no I/O.
+ *
+ * Money is integer minor units of `currency` throughout. A source that hands
+ * out decimal strings converts at its own boundary (see `money.ts`).
+ */
+/** A source registered with the importer. */
+export type CatalogSourceName = 'shopify' | 'woocommerce' | 'shopware' | (string & {});
+/** `fetch`, narrowed to what the importer uses, so tests can inject one. */
+export type FetchLike = (input: string, init?: RequestInit) => Promise<Response>;

package/dist/imports/woocommerce.d.ts

@@ -0,0 +1,62 @@
+import { slug } from '@stacksjs/strings';
+import type { CatalogAdapter, MappedProduct } from './types';
+/**
+ * Store API prices as minor units of the currency's ISO precision.
+ *
+ * `prices.price` is already an integer, but at the STORE's configured decimals
+ * (`currency_minor_unit`), which a merchant can set to anything. A sale price
+ * makes the regular price the compare-at price.
+ */
+export declare function wooPrices(prices: WooPricesPayload | null | undefined): Prices;
+declare function terms(list: WooTermPayload[] | null | undefined): Array<{ name: string, slug: string }>;
+/** One Store API product, plus its fetched variations, as a catalog product. Pure. */
+export declare function mapWooProduct(raw: WooProductPayload, context?: WooMapContext): MappedProduct;
+export declare const wooCommerceAdapter: CatalogAdapter;
+export declare interface WooPricesPayload {
+  price?: string | null
+  regular_price?: string | null
+  sale_price?: string | null
+  currency_code?: string | null
+  currency_minor_unit?: number | string | null
+}
+export declare interface WooTermPayload {
+  id?: number
+  name?: string | null
+  slug?: string | null
+}
+export declare interface WooAttributePayload {
+  id?: number
+  name?: string | null
+  taxonomy?: string | null
+  has_variations?: boolean
+  terms?: WooTermPayload[] | null
+}
+export declare interface WooProductPayload {
+  id: number | string
+  name?: string | null
+  slug?: string | null
+  type?: string | null
+  parent?: number | null
+  permalink?: string | null
+  sku?: string | null
+  description?: string | null
+  short_description?: string | null
+  prices?: WooPricesPayload | null
+  images?: Array<{ src?: string | null, alt?: string | null }> | null
+  categories?: WooTermPayload[] | null
+  tags?: WooTermPayload[] | null
+  brands?: WooTermPayload[] | null
+  attributes?: WooAttributePayload[] | null
+  variations?: Array<{ id: number | string, attributes?: Array<{ name?: string | null, value?: string | null }> | null }> | null
+  is_in_stock?: boolean | null
+  is_purchasable?: boolean | null
+  low_stock_remaining?: number | null
+}
+export declare interface WooMapContext {
+  variations?: Map<string, WooProductPayload>
+}
+declare interface Prices {
+  currency: string | null
+  priceMinor: number | null
+  compareAtMinor: number | null
+}

package/dist/imports/writer.d.ts

@@ -0,0 +1,202 @@
+import type { CatalogAdapter, CatalogFetchOptions, CatalogProduct, CatalogVariant, CatalogWarning } from './types';
+/** The lowest price among a product's priced variants. */
+export declare function lowestPrice(variants: CatalogVariant[]): number | null;
+/** Total stock, or null unless every variant reports its count. */
+export declare function totalInventory(variants: CatalogVariant[]): number | null;
+/**
+ * The SKU each of a product's variants may write, keyed by variant id.
+ *
+ * `product_variants.sku` is unique per product, but no source enforces that:
+ * Shopify accepts the same SKU on every variant. The first variant to carry a
+ * SKU keeps it; a later duplicate, or a SKU too long for the column, is
+ * written as no SKU and reported, rather than failing the whole product.
+ */
+export declare function variantSkus(product: CatalogProduct): { skus: Map<string, string | null>, warnings: CatalogWarning[] };
+/** The `products` row for a catalog product. Pure. */
+export declare function productRow(product: CatalogProduct, host: string, refs: ProductRefs, now: string, mode: 'create' | 'update'): ProductRow;
+/**
+ * The `product_variants` row for one variant of a catalog product. Pure.
+ *
+ * `sku` is the SKU this variant may claim (see `variantSkus`), which can be
+ * null even when the source reported one.
+ */
+export declare function variantRow(product: CatalogProduct, variant: CatalogVariant, host: string, productId: number, now: string, mode: 'create' | 'update', sku?: string | null): VariantRow;
+/**
+ * Fetch a store's catalog through `adapter` and upsert it via `repository`.
+ *
+ * Idempotent: products and variants are matched on their derived `uuid`,
+ * categories on slug (then name) and manufacturers on name, so a second run
+ * over an unchanged store creates nothing.
+ */
+export declare function importCatalog(options: ImportCatalogOptions): Promise<ImportResult>;
+/**
+ * A repository over the commerce tables, via the query builder.
+ *
+ * Inserts are read back by `uuid`, which works on every dialect: Postgres
+ * reports no insert id without `RETURNING`, and a row count is never an id.
+ */
+export declare function createDatabaseRepository(connection?: any): CatalogRepository;
+/**
+ * A repository that keeps rows in memory. Backs the importer's own tests and
+ * a `--dry-run` with no database to compare against.
+ */
+export declare function createMemoryRepository(): CatalogRepository & { tables: Record<string, Array<Record<string, any>>> };
+/**
+ * Reads through to `inner`, writes nothing. What `--dry-run` uses, so its
+ * report says "create" or "update" exactly as a real run would.
+ */
+export declare function createReadOnlyRepository(inner: CatalogRepository): CatalogRepository;
+/** Manufacturers require a country; the source never says which. */
+export declare const UNKNOWN_COUNTRY: 'Unknown';
+/** `product_variants.sku` is a 100-character column (see the model). */
+export declare const SKU_MAX: 100;
+/**
+ * Writing a normalized catalog into the built-in commerce tables.
+ *
+ * Where each field lands, given the columns those tables actually have:
+ *
+ * | Source                      | Column                                         |
+ * |-----------------------------|------------------------------------------------|
+ * | product id + store host     | `products.uuid` (UUIDv5, see `identity.ts`)    |
+ * | title / name                | `products.name`                                |
+ * | description (HTML)          | `products.description`, unchanged              |
+ * | lowest variant price        | `products.price`, integer minor units          |
+ * | first image URL             | `products.image_url` (never downloaded)        |
+ * | any variant available       | `products.is_available`                        |
+ * | summed stock, when exposed  | `products.inventory_count`                     |
+ * | first product type/category | `categories` by slug, then `category_id`       |
+ * | vendor / brand              | `manufacturers` by name, then `manufacturer_id` |
+ * | each real option variant    | `product_variants` (uuid from the variant id)  |
+ * | variant SKU                 | `product_variants.sku`, unique per product     |
+ * | variant price / compare-at  | `product_variants.price` / `compare_at_price`  |
+ * | variant stock, when exposed | `product_variants.inventory_count`             |
+ *
+ * Variant money is integer minor units, like `products.price`. A NULL variant
+ * `price` means "inherits the product price"; a NULL `inventory_count` means
+ * stock is not tracked. `options` holds the option values as the JSON string
+ * array the dashboard reads. A variant's `description` is never written: the
+ * source has no per-variant description, so the column is the merchant's.
+ *
+ * Re-running updates the rows a previous run wrote (matched on `uuid`) and
+ * leaves alone the columns an operator owns: `preparation_time`, `allergens`,
+ * `nutritional_info`, a variant's `description`, and a product's or variant's
+ * `inventory_count` or a variant's `sku` when the source does not report one.
+ *
+ * The source wins a SKU. Before a product's variants are updated, the SKUs it
+ * is about to write are released from whichever of that product's variants
+ * holds them (see `releaseVariantSkus`), so a SKU that moved between variants
+ * at the source, or still sits on a variant the source has since deleted,
+ * cannot trip the per-product unique index halfway through the product.
+ */
+export declare interface ProductRow {
+  uuid: string
+  name: string
+  description: string | null
+  price: number
+  image_url: string | null
+  is_available: boolean
+  inventory_count?: number
+  preparation_time?: number
+  category_id?: number | null
+  manufacturer_id?: number | null
+  created_at?: string
+  updated_at: string
+}
+export declare interface VariantRow {
+  uuid: string
+  product_id: number
+  variant: string
+  type: string
+  options: string
+  status: 'active' | 'inactive'
+  sku?: string | null
+  price: number | null
+  compare_at_price: number | null
+  inventory_count?: number | null
+  created_at?: string
+  updated_at: string
+}
+export declare interface CategoryRow {
+  uuid: string
+  name: string
+  slug: string
+  description: null
+  image_url: null
+  is_active: boolean
+  parent_category_id: null
+  display_order: number
+  created_at: string
+  updated_at: string
+}
+export declare interface ManufacturerRow {
+  uuid: string
+  manufacturer: string
+  description: null
+  country: string
+  featured: boolean
+  created_at: string
+  updated_at: string
+}
+/**
+ * Where the importer reads and writes. The database implementation is below;
+ * tests and `--dry-run` use the in-memory and read-only ones.
+ */
+export declare interface CatalogRepository {
+  findCategory: (slug: string, name: string) => Promise<number | undefined>
+  createCategory: (row: CategoryRow) => Promise<number>
+  findManufacturer: (name: string) => Promise<number | undefined>
+  createManufacturer: (row: ManufacturerRow) => Promise<number>
+  findProducts: (uuids: string[]) => Promise<Map<string, number>>
+  createProduct: (row: ProductRow) => Promise<number>
+  updateProduct: (id: number, row: Omit<ProductRow, 'uuid'>) => Promise<void>
+  findVariants: (uuids: string[]) => Promise<Map<string, number>>
+  createVariant: (row: VariantRow) => Promise<number>
+  updateVariant: (id: number, row: Omit<VariantRow, 'uuid'>) => Promise<void>
+  releaseVariantSkus: (productId: number, skus: string[]) => Promise<void>
+  transaction?: <T>(work: (repository: CatalogRepository) => Promise<T>) => Promise<T>
+}
+export declare interface ProductRefs {
+  categoryId: number | null
+  manufacturerId: number | null
+}
+export declare interface ImportedProduct {
+  action: ImportAction
+  externalId: string
+  name: string
+  handle: string
+  priceMinor: number | null
+  currency: string | null
+  variants: { create: number, update: number }
+  category: string | null
+  vendor: string | null
+  imageCount: number
+}
+export declare interface ImportCounts {
+  created: number
+  updated: number
+}
+export declare interface ImportResult {
+  source: string
+  storeUrl: string
+  dryRun: boolean
+  pages: string[]
+  products: ImportedProduct[]
+  counts: {
+    products: ImportCounts
+    variants: ImportCounts
+    categories: ImportCounts
+    manufacturers: ImportCounts
+    duplicates: number
+  }
+  currencies: string[]
+  warnings: CatalogWarning[]
+}
+export declare interface ImportCatalogOptions extends CatalogFetchOptions {
+  adapter: CatalogAdapter
+  storeUrl: string
+  repository: CatalogRepository
+  dryRun?: boolean
+  onProduct?: (product: ImportedProduct) => void
+  now?: () => Date
+}
+export type ImportAction = 'create' | 'update';

package/dist/index.d.ts

@@ -1,10 +1,12 @@
 import * as auctions from './auctions/index';
 import * as carts from './carts/index';
+import * as catalogImport from './imports/index';
 import * as coupons from './coupons/index';
 import * as customers from './customers/index';
 import * as devices from './devices/index';
 import * as errors from './errors/index';
 import * as giftCards from './gift-cards/index';
+import * as money from './money';
 import * as orders from './orders/index';
 import * as payments from './payments/index';
 import * as products from './products/index';
@@ -13,6 +15,7 @@ import * as restaurant from './waitlists/restaurant/index';
 import * as shippings from './shippings/index';
 import * as tax from './tax/index';
 import * as waitlists from './waitlists/index';
+export type { MoneyInputOptions } from './money';
 export declare const commerce: CommerceNamespace;
 export declare interface CommerceNamespace {
   auctions: AuctionsModule
@@ -46,14 +49,18 @@ declare type TaxModule = typeof tax;
 declare type WaitlistsModule = typeof waitlists;
 declare type DevicesModule = typeof devices;
 declare type ReceiptsModule = typeof receipts;
+// Catalog import (Shopify, WooCommerce) is a tool rather than a store module,
+// so it is exported beside the namespace rather than inside it.
 export {
   auctions,
   carts,
+  catalogImport,
   coupons,
   customers,
   devices,
   errors,
   giftCards,
+  money,
   orders,
   payments,
   products,
@@ -63,4 +70,20 @@ export {
   tax,
   waitlists,
 };
+// Money conversion at the display and input boundary: stored amounts are
+// integer minor units everywhere (stacksjs/stacks#2851). Browser code imports
+// the same functions from `@stacksjs/commerce/money`, which pulls in nothing else.
+export {
+  currencyExponent,
+  decimalToMinor,
+  formatCurrency,
+  formatMinor,
+  minorToDecimal,
+  minorToInput,
+  minorToMajor,
+  moneyInputError,
+  moneyInputStep,
+  parseMoneyInput,
+  PriceFormatError,
+} from './money';
 export default commerce;