@toolpath/tool-scraper 0.1.0 → 2.0.0

package/dist/vendors/emuge/records.js

@@ -0,0 +1,375 @@
+/**
+ * EMUGE-FRANKEN rows -> {@link ToolRecord}.
+ *
+ * The CSV a scrape writes holds the vendor's own value strings — `1 1/2 "`,
+ * `3 mm`, `140 deg`, `4` — rather than parsed numbers, because the file is the
+ * receipt and EMUGE's fractional inches and stated units are part of what it
+ * published. So this module is where a cell becomes a number, through
+ * `value.ts`. The closest precedent is Harvey Tool's, not Kennametal's, whose
+ * columns are already decimals.
+ *
+ * ## What EMUGE publishes that nobody else here does
+ *
+ * - **Both identity columns.** The 18-digit SAP material number and the catalog
+ *   article code, per part, so there is no `conventions.IDENTITY_DEVIATIONS`
+ *   entry — the first vendor since Kennametal that needs none.
+ * - **A point angle, per drill.** Kennametal's drill families assume theirs; the
+ *   detail record states it, so `SIG` is a mapped column here and no fact.
+ * - **A per-part ISO 513 index.** `applicationMaterials` returns the vendor's
+ *   own P/M/K/N/S/H rating for each part, which fills `materialGroups` as
+ *   `vendor-stated`.
+ * - **A description for every part.** The grouped product's `productListInfo`
+ *   is one sentence of the vendor's own prose per product line, so every kind
+ *   here fills `description` from `conventions.DESCRIPTION_COLUMN` — including
+ *   the tap, where Kennametal has to fall back to the thread designation
+ *   because it publishes no such text. EMUGE's designation is on the CSV as
+ *   `dimensionFeatureValue` and its thread is on the record as `TP`.
+ *
+ * ## What it does not publish
+ *
+ * **No flute count on a drill or a tap.** Not on the grouped product, the
+ * variant listing, the per-part detail or any facet. A drill's comes from the
+ * family's `flutes` fact — all seventeen drill groups state
+ * `Specification: Twist drill` — and a tap's is simply absent, which is why
+ * `records.RECORD_GEOMETRY.tap` lists `NOF` under `sometimes`. EMUGE's own tap
+ * families run 2, 3 and 4 flutes across a size range, so no per-family constant
+ * could be true of every row, and 0 is not a substitute for a number nobody
+ * stated.
+ *
+ * **No CAD a scrape can reach.** The STEP, DXF and DIN 4000 documents are
+ * published behind a login — `anonymousAccess: false`, with both URL fields
+ * null — so neither `conventions.CAD_COLUMN` nor `CAD_DXF_COLUMN` is written.
+ * See `docs/EMUGE_FRANKEN_COMMERCE_API.md`.
+ */
+import { columnReaders } from '../../columns.js';
+import { DESCRIPTION_COLUMN } from '../../conventions.js';
+import { VendorResponseError } from '../../errors.js';
+import { fact, familyBrand } from '../../family.js';
+import { BRANDS } from '../../identity.js';
+import { ISO_MATERIAL_GROUPS, toolRecord, UNSPECIFIED, } from '../../records.js';
+import { consoleWarn } from '../../scrape.js';
+import { APPLICATION_MATERIALS_COLUMN, CATALOG_NUMBER_COLUMN, MATERIAL_NUMBER_COLUMN, } from './scrape.js';
+import { measureIn, parseMeasure, wholeCount } from './value.js';
+/** The cutting-material property, spelled the same way in all three categories. */
+export const SUBSTRATE_COLUMN = 'Cutting material';
+/**
+ * The coating property, which is **not** spelled the same way.
+ *
+ * `coating` on a milling part and `Coating` on a drill or a tap, in the same
+ * API, on the same day. Both are read and the first non-empty one wins, because
+ * relabelling one onto the other in the CSV would be this adapter deciding what
+ * the vendor meant — see `scrape.ts`.
+ */
+export const COATING_COLUMNS = ['coating', 'Coating'];
+/**
+ * Whether a part is through-coolant, by the vendor's own word for it.
+ *
+ * Three columns and three vocabularies, one per category, each a closed facet
+ * this package read off the vendor's own index on 2026-09-01 — so a value
+ * absent from here is a vocabulary that changed rather than a part that is
+ * odd, and {@link coolantThrough} refuses it by naming the table to add to.
+ *
+ * ## The facet does not cover the whole of milling
+ *
+ * The values below account for 6,862 milling variants, 2,670 drilling and
+ * 11,566 tapping. Drilling and tapping are the whole category — the same two
+ * numbers `docs/EMUGE_FRANKEN_COMMERCE_API.md` §4 gives — and milling is
+ * **159 short** of `FF01`'s 7,021, which is also `families/emuge.ts`'s two row
+ * counts added up. So 159 milling variants carry no `internal coolant supply`
+ * value at all.
+ *
+ * That is a gap in the vendor's index rather than a vocabulary that moved, and
+ * it is why {@link coolantThrough} separates the two cases: an unrecognised
+ * *value* still refuses, and a column nobody filled warns and records `false`.
+ * They were one case until 2026-09-01, and because `registry.toRecords` maps
+ * its rows, a single such part threw and took the whole family's conversion
+ * with it — 159 unindexed variants for two dead end mill CSVs.
+ */
+export const COOLANT_COLUMNS = {
+    // `HYB_AMM_KMIZU`, milling.
+    'internal coolant supply': {
+        'ICA - Axial hole': true,
+        'ICR - Radial hole': true,
+        'ICRA - Radial & Axial holes': true,
+        'Without internal cooling': false,
+    },
+    // `HYB_TAM_IKZ`, drilling. Note that "external coolant supply" is a real
+    // statement rather than a blank: it is how EMUGE says a drill has no through
+    // hole, and 164 of its 2,670 drill variants are it.
+    'Coolant supply': {
+        'internal coolant supply': true,
+        'external coolant supply': false,
+    },
+    // `HYB_BAM_IKZ`, tapping.
+    'coolant supply': {
+        'IKZ - Axial hole': true,
+        'IKZN - Radial hole': true,
+        Without: false,
+    },
+};
+/**
+ * The vendor's cutting materials, onto the package's own vocabulary.
+ *
+ * `FamilyFacts.bmc` names a material class — `carbide`, `hss`, `diamond` — and
+ * EMUGE's index names an alloy and a production route: HSS, HSSE and HSSE-PM
+ * are three grades of high-speed steel and all three are `hss`. `PCD` is
+ * `diamond`, which is the call `families/kennametal.ts` already made for its
+ * PCD drills: the word names the cutting material rather than the body it is
+ * brazed to.
+ *
+ * `cbn` and `ceramic` keep the vendor's own name, lowercased, because the
+ * package's three words have no counterpart for either and inventing one would
+ * be worse than recording what is standard. Closed, and it throws on anything
+ * else — the seven values below are the whole of the vendor's `HYB_AAM_MAT`
+ * facet across all three categories (2026-09-01).
+ */
+export const SUBSTRATES = {
+    carbide: 'carbide',
+    HSS: 'hss',
+    HSSE: 'hss',
+    'HSSE-PM': 'hss',
+    PCD: 'diamond',
+    CBN: 'cbn',
+    ceramic: 'ceramic',
+};
+/**
+ * The flute count EMUGE publishes where it has none: 64 end mill variants, on
+ * 2026-09-01. A sentinel and not a number, so it is refused rather than read.
+ */
+export const NO_FLUTE_COUNT = 999;
+/**
+ * The three column readers, over this vendor's grammar.
+ *
+ * `measureIn` is the only EMUGE-specific half; everything either side of it —
+ * an unmapped column answering undefined, a required field refusing the row —
+ * is `columns.columnReaders`, shared with Harvey Tool's mapper.
+ */
+const { cell, required, optional } = columnReaders(measureIn);
+/**
+ * An angle in degrees — the drill's point angle.
+ *
+ * Read through {@link parseMeasure} rather than {@link measureIn}, which
+ * refuses degrees on purpose: a length column stating an angle is a property
+ * that has moved. Here degrees are what the column is for.
+ */
+function angle(row, columns, unit, what) {
+    const raw = cell(row, columns, 'SIG', unit);
+    const { value, stated } = parseMeasure(raw ?? '');
+    if (value === null || stated === 'inches' || stated === 'millimeters') {
+        throw new VendorResponseError(what, `publishes no point angle — its cell is ${JSON.stringify(raw ?? '')}`);
+    }
+    return value;
+}
+/** The vendor's own coating string, `''` where neither spelling carries one. */
+function coating(row) {
+    for (const column of COATING_COLUMNS) {
+        const value = row[column];
+        if (value !== undefined && value !== '')
+            return value;
+    }
+    return '';
+}
+/** The cutting material, refused rather than guessed when it is a new word. */
+function substrate(row, what) {
+    const stated = row[SUBSTRATE_COLUMN] ?? '';
+    const mapped = SUBSTRATES[stated];
+    if (mapped === undefined) {
+        throw new VendorResponseError(what, `cutting material ${JSON.stringify(stated)} is not one of ` +
+            `${Object.keys(SUBSTRATES).sort().join(', ')} — add it to SUBSTRATES`);
+    }
+    return mapped;
+}
+/**
+ * Whether the part takes coolant through it, in whichever word its category
+ * uses.
+ *
+ * **A word the category's vocabulary does not have refuses the row**, because
+ * that is EMUGE's own closed facet having changed under this package, and
+ * guessing what a new value means is how a scraper becomes a place tool data is
+ * authored by hand.
+ *
+ * **A category whose column nobody filled warns and answers `false`**, which is
+ * a different thing: the vendor rated this part for nothing rather than for
+ * something new. 159 milling variants are in that position — see
+ * {@link COOLANT_COLUMNS}. `false` is not a claim that the tool has no through
+ * hole so much as the absence of the vendor's claim that it has one, and it is
+ * the only answer available: `ToolRecord.coolantThrough` is a boolean with no
+ * third state, and `true` would be the fabrication.
+ */
+function coolantThrough(row, what, warn) {
+    for (const [column, vocabulary] of Object.entries(COOLANT_COLUMNS)) {
+        const stated = row[column];
+        if (stated === undefined || stated === '')
+            continue;
+        const value = vocabulary[stated];
+        if (value === undefined) {
+            throw new VendorResponseError(what, `${column} is ${JSON.stringify(stated)}, which is not one of ` +
+                `${Object.keys(vocabulary).sort().join(', ')} — add it to COOLANT_COLUMNS`);
+        }
+        return value;
+    }
+    warn(`  WARNING: ${what}: none of ${Object.keys(COOLANT_COLUMNS).join(', ')} is ` +
+        `filled — the vendor's index rates it for no coolant supply, recorded as false`);
+    return false;
+}
+/**
+ * The workpiece-material groups, and how they were arrived at.
+ *
+ * Three states, and the column carries two of them: a cell the vendor's index
+ * filled, and an empty one meaning it rates this part for nothing. The third —
+ * **we have no evidence** — is the row whose per-part detail request answered
+ * nothing, which `scrape.ts` warns about and leaves the key off entirely.
+ *
+ * That last distinction lives only in the in-memory scrape: `node/csv.parseCsv`
+ * fills `''` under every header column, so a CSV round-trip flattens an absent
+ * key into an empty one. Which is why the missing detail is warned about when
+ * it happens rather than inferred from the file afterwards.
+ *
+ * Reordered onto {@link ISO_MATERIAL_GROUPS} rather than passed through in the
+ * vendor's order — a consumer that renders a facet from one order and a tool's
+ * own list from another has no way to notice the two disagree.
+ */
+function materialGroups(row) {
+    const cellText = row[APPLICATION_MATERIALS_COLUMN];
+    if (cellText === undefined) {
+        return { materialGroups: null, materialGroupsSource: UNSPECIFIED };
+    }
+    const stated = new Set(cellText.split(/\s+/).filter((code) => code !== ''));
+    return {
+        materialGroups: ISO_MATERIAL_GROUPS.filter((group) => stated.has(group)),
+        materialGroupsSource: 'vendor-stated',
+    };
+}
+/** Everything a record of any kind here shares. */
+function common(row, family, what, warn) {
+    return {
+        brand: familyBrand(family),
+        vendor: BRANDS[familyBrand(family)].vendor,
+        materialNumber: what,
+        catalogNumber: row[CATALOG_NUMBER_COLUMN] ?? '',
+        description: row[DESCRIPTION_COLUMN] ?? '',
+        substrate: substrate(row, what),
+        coating: coating(row),
+        coolantThrough: coolantThrough(row, what, warn),
+        ...materialGroups(row),
+    };
+}
+/** The material number a record is minted from, refusing a row without one. */
+function partNumber(row, family) {
+    const what = row[MATERIAL_NUMBER_COLUMN] ?? '';
+    if (what === '') {
+        throw new VendorResponseError(family.id, `has a row with no ${MATERIAL_NUMBER_COLUMN}`);
+    }
+    return what;
+}
+/**
+ * A solid end mill, in the family's declared unit.
+ *
+ * The two shoulder fields fall back the way every end mill mapper here does: a
+ * family with no neck column is a plain tool whose usable length below the
+ * shank is its flute length and whose shoulder is its cutting diameter. EMUGE
+ * publishes `neck length l₃` and `neck diameter Ød₃` on the necked lines and
+ * neither on the plain ones, in the same family, so the fallback is per row
+ * rather than per family.
+ *
+ * A missing `radius r₁` is a square end and 0 is the right answer — the reason
+ * `RE` is optional on the end mill contract.
+ */
+export function endmillRecord(row, family, columns, options = {}) {
+    const warn = options.warn ?? consoleWarn;
+    const opts = { warn };
+    const unit = fact(family, 'unit', family.unit);
+    const what = partNumber(row, family);
+    const dc = required(row, columns, 'DC', unit, what, opts);
+    const fluteLength = required(row, columns, 'LCF', unit, what, opts);
+    const geometry = {
+        DC: dc,
+        RE: optional(row, columns, 'RE', unit, what, opts) ?? 0,
+        SFDM: required(row, columns, 'SFDM', unit, what, opts),
+        OAL: required(row, columns, 'OAL', unit, what, opts),
+        LCF: fluteLength,
+        'shoulder-length': optional(row, columns, 'shoulder-length', unit, what, opts) ?? fluteLength,
+        'shoulder-diameter': optional(row, columns, 'shoulder-diameter', unit, what, opts) ?? dc,
+    };
+    const raw = cell(row, columns, 'NOF', unit);
+    const nof = raw === undefined ? null : wholeCount(raw);
+    if (nof === NO_FLUTE_COUNT) {
+        warn(`  WARNING: ${what}: the vendor's flute count is ${NO_FLUTE_COUNT} — omitted`);
+    }
+    else if (nof !== null) {
+        geometry.NOF = nof;
+    }
+    return toolRecord({ ...common(row, family, what, warn), kind: 'endmill', unit, geometry });
+}
+/**
+ * A twist drill, in millimetres — the only system EMUGE publishes its drill
+ * lengths in.
+ *
+ * `SIG` is a **mapped column**, which no other drill family in this package
+ * manages: the per-part detail record states the point angle outright, so
+ * nothing here is derived from a point length or assumed from a product line.
+ * `NOF` is the one thing that is a fact, and `nonFerrous` with it — neither has
+ * a default anywhere, by design.
+ */
+export function drillRecord(row, family, columns, options = {}) {
+    const warn = options.warn ?? consoleWarn;
+    const opts = { warn };
+    const unit = fact(family, 'unit', family.unit);
+    const what = partNumber(row, family);
+    return toolRecord({
+        ...common(row, family, what, warn),
+        kind: 'drill',
+        unit,
+        nonFerrous: fact(family, 'nonFerrous', family.nonFerrous),
+        geometry: {
+            DC: required(row, columns, 'DC', unit, what, opts),
+            SFDM: required(row, columns, 'SFDM', unit, what, opts),
+            OAL: required(row, columns, 'OAL', unit, what, opts),
+            LCF: required(row, columns, 'LCF', unit, what, opts),
+            NOF: fact(family, 'flutes', family.flutes),
+            SIG: angle(row, columns, unit, what),
+        },
+    });
+}
+/**
+ * A tap, in millimetres — including an inch-thread one.
+ *
+ * That is what the vendor published rather than a conversion this package made:
+ * a `#4-40 UNC` tap's major diameter is stated as `2.845 mm` and its shank,
+ * overall length and cutting-edge length are millimetres too. So the family
+ * declares `unit: millimeters` and there is no per-row thread system to read —
+ * the shape Kennametal needs, where one family holds both and `Thread System`
+ * is a column the scrape tags on.
+ *
+ * `DC` is **read, not derived**. Kennametal parses a major diameter out of the
+ * thread designation because its tap tables publish no diameter column; EMUGE
+ * publishes one, and reading the vendor's own number is always the better of
+ * the two. The designation is still on the CSV as `dimensionFeatureValue`, and
+ * `thread symbol` and `threads per inch` beside it.
+ *
+ * `NOF` is absent, and its absence is the vendor's silence — see the module
+ * docstring and `records.RECORD_GEOMETRY`.
+ */
+export function tapRecord(row, family, columns, options = {}) {
+    const warn = options.warn ?? consoleWarn;
+    const opts = { warn };
+    const unit = fact(family, 'unit', family.unit);
+    const what = partNumber(row, family);
+    return toolRecord({
+        ...common(row, family, what, warn),
+        kind: 'tap',
+        unit,
+        geometry: {
+            DC: required(row, columns, 'DC', unit, what, opts),
+            TP: required(row, columns, 'TP', unit, what, opts),
+            SFDM: required(row, columns, 'SFDM', unit, what, opts),
+            OAL: required(row, columns, 'OAL', unit, what, opts),
+            LCF: required(row, columns, 'LCF', unit, what, opts),
+        },
+    });
+}
+export const RECORD_MAPPERS = {
+    drill: drillRecord,
+    tap: tapRecord,
+    endmill: endmillRecord,
+};

