@stacksjs/commerce 0.75.40 → 0.75.42

package/dist/customers/store.d.ts

@@ -6,5 +6,11 @@ import type { Customer, ModelRow, NewModelData } from '@stacksjs/orm';
  * @returns The newly created customer record
  */
 export declare function store(data: NewCustomer): Promise<CustomerJsonResponse>;
+/**
+ * The avatar a customer gets when nothing supplies one. `customers.avatar` is
+ * NOT NULL and the dashboard requires an http(s) URL there, so a row without
+ * one would break the customer list. The customer importer uses it too.
+ */
+export declare const DEFAULT_CUSTOMER_AVATAR: 'https://images.unsplash.com/photo-1472099645785-5658abf4ff4e?w=400&fit=crop&q=60';
 declare type CustomerJsonResponse = ModelRow<typeof Customer>;
 declare type NewCustomer = NewModelData<typeof Customer>;

package/dist/imports/account-mapping.d.ts

@@ -0,0 +1,44 @@
+import type { CatalogWarning } from './types';
+/**
+ * An email as the deduplication key: trimmed and lowercased, or null when it
+ * is not an address at all. The domain part is case-insensitive by spec, and
+ * every platform treats the local part that way in practice, so `Bob@Shop.com`
+ * and `bob@shop.com ` are one customer.
+ */
+export declare function normalizeEmail(input: unknown): string | null;
+/** A timestamp as ISO 8601 UTC, or null when it is missing or unreadable. */
+export declare function isoTimestamp(input: unknown): string | null;
+/**
+ * WooCommerce's `*_gmt` fields are UTC without a zone designator
+ * (`2026-09-14T09:12:44`), which `Date` would read as local time.
+ */
+export declare function gmtTimestamp(input: unknown): string | null;
+/** `first last`, collapsed, or null when both are empty. */
+export declare function personName(...parts: unknown[]): string | null;
+/** A phone number as text, capped at the `customers.phone` length. */
+export declare function phoneOf(...candidates: unknown[]): string | null;
+/** Address parts joined into the single line `orders.delivery_address` holds. */
+export declare function addressLine(...parts: unknown[]): string | null;
+/**
+ * A signed decimal (a string, or a JSON number) as signed integer minor units.
+ *
+ * `decimalToMinor` accepts magnitudes only, so the sign is split off first.
+ * A float is never multiplied: a JSON number goes through the decimal string
+ * it was serialized as (`numberToMinor`).
+ */
+export declare function signedMinor(value: unknown, exponent: number): number | null;
+/**
+ * An amount that must not be negative, as minor units, or `fallback` with a
+ * warning when it is missing, malformed or negative. The order tables hold
+ * every amount as a non-negative integer.
+ */
+export declare function amountOrZero(value: unknown, exponent: number, label: string, externalId: string, warnings: CatalogWarning[], fallback?: number): number;
+/**
+ * A line total spread over its quantity, in minor units, rounded half up.
+ * Integer arithmetic only: `(2 * total + quantity) / (2 * quantity)`, floored.
+ */
+export declare function unitFromTotal(totalMinor: number, quantity: number): number;
+/** A positive whole quantity, or null. */
+export declare function quantityOf(value: unknown): number | null;
+/** A three-letter ISO 4217 code, uppercased, or null. */
+export declare function currencyCode(value: unknown): string | null;

package/dist/imports/account-types.d.ts