package/dist/vendors/emuge/scrape.d.ts

@@ -0,0 +1,227 @@
+/**
+ * EMUGE-FRANKEN's SAP Commerce API -> cutting-tool rows.
+ *
+ * Nothing here parses HTML, because there is none to parse: the storefront is
+ * SAP Commerce (Hybris) behind a Vue front end, and a category page
+ * server-renders a `<title>`, a base64 CMS blob and an empty
+ * `<category-detail-page>` element. The data comes from the JSON API that
+ * element's component reads. `docs/EMUGE_FRANKEN_COMMERCE_API.md` records how
+ * the endpoint was found, what it answers with, and what was tried first.
+ *
+ * ```
+ * GET {BASE}/search/products?query=<facet query>&currentPage=&pageSize=
+ *     &searchQueryContext=KLAMMER_GROUPING   -- grouped products
+ *     &searchQueryContext=VARIANT_SEARCH     -- one group's orderable parts
+ * GET {BASE}/products?productCodes=<up to 30>&fields=FULL
+ * ```
+ *
+ * ## Three calls, because the fields are in three places
+ *
+ * A *klammer* product is EMUGE's grouping — `H301025`, "Solid Carbide End Mill
+ * TOP-Cut VAR" — and its variants are the parts somebody orders. Neither one
+ * alone carries a record:
+ *
+ * - the **grouped listing** states the product line, the category and the
+ *   version, and no dimensions;
+ * - the **variant listing** states the material number, the catalog number and
+ *   every dimension, under `mainDrawing.technicalDetails`;
+ * - the **per-part detail** states what appears in neither — the end mill's
+ *   flute count, the drill's point angle, the tap's thread symbol and pitch,
+ *   and `applicationMaterials`, which is the vendor's own ISO 513 index.
+ *
+ * The third is the reason a scrape is not two calls. It is batched 30 codes at
+ * a time, so it costs one request per 30 parts rather than one per part.
+ *
+ * ## Two buckets of property, and only one of them gets a unit suffix
+ *
+ * `mainDrawing.technicalDetails` is the dimension table — that is the bucket
+ * whose columns carry `_mm`/`_in` from the family's declared unit. Everything
+ * in the flat `technicalDetails` keeps its bare label, which is what puts a
+ * tap's `pitch [mm]` in a column called `pitch`: `records.DIMENSIONAL_COLUMNS`
+ * excludes `TP` from unit pairing, so the core reads that column by its bare
+ * label, and a suffix here would name a column nothing scraped.
+ *
+ * Values are written **verbatim** — `1 1/2 "`, `3 mm`, `140 deg` — the call
+ * `vendors/harvey/scrape.ts` makes and for the same reason: the CSV is the
+ * receipt, and EMUGE's own fractional inches and stated units are part of what
+ * it published. `records.ts` is where a cell becomes a number, through
+ * `value.ts`.
+ *
+ * ## What the vendor gets wrong
+ *
+ * Warned about, never corrected — two disagreeing vendor cells cannot say which
+ * one is wrong, and a scraper that picks becomes a place tool data is authored
+ * by hand.
+ *
+ * - **`number of flutes Z` is `999` on 64 end mill variants** (2026-09-01), a
+ *   sentinel rather than a count. `records.ts` refuses it; a CSV cell keeps it,
+ *   because that is what the vendor published.
+ * - **`name` comes back German on the US English storefront** — "TOP-Cut VAR
+ *   HM-Schaftfräser / lang Typ N ALCR" with `lang=en&country=US`. Recorded as
+ *   sent.
+ * - **The same property is spelled two ways across categories**: `coating` on
+ *   an end mill and `Coating` on a tap, `Cutting material` on both. Two
+ *   columns, because relabelling one onto the other would be this adapter
+ *   deciding what the vendor meant.
+ * - **The same measurement is published under two unit tags** — the drill
+ *   detail record carries `nominal diameter d₁ [in]` beside the millimetre one.
+ *   `value.bareLabel` strips the tag, so both want one column; {@link put} lets
+ *   the later one win and says so, rather than dropping a number out of the
+ *   receipt in silence.
+ */
+import { type UnitSystem } from '../../conventions.js';
+import type { Fetcher } from '../../fetch.js';
+import { type ScrapeResult, type ScrapedRow, type Warn } from '../../scrape.js';
+/**
+ * The `emugefrankenUSA` base site, which is the US storefront.
+ *
+ * Both halves are stated in `window.appConfig` on every page of the site
+ * (`apiNodeUrl` and `basesiteId`), and the `/api/v2/{basesiteId}` shape is what
+ * the front end's own client builds.
+ */
+export declare const BASE = "https://api.emuge-franken-group.com/api/v2/emugefrankenUSA";
+/** Answered in full at 500; the largest group seen holds 214 variants. */
+export declare const SEARCH_PAGE_SIZE = 500;
+/**
+ * Codes per `productCodes=` request.
+ *
+ * Thirty is what the storefront's own product-comparison call uses, and it is
+ * answered whole — 30 codes in, 30 records out. Raising it is a request-volume
+ * decision about somebody else's server, so it stays where the vendor put it.
+ */
+export declare const DETAIL_BATCH = 30;
+/** The CSV columns this adapter names, as against the vendor's own labels. */
+export declare const MATERIAL_NUMBER_COLUMN = "Material Number";
+export declare const CATALOG_NUMBER_COLUMN = "ISO Catalog Number";
+export declare const GROUP_COLUMN = "klammerProductCode";
+export declare const DIMENSION_FEATURE_COLUMN = "dimensionFeatureValue";
+export declare const NAME_COLUMN = "name";
+export declare const APPLICATION_MATERIALS_COLUMN = "applicationMaterials";
+/**
+ * One family's scrape target: a category, optionally narrowed by one facet.
+ *
+ * The facet is how the two end mill families are split — EMUGE indexes every
+ * milling variant under `AMM_EINHS` (`AMM_EINHS_Z` inch, `AMM_EINHS_M` metric)
+ * — so a family declares one unit and scrapes only the parts published in it.
+ */
+export interface EmugeTarget {
+    /** The vendor's category code: `FF01` end mills, `FB01` drills, `FG01` taps. */
+    readonly category: string;
+    /** A facet code and value, both the vendor's own. */
+    readonly facet?: {
+        readonly code: string;
+        readonly value: string;
+    };
+}
+/** What a scrape accepts. */
+export interface EmugeOptions {
+    /** The unit system the family declares — decides the dimensional suffix. */
+    readonly unit: UnitSystem;
+    readonly warn?: Warn;
+    /** Milliseconds between requests. Zero in tests; the shared delay otherwise. */
+    readonly delayMs?: number;
+}
+/** One `{ property, value }` pair, as the API writes them. */
+interface Detail {
+    property?: string;
+    value?: string;
+}
+/** A grouped product, as `KLAMMER_GROUPING` answers. */
+interface GroupedProduct {
+    code?: string;
+    productListInfo?: string;
+    /** How many orderable parts the vendor says this group has. */
+    numberOfMaterials?: number;
+    technicalDetails?: Detail[];
+}
+/** One orderable part, as `VARIANT_SEARCH` answers. */
+interface VariantProduct {
+    code?: string;
+    articleCode?: string;
+    name?: string;
+    dimensionFeatureValue?: string;
+    /**
+     * True on the grouped product itself, which the variant listing returns
+     * alongside its variants — see {@link fetchGroupVariants}.
+     */
+    klammerProduct?: boolean;
+    mainDrawing?: {
+        technicalDetails?: Detail[];
+    };
+}
+/** One part's full record, as `productCodes=&fields=FULL` answers. */
+interface ProductDetail {
+    code?: string;
+    technicalDetails?: Detail[];
+    applicationMaterials?: {
+        code?: string;
+    }[];
+}
+/** The facet query for a target's grouped products. */
+export declare function groupQuery(target: EmugeTarget): string;
+/** The facet query for one group's variants. */
+export declare function variantQuery(klammerCode: string): string;
+/**
+ * One `/search/products` URL.
+ *
+ * `lang` and `country` are the front end's own defaults for this base site and
+ * are what make the property labels English; without them the API answers in
+ * German.
+ */
+export declare function searchUrl(query: string, context: string, page: number, sort?: string): string;
+/** The batched per-part detail URL. */
+export declare function detailUrl(codes: readonly string[]): string;
+/** Every grouped product under one target. */
+export declare function fetchGroups(fetcher: Fetcher, target: EmugeTarget, delayMs?: number): Promise<GroupedProduct[]>;
+/**
+ * Every orderable part in one group.
+ *
+ * `sort=prod-detail-variant` is the vendor's own variant order — the sequence
+ * its product page lists sizes in — so a re-scrape diffs against the last one
+ * rather than against a relevance ranking that moved.
+ *
+ * **The grouped product comes back inside its own variant listing**, last, and
+ * it is not a part: `klammerProduct` is true on it, it carries the base article
+ * code with no size suffix (`TA219744` against the variants' `TA219744.0300`),
+ * and it has no `mainDrawing.technicalDetails` at all. `KLAMMER_GROUPING`
+ * queries filter it out with `:klammerProduct:false` and `VARIANT_SEARCH` ones
+ * do not, so the flag is read here instead — the vendor's own discriminator
+ * rather than a guess from the missing dimensions.
+ *
+ * It cost exactly one bogus row per group, which is the kind of thing only a
+ * real scrape finds: the first drill run wrote 2,687 rows where the family
+ * declares 2,670, and `node/receipts.checkRows` is what said so (JG 2026-09-01).
+ */
+export declare function fetchGroupVariants(fetcher: Fetcher, klammerCode: string, delayMs?: number): Promise<VariantProduct[]>;
+/**
+ * The full record for each of `codes`, by code, in batches of
+ * {@link DETAIL_BATCH}.
+ *
+ * A code the vendor answers nothing for is warned about and left out of the
+ * map; the row is still written, without the fields only this call carries. A
+ * dropped row would lose a part somebody can order over a field that is
+ * missing rather than wrong.
+ */
+export declare function fetchDetails(fetcher: Fetcher, codes: readonly string[], delayMs?: number, warn?: Warn): Promise<Map<string, ProductDetail>>;
+/**
+ * One orderable part as a row.
+ *
+ * The three property sources are written in the order they may override each
+ * other: the group's, then the part's own, then its dimension table. Group and
+ * part overlap — both state the coating and the cutting material — and the
+ * part's is the more specific of the two.
+ */
+export declare function variantRow(group: GroupedProduct, variant: VariantProduct, detail: ProductDetail | undefined, unit: UnitSystem, warn?: Warn): ScrapedRow;
+/**
+ * One category — optionally one facet of it — as rows, one per orderable part.
+ *
+ * Paced between every request it makes, so unlike the Harvey command there is
+ * nothing for a caller to pace between families.
+ *
+ * A target that yields no rows is refused rather than returned empty: a facet
+ * value the vendor retired answers exactly like a category that was
+ * discontinued, and only one of those is a scrape this package should write a
+ * receipt for.
+ */
+export declare function scrapeCategory(fetcher: Fetcher, target: EmugeTarget, options: EmugeOptions): Promise<ScrapeResult>;
+export {};