@@ -0,0 +1,99 @@
+import type { CatalogSourceName, CatalogWarning, FetchLike } from './types';
+import type { OrderStatus } from '../orders/events';
+/**
+ * The normalized customers and orders the credentialed import maps into
+ * (stacksjs/stacks#2853).
+ *
+ * The catalog import reads public storefront APIs. Customers and orders are
+ * only on each platform's admin API, behind credentials: a Shopify Admin API
+ * access token, WooCommerce REST API consumer keys, or a Shopware Admin API
+ * integration. Each source is an adapter that maps its own payloads into these
+ * records in pure functions, so the writer never sees a platform's shape and
+ * every mapping is testable from recorded JSON.
+ *
+ * Money is integer minor units of the record's own currency throughout.
+ * Nothing here has a field for a password hash or payment card data, and no
+ * adapter requests one: what is not mapped cannot be written.
+ */
+/** A customer as every source maps it. */
+export declare interface AccountCustomer {
+  source: CatalogSourceName
+  externalId: string | null
+  email: string
+  name: string
+  phone: string | null
+  active: boolean | null
+  totalSpentMinor: number | null
+  currency: string | null
+  lastOrderAt: string | null
+  avatarUrl: string | null
+  createdAt: string | null
+}
+/** Who placed an order, as the order itself records it. */
+export declare interface AccountOrderCustomer {
+  externalId: string | null
+  email: string | null
+  name: string | null
+  phone: string | null
+}
+/** One purchased line of an order. */
+export declare interface AccountOrderLine {
+  externalId: string
+  productExternalId: string | null
+  variantExternalId: string | null
+  name: string
+  sku: string | null
+  quantity: number
+  unitPriceMinor: number
+}
+export declare interface AccountOrder {
+  source: CatalogSourceName
+  externalId: string
+  number: string | null
+  currency: string
+  status: OrderStatus
+  sourceStatus: string
+  totalMinor: number
+  taxMinor: number
+  discountMinor: number
+  shippingMinor: number
+  tipMinor: number
+  customer: AccountOrderCustomer | null
+  shippingAddress: string | null
+  note: string | null
+  placedAt: string | null
+  lines: AccountOrderLine[]
+  refundedMinor?: number
+}
+/** A source payload mapped to a record (or skipped), with what the mapping noticed. */
+export declare interface MappedAccountRecord<T> {
+  record: T | null
+  warnings: CatalogWarning[]
+}
+/** One page of a source's customers or orders, already normalized. */
+export declare interface AccountPage<T> {
+  url: string
+  items: T[]
+  warnings: CatalogWarning[]
+}
+export declare interface AccountFetchOptions {
+  credentials: AccountCredentials
+  limit?: number
+  fetch?: FetchLike
+  currency?: string
+  adminUrl?: string
+  sleep?: (ms: number) => Promise<void>
+}
+/**
+ * A source of customers and orders. Implement this to add a platform: map its
+ * payloads in pure functions, and page through its admin API here.
+ */
+export declare interface AccountAdapter {
+  name: CatalogSourceName
+  customers: (storeUrl: string, options: AccountFetchOptions) => AsyncIterable<AccountPage<AccountCustomer>>
+  orders: (storeUrl: string, options: AccountFetchOptions) => AsyncIterable<AccountPage<AccountOrder>>
+}
+/** Credentials for one source. Read from env only, never from a flag. */
+export type AccountCredentials = | { source: 'shopify', accessToken: string }
+  | { source: 'woocommerce', consumerKey: string, consumerSecret: string }
+  | { source: 'shopware', clientId: string, clientSecret: string }

package/dist/imports/account-writer.d.ts

@@ -0,0 +1,237 @@
+import type { AccountCustomer, AccountOrder, AccountOrderLine } from './account-types';
+import type { CatalogWarning } from './types';
+import type { ImportAction, ImportCounts } from './writer';
+/** The uuid a customer gets when an import creates it: from the source id, else from the email. */
+export declare function customerUuid(source: string, host: string, externalId: string | null, email: string): string;
+/**
+ * The account uuid a row found by email should take, or null to leave it.
+ *
+ * Only a uuid this importer derived from that same email (a guest, or a
+ * shopper first seen on an order) is replaced: it names no source record, so
+ * once the source has an account for the address, the account's id is the
+ * better key. A row created any other way (checkout, the dashboard, another
+ * store) keeps its uuid, which something else may already refer to.
+ */
+export declare function promotedCustomerUuid(source: string, host: string, existingUuid: string | null, externalId: string | null, email: string): string | null;
+/** The `customers` row for an imported customer. Pure. */
+export declare function customerRow(customer: AccountCustomer, uuid: string, now: string, mode: 'create' | 'update'): CustomerRow;
+/** `Name (SKU X)`: what `order_items.special_instructions` keeps of a line. */
+export declare function lineLabel(line: AccountOrderLine): string;
+/** The `orders` row for an imported order. Pure. */
+export declare function orderRow(order: AccountOrder, host: string, customerId: number | null, now: string): OrderRow;
+/**
+ * Fetch a store's customers through `adapter` and upsert them via
+ * `repository`, deduplicated by email. Idempotent: a second run over an
+ * unchanged store updates every row and creates none.
+ */
+export declare function importCustomers(options: ImportCustomersOptions): Promise<CustomerImportResult>;
+/**
+ * Fetch a store's orders through `adapter` and upsert them, with their lines,
+ * via `repository`. Each order's customer is the Stacks customer with its
+ * email (created from the order when there is none); each line links to the
+ * product the catalog import wrote, when it exists.
+ */
+export declare function importOrders(options: ImportOrdersOptions): Promise<OrderImportResult>;
+/**
+ * A repository over the commerce tables, via the query builder.
+ *
+ * Inserts are read back by `uuid`, which works on every dialect. Emails are
+ * compared with `LOWER()` on both sides, because rows created by checkout or
+ * the dashboard keep whatever case the shopper typed.
+ */
+export declare function createDatabaseAccountRepository(connection?: any): AccountRepository;
+/**
+ * A repository that keeps rows in memory. Pass the catalog memory
+ * repository's `tables` to share its products and variants, as a real
+ * database would.
+ */
+export declare function createMemoryAccountRepository(shared?: { tables: Record<string, Array<Record<string, any>>> }): AccountRepository & { 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 createReadOnlyAccountRepository(inner: AccountRepository): AccountRepository;
+/**
+ * Writing imported customers and orders into the built-in commerce tables.
+ *
+ * Where each field lands, given the columns those tables actually have:
+ *
+ * | Source                          | Column                                              |
+ * |---------------------------------|-----------------------------------------------------|
+ * | customer email (trim, lowercase)| `customers.email`, the deduplication key            |
+ * | customer id + store host        | `customers.uuid` on create (UUIDv5, `identity.ts`)  |
+ * | first + last name               | `customers.name` (the email when there is none)     |
+ * | phone                           | `customers.phone`                                   |
+ * | lifetime spend, when reported   | `customers.total_spent`, integer minor units        |
+ * | last order date, when reported  | `customers.last_order`, and moved forward (never    |
+ * |   or placed by an imported order|   back) to the latest order the import links to it  |
+ * | account disabled (Shopware)     | `customers.status` `Inactive`                       |
+ * | order id + store host           | `orders.uuid` (UUIDv5)                              |
+ * | mapped status                   | `orders.status` (the `OrderStatus` vocabulary)      |
+ * | currency                        | `orders.currency`, per order                        |
+ * | total / tax / discount / shipping / tip | `orders.total_amount` / `tax_amount` / `discount_amount` / `delivery_fee` / `tip_amount`, minor units |
+ * | shipping address, one line      | `orders.delivery_address`                           |
+ * | customer note                   | `orders.special_instructions`                       |
+ * | placed at                       | `orders.created_at`                                 |
+ * | each line                       | `order_items`: quantity, unit `price`, `product_id` |
+ * | line label and SKU              | `order_items.special_instructions`                  |
+ *
+ * Customers are deduplicated by email, case-insensitively. A customer is
+ * matched first by the uuid an earlier run derived from its source id (so a
+ * changed email updates the row instead of adding one), then by email, so a
+ * customer who already exists in Stacks (a checkout, another store) is updated
+ * rather than duplicated. A row an earlier run created for a guest (its uuid
+ * derived from the email) takes the account's uuid once the shopper has an
+ * account at the source, so a later change of address there still finds it.
+ * Nothing password- or card-shaped is ever written: the normalized records
+ * have no field for either.
+ *
+ * Orders are matched on their derived uuid. A re-run updates the order and
+ * replaces its lines, since `order_items` has no identity column of its own;
+ * the lines of an imported order belong to the source. A line is linked to the
+ * product the catalog import wrote, through the same deterministic identities
+ * (`catalogUuid`). A line whose product is not in Stacks yet is kept, with no
+ * `product_id`, its label and price intact, and reported: import the catalog,
+ * re-run the order import, and the lines link. A line that names no product
+ * at the source (a fee, a custom item, a product deleted since) is kept the
+ * same way and counted apart, since no catalog import will ever link it.
+ *
+ * Writes go through the query builder, not the models, so importing a store's
+ * history fires no `order:created` events or emails to its customers.
+ */
+export declare interface CustomerRow {
+  uuid?: string
+  name: string
+  email?: string
+  phone?: string | null
+  total_spent?: number
+  last_order?: string | null
+  status?: 'Active' | 'Inactive'
+  avatar?: string
+  created_at?: string
+  updated_at: string
+}
+export declare interface OrderRow {
+  uuid: string
+  status: string
+  total_amount: number
+  currency: string
+  tax_amount: number
+  discount_amount: number
+  delivery_fee: number
+  tip_amount: number
+  order_type: string
+  delivery_address: string | null
+  special_instructions: string | null
+  customer_id?: number | null
+  created_at: string
+  updated_at: string
+}
+export declare interface OrderItemRow {
+  order_id: number
+  product_id: number | null
+  quantity: number
+  price: number
+  special_instructions: string
+  created_at: string
+  updated_at: string
+}
+export declare interface ExistingCustomer {
+  id: number
+  uuid: string | null
+  email: string
+}
+/**
+ * Where the importer reads and writes customers and orders. The database
+ * implementation is below; tests and `--dry-run` use the in-memory and
+ * read-only ones. Every `find*` takes a whole page's keys at once.
+ */
+export declare interface AccountRepository {
+  findCustomers: (query: { uuids: string[], emails: string[] }) => Promise<ExistingCustomer[]>
+  createCustomer: (row: CustomerRow) => Promise<number>
+  updateCustomer: (id: number, row: CustomerUpdate) => Promise<void>
+  advanceLastOrder?: (id: number, at: string) => Promise<void>
+  findOrders: (uuids: string[]) => Promise<Map<string, number>>
+  createOrder: (row: OrderRow) => Promise<number>
+  updateOrder: (id: number, row: Omit<OrderRow, 'uuid'>) => Promise<void>
+  replaceOrderItems: (orderId: number, rows: OrderItemRow[]) => Promise<void>
+  findProducts: (uuids: string[]) => Promise<Map<string, number>>
+  findVariantProducts: (uuids: string[]) => Promise<Map<string, number>>
+  transaction?: <T>(work: (repository: AccountRepository) => Promise<T>) => Promise<T>
+}
+export declare interface ImportedCustomer {
+  action: ImportAction
+  externalId: string | null
+  email: string
+  name: string
+  matchedBy: 'uuid' | 'email' | null
+}
+export declare interface ImportedOrder {
+  action: ImportAction
+  externalId: string
+  number: string | null
+  status: string
+  sourceStatus: string
+  totalMinor: number
+  currency: string
+  lines: number
+  unlinkedLines: number
+  productlessLines: number
+  refundedMinor: number
+  customerEmail: string | null
+}
+export declare interface CustomerImportResult {
+  source: string
+  storeUrl: string
+  dryRun: boolean
+  pages: string[]
+  customers: ImportedCustomer[]
+  counts: {
+    customers: ImportCounts
+    merged: number
+  }
+  warnings: CatalogWarning[]
+}
+export declare interface OrderImportResult {
+  source: string
+  storeUrl: string
+  dryRun: boolean
+  pages: string[]
+  orders: ImportedOrder[]
+  counts: {
+    orders: ImportCounts
+    customers: ImportCounts
+    lines: { linked: number, unlinked: number, productless: number }
+    duplicates: number
+    partlyRefunded: number
+  }
+  currencies: string[]
+  warnings: CatalogWarning[]
+}
+declare interface AccountImportOptions extends AccountFetchOptions {
+  adapter: AccountAdapter
+  storeUrl: string
+  repository: AccountRepository
+  dryRun?: boolean
+  now?: () => Date
+}
+export declare interface ImportCustomersOptions extends AccountImportOptions {
+  onCustomer?: (customer: ImportedCustomer) => void
+}
+export declare interface ImportOrdersOptions extends AccountImportOptions {
+  onOrder?: (order: ImportedOrder) => void
+}
+/** The columns an update writes; anything left out keeps its value. */
+export type CustomerUpdate = Partial<CustomerRow> & { updated_at: string }
+/**
+ * Resolves customers to row ids by uuid, then by email, across a whole run.
+ * Lookups are batched per page; rows created during the run are remembered so
+ * the next order for the same email finds them without a query.
+ */
+declare class CustomerIndex {
+  load(repository: AccountRepository, keys: Array<{ uuid: string | null, email: string | null }>): Promise<void>;
+  remember(id: number, uuid: string | null, email: string | null): void;
+  find(uuid: string | null, email: string | null): { id: number, matchedBy: 'uuid' | 'email' } | null;
+  uuidOf(id: number): string | null;
+  emailTakenByOther(email: string, id: number): boolean;
+}

package/dist/imports/admin-http.d.ts

@@ -0,0 +1,30 @@
+import { CatalogFetchError } from './http';
+import type { FetchLike } from './types';
+import type { JsonRequest, JsonResponse } from './http';
+/** One admin API call, with rate-limit retries and credential-aware errors. */
+export declare function adminRequest<T>(url: string, options: AdminRequestOptions): Promise<JsonResponse<T>>;
+/**
+ * Authenticated requests to a platform's admin API.
+ *
+ * On top of `fetchJson` (which names the failing URL), this:
+ *
+ * - waits out a 429 for as long as `Retry-After` asks (Shopify sends it on
+ *   every throttled call; its REST leaky bucket refills at 2 calls a second),
+ *   then retries, up to `MAX_RETRIES` times;
+ * - turns a 401 or 403 into a message about the credential, saying which
+ *   variables to check and where to create them, without ever repeating a
+ *   secret: every message is scrubbed of the credential values, including
+ *   any a server echoed back in its error body.
+ */
+export declare const MAX_RETRIES: 5;
+export declare const defaultSleep: (ms: number) => Promise<void>;
+export declare interface AdminRequestOptions extends JsonRequest {
+  fetch: FetchLike
+  secrets: string[]
+  credentialHelp: string
+  hint?: string
+  sleep?: (ms: number) => Promise<void>
+}
+export declare class AdminCredentialError extends CatalogFetchError {
+  constructor(url: string, message: string, status: number);
+}

package/dist/imports/credentials.d.ts

@@ -0,0 +1,44 @@
+import type { AccountCredentials } from './account-types';
+/**
+ * The credentials `source` needs, from `env`, or a `MissingCredentialsError`
+ * naming every variable that is unset and where to create them. The values
+ * themselves never appear in a message.
+ */
+export declare function readAccountCredentials(source: string, env: Env): AccountCredentials;
+/** Every secret value in `credentials`, for scrubbing from messages. */
+export declare function credentialSecrets(credentials: AccountCredentials): string[];
+/** `text` with every secret replaced, so an error never repeats a credential, even one a server echoed. */
+export declare function redactSecrets(text: string, secrets: string[]): string;
+/**
+ * Admin API credentials for the customer and order import, from env only.
+ *
+ * A credential passed as a command-line flag lands in shell history, in `ps`
+ * output for every user on the machine, and in CI logs that echo commands.
+ * There is deliberately no flag for any of these: the operator exports them,
+ * or puts them in `.env`, which `buddy` loads.
+ *
+ * Every check here runs before the first request, so a missing credential
+ * fails with the variable names and where to create them, never with a 401
+ * halfway through an import.
+ */
+export declare const ACCOUNT_CREDENTIAL_ENV: {
+  shopify: readonly ['SHOPIFY_ADMIN_TOKEN'];
+  woocommerce: readonly ['WOOCOMMERCE_CONSUMER_KEY', 'WOOCOMMERCE_CONSUMER_SECRET'];
+  shopware: readonly ['SHOPWARE_CLIENT_ID', 'SHOPWARE_CLIENT_SECRET']
+};
+/**
+ * Where each platform issues the credentials, for every message that asks for them.
+ * @defaultValue
+ * ```ts
+ * {
+ *   shopify: 'Create a custom app for the store (Shopify admin > Settings > Apps > Develop apps, or the Shopify Dev Dashboard), give it the Admin API scopes read_customers and read_orders (plus read_all_orders for orders older than 60 days), install it, and copy its Admin API access token (shpat_...).',
+ *   woocommerce: 'Create a key in WordPress admin > WooCommerce > Settings > Advanced > REST API > Add key, with Read permission, for a user who can manage WooCommerce. The key starts with ck_ and the secret with cs_.',
+ *   shopware: 'Create an integration in the Shopware Administration > Settings > System > Integrations, with a role that can read customers and orders. Its access key id (SWIA...) is the client id and its secret access key is the client secret.'
+ * }
+ * ```
+ */
+export declare const ACCOUNT_CREDENTIAL_HELP: Record<keyof typeof ACCOUNT_CREDENTIAL_ENV, string>;
+declare type Env = Record<string, string | undefined>;
+export declare class MissingCredentialsError extends Error {
+  constructor(message: string);
+}

package/dist/imports/http.d.ts

@@ -9,6 +9,11 @@ import type { FetchLike } from './types';
 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;
+/**
+ * `Retry-After` as seconds. Shopify sends a decimal (`"2.0"`); the HTTP spec
+ * also allows an HTTP date. Anything unreadable is undefined, not zero.
+ */
+export declare function retryAfterSeconds(header: string | null | undefined, now?: () => number): number | undefined;
 /** 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> {
@@ -32,5 +37,6 @@ 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);
+  public readonly retryAfter?: number;
+  constructor(url: string, message: string, status?: number, body?: string, retryAfter?: number);
 }

package/dist/imports/identity.d.ts

@@ -19,4 +19,9 @@ export declare function catalogUuid(source: string, host: string, kind: CatalogR
  */
 /** 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';
+/**
+ * What an identity names. `customer` and `order` come from the credentialed
+ * import (`accounts.ts`), and share the namespace so an order's line items
+ * resolve to the very `product` and `variant` uuids the catalog import wrote.
+ */
+export type CatalogRecordKind = 'product' | 'variant' | 'customer' | 'order';

package/dist/imports/index.d.ts

@@ -1,4 +1,16 @@
+import type { AccountAdapter } from './account-types';
 import type { CatalogAdapter } from './types';
+export type {
+  AccountAdapter,
+  AccountCredentials,
+  AccountCustomer,
+  AccountFetchOptions,
+  AccountOrder,
+  AccountOrderCustomer,
+  AccountOrderLine,
+  AccountPage,
+  MappedAccountRecord,
+} from './account-types';
 export type {
   CatalogAdapter,
   CatalogCategory,
@@ -14,6 +26,8 @@ export type {
 } from './types';
 /** The adapter registered under `name`, case-insensitively. */
 export declare function catalogAdapter(name: string): CatalogAdapter | undefined;
+/** The customer and order adapter registered under `name`, case-insensitively. */
+export declare function accountAdapter(name: string): AccountAdapter | undefined;
 /**
  * Catalog import from other commerce platforms (stacksjs/stacks#1319, #1320,
  * #1321).
@@ -25,13 +39,27 @@ export declare function catalogAdapter(name: string): CatalogAdapter | undefined
  *
  * Adding a platform means writing a `CatalogAdapter` (a pure payload mapper
  * plus a pager) and registering it in `catalogAdapters`.
+ *
+ * Customers and orders (stacksjs/stacks#2853) come from each platform's admin
+ * API instead, with credentials read from env only (`credentials.ts`):
+ * `buddy commerce:import <store-url> --from <platform> --customers --orders`.
+ * Those adapters are `AccountAdapter`s, registered in `accountAdapters`, and
+ * written by `importCustomers` / `importOrders` (`account-writer.ts`).
  */
 export declare const catalogAdapters: Readonly<Record<string, CatalogAdapter>>;
+export declare const accountAdapters: Readonly<Record<string, AccountAdapter>>;
+export * from './account-mapping';
+export * from './account-writer';
+export * from './admin-http';
+export * from './credentials';
 export * from './http';
 export * from './identity';
 export * from './money';
 export * from './shopify';
+export * from './shopify-admin';
 export * from './shopware';
+export * from './shopware-admin';
 export * from './text';
 export * from './woocommerce';
+export * from './woocommerce-admin';
 export * from './writer';

package/dist/imports/shopify-admin.d.ts

@@ -0,0 +1,95 @@
+import type { AccountAdapter, AccountCustomer, AccountOrder, MappedAccountRecord } from './account-types';
+import type { OrderStatus } from '../orders/events';
+/** One Admin API customer as a normalized customer, or null with the reason. Pure. */
+export declare function mapShopifyCustomer(raw: ShopifyCustomerPayload): MappedAccountRecord<AccountCustomer>;
+/**
+ * The Stacks status for a Shopify order, and whether Shopify's combination
+ * was one this knows. Shopify has no "delivered": a fulfilled order shipped.
+ */
+export declare function shopifyOrderStatus(raw: Pick<ShopifyOrderPayload, 'financial_status' | 'fulfillment_status' | 'cancelled_at'>): { status: OrderStatus, mapped: boolean };
+/** One Admin API order as a normalized order, or null with the reason. Pure. */
+export declare function mapShopifyOrder(raw: ShopifyOrderPayload, context?: { currency?: string }): MappedAccountRecord<AccountOrder>;
+/** The `page_info` cursor of the `rel="next"` entry in a `Link` header, or null on the last page. */
+export declare function nextPageInfo(link: string | null | undefined): string | null;
+/** The admin API base: `adminUrl` when given (a custom domain's `.myshopify.com`), else the store URL. HTTPS only. */
+export declare function shopifyAdminBase(storeUrl: string, adminUrl?: string): string;
+/**
+ * Shopify customers and orders, through the Admin REST API.
+ *
+ * Authenticated with a custom app's Admin API access token in the
+ * `X-Shopify-Access-Token` header (from `SHOPIFY_ADMIN_TOKEN`). Pages with
+ * cursor pagination: each response's `Link` header carries the next page's
+ * `page_info`, and a request with `page_info` may only add `limit` and
+ * `fields`, so every follow-up URL is rebuilt from those three.
+ *
+ * `fields` keeps each response to what the mappers read. Nothing requested
+ * carries a password (the Admin API never exposes one) or payment card data
+ * (`payment_details` and transactions are not requested).
+ *
+ * Shopify marked the REST Admin API legacy in October 2024 but keeps serving
+ * it to custom apps; the version is pinned so a Shopify-side change is a
+ * deliberate bump here, not a silent shape change.
+ */
+export declare const SHOPIFY_ADMIN_API_VERSION: '2026-10';
+export declare const shopifyAccountAdapter: AccountAdapter;
+export declare interface ShopifyAddressPayload {
+  first_name?: string | null
+  last_name?: string | null
+  name?: string | null
+  address1?: string | null
+  address2?: string | null
+  city?: string | null
+  province?: string | null
+  province_code?: string | null
+  zip?: string | null
+  country?: string | null
+  country_code?: string | null
+  phone?: string | null
+}
+export declare interface ShopifyCustomerPayload {
+  id: number | string
+  email?: string | null
+  first_name?: string | null
+  last_name?: string | null
+  phone?: string | null
+  state?: string | null
+  total_spent?: string | null
+  currency?: string | null
+  created_at?: string | null
+  default_address?: ShopifyAddressPayload | null
+}
+export declare interface ShopifyLineItemPayload {
+  id: number | string
+  product_id?: number | string | null
+  variant_id?: number | string | null
+  sku?: string | null
+  title?: string | null
+  variant_title?: string | null
+  name?: string | null
+  quantity?: number | null
+  price?: string | null
+}
+export declare interface ShopifyOrderPayload {
+  id: number | string
+  name?: string | null
+  order_number?: number | null
+  email?: string | null
+  contact_email?: string | null
+  created_at?: string | null
+  processed_at?: string | null
+  cancelled_at?: string | null
+  currency?: string | null
+  total_price?: string | null
+  total_tax?: string | null
+  total_discounts?: string | null
+  total_shipping_price_set?: { shop_money?: { amount?: string | null, currency_code?: string | null } | null } | null
+  shipping_lines?: Array<{ price?: string | null }> | null
+  total_tip_received?: string | null
+  financial_status?: string | null
+  fulfillment_status?: string | null
+  customer?: (Partial<ShopifyCustomerPayload> & { id?: number | string | null }) | null
+  billing_address?: ShopifyAddressPayload | null
+  shipping_address?: ShopifyAddressPayload | null
+  line_items?: ShopifyLineItemPayload[] | null
+  note?: string | null
+}