@deerdesign/deertools 1.2.35 → 1.3.0

package/src/estimate/client.js

@@ -0,0 +1,1787 @@
+'use strict';
+const { ensureDevToken } = require('./auth');
+const domain = require('./domain');
+
+const DEV_API_BASE = 'https://dev.deergroup.pl/api';
+const DEFAULT_ORG_ID = '1';
+const ESTIMATE_CATALOG_ID = '5';
+
+/**
+ * Wykonuje autoryzowane zapytanie HTTP do https://dev.deergroup.pl/api.
+ */
+async function callDevApi(method, path, { query = {}, body = undefined, orgId = DEFAULT_ORG_ID } = {}) {
+  const token = ensureDevToken();
+  const url = new URL(DEV_API_BASE + path);
+
+  for (const [k, v] of Object.entries(query)) {
+    if (v !== undefined && v !== null && v !== '') {
+      url.searchParams.set(k, String(v));
+    }
+  }
+
+  const headers = {
+    'Authorization': `Bearer ${token}`,
+    'x-org-id': String(orgId),
+    'Accept': 'application/json'
+  };
+
+  let payload;
+  if (body !== undefined) {
+    headers['Content-Type'] = 'application/json';
+    payload = JSON.stringify(body);
+  }
+
+  const res = await fetch(url.toString(), { method, headers, body: payload });
+  const text = await res.text();
+  let json = null;
+  try { json = JSON.parse(text); } catch (_) {}
+
+  if (!res.ok) {
+    const errorMsg = (json && (json.message || json.error)) || text;
+    throw new Error(`DeerTools Dev API (${res.status}): ${errorMsg}`);
+  }
+
+  return json !== null ? json : text;
+}
+
+/**
+ * Pobiera listę projektów z dev.deergroup.pl/api/projects.
+ */
+async function listProjects(params = {}) {
+  const {
+    page = 1,
+    pageSize = 20,
+    search,
+    projectType,
+    propertyStatus,
+    externalId,
+    sort = 'createdOn:desc',
+    orgId = DEFAULT_ORG_ID
+  } = params;
+
+  return await callDevApi('GET', '/projects', {
+    query: { page, pageSize, search, projectType, propertyStatus, externalId, sort },
+    orgId
+  });
+}
+
+/**
+ * Buduje zwięzłe podsumowanie rekordu dokumentu (bez kilkumegabajtowego templatesSnapshot).
+ */
+function summarizeDocumentRecord(doc) {
+  const dj = doc.dataJson || {};
+  const items = dj.estimatePanelData?.estimateItems || [];
+  const activeItems = items.filter(x => !x.cancelled);
+  const reducedItems = items.filter(x => x.cancelled);
+  const templatePlaceholders = activeItems.filter(x => x.isTemplate && x.type === 'PRODUCT');
+  const rooms = dj.roomsAndMeasurements?.roomAnalyses?.[0]?.rooms || [];
+  const rawPkg = dj.finishStandard?.selectedPackageName || dj.finishStandard?.selectedPackageId || dj.estimateBindings?.packageId;
+  const resolvedPkg = rawPkg ? domain.resolvePackageConfig(rawPkg) : null;
+
+  return {
+    id: doc.id,
+    documentNumber: doc.documentNumber,
+    name: doc.name,
+    type: doc.type,
+    state: doc.state,
+    projectId: doc.projectId,
+    addedAt: doc.addedAt || doc.createdAt || null,
+    updatedAt: doc.updatedAt || null,
+    finishStandard: {
+      selectedPackageId: dj.finishStandard?.selectedPackageId || resolvedPkg?.selectedPackageId || null,
+      selectedPackageName: dj.finishStandard?.selectedPackageName || resolvedPkg?.selectedPackageName || null,
+      unitPriceM2: dj.finishStandard?.unitPriceM2 || resolvedPkg?.unitPriceM2 || null
+    },
+    roomsSummary: {
+      totalArea: dj.roomsAndMeasurements?.roomAnalyses?.[0]?.totalArea || domain.round2(rooms.reduce((s, r) => s + (Number(r.area) || 0), 0)),
+      roomsCount: rooms.length,
+      rooms: rooms.map(r => ({ id: r.id, name: r.name, area: r.area, perimeter: r.perimeter, height: r.height }))
+    },
+    itemsSummary: {
+      totalRows: items.length,
+      activeRows: activeItems.length,
+      reducedRows: reducedItems.length,
+      unfilledTemplateProductSlots: templatePlaceholders.length,
+      totalPrices: dj.estimatePanelData?.totalPrices || domain.recalculateDocumentTotals(dj)
+    }
+  };
+}
+
+/**
+ * Pobiera szczegóły pojedynczego projektu wraz z powiązanymi dokumentami (w formie zwięzłych podsumowań).
+ */
+async function getProject(projectId, { orgId = DEFAULT_ORG_ID } = {}) {
+  if (!projectId) throw new Error('Wymagany jest parametr projectId.');
+
+  const project = await callDevApi('GET', `/projects/${projectId}`, { orgId });
+  const documents = await callDevApi('GET', '/documents', {
+    query: { projectId, pageSize: 100 },
+    orgId
+  });
+
+  const rawDocs = documents.items || project.documents || [];
+  const compactDocs = rawDocs.map(summarizeDocumentRecord);
+
+  return {
+    ...project,
+    documents: compactDocs
+  };
+}
+
+/**
+ * Pobiera listę dokumentów (kosztorysów, aneksów, umów) w formie zwięzłych podsumowań bez pełnego dataJson.
+ */
+async function listDocuments(params = {}) {
+  const {
+    page = 1,
+    pageSize = 20,
+    search,
+    projectId,
+    sort = 'addedAt:desc',
+    orgId = DEFAULT_ORG_ID
+  } = params;
+
+  const res = await callDevApi('GET', '/documents', {
+    query: { page, pageSize, search, projectId, sort },
+    orgId
+  });
+
+  if (Array.isArray(res?.items)) {
+    return {
+      ...res,
+      items: res.items.map(summarizeDocumentRecord)
+    };
+  }
+  return res;
+}
+
+/**
+ * Pobiera pełny dokument kosztorysu wraz ze strukturą dataJson i podsumowaniem.
+ */
+async function getDocument(documentId, { summaryOnly = false, orgId = DEFAULT_ORG_ID } = {}) {
+  if (!documentId) throw new Error('Wymagany jest parametr documentId.');
+  const doc = await callDevApi('GET', `/documents/${documentId}`, { orgId });
+
+  if (!summaryOnly) return doc;
+  return summarizeDocumentRecord(doc);
+}
+
+/**
+ * Bezpośrednia aktualizacja dokumentu PATCH /documents/:id.
+ */
+async function patchDocument(documentId, updateDto, { orgId = DEFAULT_ORG_ID } = {}) {
+  if (!documentId) throw new Error('Wymagany jest parametr documentId.');
+  return await callDevApi('PATCH', `/documents/${documentId}`, {
+    body: updateDto,
+    orgId
+  });
+}
+
+/**
+ * Wyszukiwanie produktów i usług w Katalogu Kosztorysu (Catalog 5 na dev.deergroup.pl/api/catalogs/5/items).
+ * Obsługuje zarówno zablokowane filtry pakietowe/slotowe (lockedFilters z wiersza kosztorysu),
+ * jak i odblokowane wyszukiwanie w całym katalogu z automatycznym oznaczeniem dopłat i limitów.
+ */
+async function searchEstimateCatalog(params = {}) {
+  const {
+    search,
+    type,
+    categoryPathPrefix,
+    packageFilter,
+    priceMin,
+    priceMax,
+    unit,
+    documentId,
+    slotRowId,
+    unlockFilters = false,
+    includeRelated = true,
+    page = 1,
+    pageSize = 20,
+    orgId = DEFAULT_ORG_ID
+  } = params;
+
+  let effectiveCategoryPath = categoryPathPrefix;
+  let effectivePackage = packageFilter && packageFilter !== 'all' ? String(packageFilter).toLowerCase() : undefined;
+  let effectivePriceMin = priceMin;
+  let effectivePriceMax = priceMax;
+  let effectiveUnit = unit ? domain.normalizePricingUnit(unit) : undefined;
+  let markupPct = 57;
+  let slotContext = null;
+
+  // Jeśli podano documentId + slotRowId, odczytujemy ograniczenia bezpośrednio ze slotu w kosztorysie
+  if (documentId && slotRowId) {
+    const doc = await getDocument(documentId, { orgId });
+    const dj = doc.dataJson || {};
+    const pkgCfg = domain.resolvePackageConfig(dj.finishStandard?.selectedPackageId || dj.finishStandard?.selectedPackageName || 'SMART');
+    markupPct = pkgCfg.markupPct;
+    const items = dj.estimatePanelData?.estimateItems || [];
+    const row = items.find(it =>
+      String(it.id) === String(slotRowId) ||
+      String(it.binding?.slotKey) === String(slotRowId) ||
+      String(it.templateMeta?.slotName) === String(slotRowId) ||
+      domain.norm(it.templateMeta?.slotName).includes(domain.norm(slotRowId)) ||
+      domain.norm(it.name).includes(domain.norm(slotRowId))
+    );
+    if (!row) {
+      throw new Error(`Nie znaleziono wiersza/slotu "${slotRowId}" w kosztorysie ${documentId}.`);
+    }
+    const tm = row.templateMeta || {};
+    slotContext = {
+      rowId: row.id,
+      name: row.name,
+      group: row.group,
+      unit: row.unit,
+      quantity: row.quantity,
+      categoryPath: tm.categoryPath || row.categoryPath,
+      allowedCategories: tm.allowedCategories || [],
+      priceMin: tm.priceMin ?? null,
+      priceMax: tm.priceMax ?? null,
+      priceAvg: tm.priceAvg ?? null,
+      packageKey: pkgCfg.packageKey
+    };
+
+    if (!unlockFilters) {
+      if (!effectiveCategoryPath) effectiveCategoryPath = slotContext.categoryPath;
+      if (!effectivePackage) effectivePackage = slotContext.packageKey;
+      if (effectivePriceMin === undefined && slotContext.priceMin != null) effectivePriceMin = slotContext.priceMin;
+      if (effectivePriceMax === undefined && slotContext.priceMax != null) effectivePriceMax = slotContext.priceMax;
+      if (!effectiveUnit && row.unit) effectiveUnit = domain.normalizePricingUnit(row.unit);
+    } else {
+      // Przy odblokowanych filtrach zachowujemy opcjonalnie tylko kategorię, jeśli użytkownik jej nie zmienił i nie podał frazy
+      if (effectiveCategoryPath === undefined && !search) {
+        effectiveCategoryPath = slotContext.categoryPath;
+      }
+    }
+  } else if (effectivePackage) {
+    markupPct = domain.resolvePackageConfig(effectivePackage).markupPct;
+  }
+
+  const query = {
+    page,
+    pageSize,
+    search: search ? String(search).trim() : undefined,
+    type: type ? String(type).toLowerCase() : undefined,
+    categoryPathPrefix: effectiveCategoryPath || undefined,
+    package: unlockFilters ? (packageFilter && packageFilter !== 'all' ? String(packageFilter).toLowerCase() : undefined) : effectivePackage,
+    purchasePricePerPricingUnitFrom: !unlockFilters && effectivePriceMin != null ? Number(effectivePriceMin) : undefined,
+    purchasePricePerPricingUnitTo: !unlockFilters && effectivePriceMax != null ? Number(effectivePriceMax) : undefined,
+    pricingUnit: !unlockFilters && effectiveUnit ? effectiveUnit : undefined,
+    includeRelated: includeRelated ? 'true' : undefined
+  };
+
+  let res = await callDevApi('GET', `/catalogs/${ESTIMATE_CATALOG_ID}/items`, { query, orgId });
+  let items = res.items || res.data || [];
+
+  // Fallback: jeśli filtr pricingUnit na serwerze odfiltrował pozycje z purchasePrice bez pricingUnit, powtórz bez pricingUnit
+  if (items.length === 0 && query.pricingUnit && (query.purchasePricePerPricingUnitTo != null || query.purchasePricePerPricingUnitFrom != null)) {
+    const fallbackQuery = {
+      ...query,
+      pricingUnit: undefined,
+      purchasePriceTo: query.purchasePricePerPricingUnitTo,
+      purchasePricePerPricingUnitTo: undefined,
+      purchasePricePerPricingUnitFrom: undefined
+    };
+    const resFallback = await callDevApi('GET', `/catalogs/${ESTIMATE_CATALOG_ID}/items`, { query: fallbackQuery, orgId });
+    if ((resFallback.items || []).length > 0) {
+      res = resFallback;
+      items = resFallback.items || [];
+    }
+  }
+
+  const limitMax = slotContext?.priceMax ?? (priceMax != null ? Number(priceMax) : null);
+  const targetPkg = slotContext?.packageKey ?? effectivePackage;
+
+  const enrichedItems = items.map(item => {
+    const sale = domain.computeSalePrice(item, markupPct);
+    const pkgInfo = domain.readPackaging(item);
+    const unitPurchase = Number(item.purchasePricePerPricingUnit ?? item.purchasePrice ?? 0);
+    const withinPriceLimit = limitMax == null ? true : (unitPurchase <= Number(limitMax) + 0.01);
+    const inPackageTier = !targetPkg || !item.package || String(item.package).toLowerCase() === String(targetPkg).toLowerCase();
+    const inPackageScope = withinPriceLimit && inPackageTier;
+
+    return {
+      id: item.id,
+      sku: item.sku,
+      name: item.name,
+      type: item.type,
+      package: item.package,
+      unit: item.unit,
+      pricingUnit: item.pricingUnit,
+      pricingUnitsPerPackage: item.pricingUnitsPerPackage,
+      purchasePrice: item.purchasePrice,
+      purchasePricePerPricingUnit: item.purchasePricePerPricingUnit,
+      salePriceGrossCatalog: item.salePrice,
+      computedUnitPriceNet: sale.unitPriceNet,
+      computedUnitPriceGross: sale.unitPriceGross,
+      vatRate: sale.vatRate,
+      categoryPath: item.attributes?.categoryPath,
+      manufacturerName: item.attributes?.manufacturerName,
+      ean: item.attributes?.ean,
+      imageUrl: item.attributes?.images?.[0] || null,
+      packaging: pkgInfo,
+      inPackageScope,
+      withinPriceLimit,
+      slotPriceMaxNet: limitMax,
+      requiresReductionAndReplacement: !inPackageScope,
+      relatedServices: (item.relatedItems || []).filter(r => r.type === 'service').map(r => ({
+        id: r.id,
+        sku: r.sku,
+        name: r.name,
+        unit: r.unit,
+        purchasePrice: r.purchasePrice,
+        salePrice: r.salePrice
+      }))
+    };
+  });
+
+  return {
+    total: res.total ?? enrichedItems.length,
+    page: res.page ?? page,
+    pageSize: res.pageSize ?? pageSize,
+    appliedFilters: {
+      unlockFilters,
+      search: query.search || null,
+      categoryPathPrefix: query.categoryPathPrefix || null,
+      package: query.package || null,
+      priceMinNet: query.purchasePricePerPricingUnitFrom ?? null,
+      priceMaxNet: query.purchasePricePerPricingUnitTo ?? query.purchasePriceTo ?? null,
+      pricingUnit: query.pricingUnit || null
+    },
+    slotContext,
+    items: enrichedItems
+  };
+}
+
+/**
+ * Pobiera pojedynczą pozycję z Katalogu 5 po ID lub SKU wraz z powiązanymi usługami (relatedItems).
+ */
+async function getEstimateCatalogItem(itemIdOrSku, { markupPct = 57, orgId = DEFAULT_ORG_ID } = {}) {
+  if (!itemIdOrSku) throw new Error('Wymagany jest parametr itemIdOrSku.');
+  const raw = String(itemIdOrSku).trim();
+
+  let item = null;
+  if (/^\d+$/.test(raw)) {
+    try {
+      item = await callDevApi('GET', `/catalogs/${ESTIMATE_CATALOG_ID}/items/${raw}`, {
+        query: { includeRelated: 'true' },
+        orgId
+      });
+    } catch (_) {}
+  }
+
+  if (!item) {
+    const searchRes = await callDevApi('GET', `/catalogs/${ESTIMATE_CATALOG_ID}/items`, {
+      query: { search: raw, includeRelated: 'true', page: 1, pageSize: 10 },
+      orgId
+    });
+    const list = searchRes.items || [];
+    item = list.find(x => String(x.sku).toLowerCase() === raw.toLowerCase() || String(x.id) === raw) || list[0];
+  }
+
+  if (!item) {
+    throw new Error(`Nie znaleziono pozycji katalogowej "${raw}" w Katalogu 5.`);
+  }
+
+  return {
+    ...item,
+    computedSalePrice: domain.computeSalePrice(item, markupPct),
+    computedPackaging: domain.readPackaging(item)
+  };
+}
+
+/**
+ * Zwraca zdeduplikowane podpowiedzi usług i slotów produktowych ze wzorca pakietowego (templatesSnapshot).
+ */
+async function listTemplateSuggestions(params = {}) {
+  const { documentId, package: pkgInput = 'SMART', kind, search, orgId = DEFAULT_ORG_ID } = params;
+  let templates = null;
+  let selectedPkgConfig = domain.resolvePackageConfig(pkgInput);
+
+  if (documentId) {
+    const doc = await getDocument(documentId, { orgId });
+    templates = doc.dataJson?.templatesSnapshot;
+    if (!params.package && doc.dataJson?.finishStandard?.selectedPackageId) {
+      selectedPkgConfig = domain.resolvePackageConfig(doc.dataJson.finishStandard.selectedPackageId);
+    }
+  }
+  if (!templates || !Array.isArray(templates.packages)) {
+    templates = domain.getDefaultTemplatesSnapshot();
+  }
+
+  const pkg = templates.packages.find(p => p.id === selectedPkgConfig.packageUuid || domain.norm(p.key) === domain.norm(selectedPkgConfig.key)) || templates.packages[0];
+  if (!pkg) return { package: selectedPkgConfig.key, count: 0, suggestions: [] };
+
+  const acc = new Map();
+  const pushRoom = (entry, roomName) => {
+    entry.usageCount += 1;
+    if (roomName && !entry.rooms.includes(roomName)) entry.rooms.push(roomName);
+  };
+
+  const walkSlot = (node, roomName) => {
+    for (const s of (node.services || [])) {
+      const sku = String(s.skuSnapshot || '').trim();
+      const name = String(s.nameSnapshot || sku).trim();
+      const key = `service:${(sku || s.catalogItemId || name).toLowerCase()}`;
+      if (!acc.has(key)) {
+        acc.set(key, {
+          id: key,
+          kind: 'service',
+          name,
+          sku: sku || null,
+          catalogItemId: s.catalogItemId || null,
+          unit: s.unitSnapshot || 'm2',
+          purchasePrice: s.purchasePriceSnapshot ?? null,
+          salePriceGross: s.salePriceSnapshot ?? null,
+          usageCount: 0,
+          rooms: []
+        });
+      }
+      pushRoom(acc.get(key), roomName);
+    }
+    for (const p of (node.products || [])) {
+      const catPath = p.category?.categoryPath || '';
+      if (!catPath) continue;
+      const priceMax = p.filter?.priceMax ?? null;
+      const key = `product:${catPath.toLowerCase()}:${priceMax ?? ''}`;
+      if (!acc.has(key)) {
+        const leaf = catPath.split('|').pop() || catPath;
+        acc.set(key, {
+          id: key,
+          kind: 'product',
+          name: leaf,
+          categoryPath: catPath,
+          categoryId: p.category?.categoryId || null,
+          priceMaxNet: priceMax,
+          priceAvgNet: p.filter?.priceAvg ?? null,
+          usageCount: 0,
+          rooms: []
+        });
+      }
+      pushRoom(acc.get(key), roomName);
+    }
+    for (const v of (node.variants || [])) walkSlot(v, roomName);
+  };
+
+  for (const r of (pkg.rooms || [])) {
+    for (const slot of (r.items || [])) {
+      walkSlot(slot, r.name || r.key);
+    }
+  }
+
+  let list = [...acc.values()];
+  if (kind && (kind === 'service' || kind === 'product')) {
+    list = list.filter(x => x.kind === kind);
+  }
+  if (search && String(search).trim()) {
+    const tokens = domain.norm(search).split(/\s+/).filter(Boolean);
+    list = list.filter(x => {
+      const hay = `${domain.norm(x.name)} ${domain.norm(x.sku)} ${domain.norm(x.categoryPath)}`;
+      return tokens.every(t => hay.includes(t));
+    });
+  }
+
+  return {
+    package: pkg.name,
+    packageId: pkg.id,
+    count: list.length,
+    suggestions: list
+  };
+}
+
+/**
+ * Przypisuje produkt lub usługę z Katalogu 5 do slotu/wiersza w kosztorysie (lub dodaje jako nową pozycję).
+ * Obsługuje automatyczne przeliczenie opakowań (packaging), narzutów, usług powiązanych (relatedItems),
+ * wypełnianie wszystkich pustych slotów tej samej kategorii (fillAllMatchingSlots) oraz automatyczną
+ * redukcję pozycji pakietowej i wstawienie zamiennika z dopłatą, gdy produkt przekracza limit pakietu!
+ */
+async function assignCatalogItemToEstimate(documentId, params = {}) {
+  const {
+    catalogItemId,
+    sku,
+    rowId,
+    slotKey,
+    group = 'Inne',
+    quantity,
+    includeRelatedServices = false,
+    fillAllMatchingSlots = false,
+    asReplacement = false,
+    autoReduceOnExceed = true,
+    forceInSlot = false,
+    dryRun = false,
+    orgId = DEFAULT_ORG_ID
+  } = params;
+
+  if (!documentId) throw new Error('Wymagany jest parametr documentId.');
+  const lookupKey = catalogItemId || sku;
+  if (!lookupKey) throw new Error('Wymagany jest parametr catalogItemId lub sku.');
+
+  const doc = await getDocument(documentId, { orgId });
+  const dj = doc.dataJson || {};
+  const pkgCfg = domain.resolvePackageConfig(dj.finishStandard?.selectedPackageId || dj.finishStandard?.selectedPackageName || 'SMART');
+  const catalogItem = await getEstimateCatalogItem(lookupKey, { markupPct: pkgCfg.markupPct, orgId });
+
+  const panelData = dj.estimatePanelData || { estimateItems: [] };
+  let items = [...(panelData.estimateItems || [])];
+
+  // Jeśli nie wskazano rowId ani slotKey, dodajemy nową pozycję do wskazanego pokoju (group)
+  if (!rowId && !slotKey) {
+    const newRow = domain.buildEstimateRowFromCatalogItem(catalogItem, {
+      quantity: quantity != null ? Number(quantity) : 1,
+      group,
+      markupPct: pkgCfg.markupPct,
+      packageLabel: pkgCfg.selectedPackageName
+    });
+    newRow.outOfPackageScope = true;
+    newRow.settlementMode = 'surcharge';
+    items.push(newRow);
+
+    const addedIds = [newRow.id];
+    if (includeRelatedServices && Array.isArray(catalogItem.relatedItems)) {
+      for (const rel of catalogItem.relatedItems.filter(r => r.type === 'service')) {
+        const srvRow = domain.buildEstimateRowFromCatalogItem(rel, {
+          quantity: quantity != null ? Number(quantity) : newRow.quantity,
+          group,
+          markupPct: pkgCfg.markupPct,
+          packageLabel: pkgCfg.selectedPackageName
+        });
+        srvRow.parentId = newRow.id;
+        srvRow.settlementMode = 'surcharge';
+        items.push(srvRow);
+        addedIds.push(srvRow.id);
+      }
+    }
+
+    if (dryRun) {
+      return { dryRun: true, action: 'added_new_row', addedIds, row: newRow };
+    }
+
+    panelData.estimateItems = items;
+    dj.estimatePanelData = panelData;
+    const totals = domain.recalculateDocumentTotals(dj);
+    await patchDocument(documentId, { dataJson: dj }, { orgId });
+    return {
+      success: true,
+      action: 'added_new_row',
+      documentId,
+      addedIds,
+      row: newRow,
+      totalPrices: totals
+    };
+  }
+
+  // Szukamy istniejącego wiersza po rowId lub slotKey
+  const idx = items.findIndex(it =>
+    (rowId && String(it.id) === String(rowId)) ||
+    (slotKey && (String(it.binding?.slotKey) === String(slotKey) || String(it.templateMeta?.slotName) === String(slotKey)))
+  );
+  if (idx < 0) {
+    throw new Error(`Nie znaleziono pozycji o rowId="${rowId || ''}" / slotKey="${slotKey || ''}" w kosztorysie ${documentId}.`);
+  }
+
+  const targetRow = items[idx];
+  const tm = targetRow.templateMeta || {};
+  const rawQty = quantity != null
+    ? Number(quantity)
+    : (targetRow.packaging?.includesReserve ? (targetRow.packaging.rawAreaM2 ?? targetRow.quantity ?? 1) : (targetRow.quantity ?? 1));
+
+  const unitPurchase = Number(catalogItem.purchasePricePerPricingUnit ?? catalogItem.purchasePrice ?? 0);
+  const priceMax = tm.priceMax != null ? Number(tm.priceMax) : null;
+  const exceedsPriceMax = priceMax != null && unitPurchase > priceMax + 0.01;
+  const outOfPackageTier = Boolean(catalogItem.package && pkgCfg.packageKey && String(catalogItem.package).toLowerCase() !== String(pkgCfg.packageKey).toLowerCase());
+  const outOfScope = exceedsPriceMax || outOfPackageTier;
+  const shouldReplaceWithReduction = !forceInSlot && (asReplacement || (autoReduceOnExceed && outOfScope && Boolean(targetRow.binding)));
+
+  let mode = 'filled_in_slot';
+  const affectedIds = [];
+
+  if (shouldReplaceWithReduction) {
+    mode = 'reduced_and_replaced';
+    const replacementId = domain.newUuid();
+    // 1. Oznacz pozycję pakietową jako redukcję (rezygnację)
+    items[idx] = {
+      ...targetRow,
+      cancelled: true,
+      cancelledManual: true,
+      replacedByItemId: replacementId
+    };
+    affectedIds.push(targetRow.id);
+
+    // 2. Zbuduj wiersz zamiennika tuż pod zredukowaną pozycją
+    const replacementRow = domain.buildEstimateRowFromCatalogItem(catalogItem, {
+      quantity: rawQty,
+      group: targetRow.group,
+      rowId: replacementId,
+      expectedUnit: targetRow.unit,
+      reservePct: targetRow.reservePct,
+      markupPct: pkgCfg.markupPct,
+      packageLabel: catalogItem.package || pkgCfg.selectedPackageName
+    });
+    replacementRow.replacesItemId = targetRow.id;
+    replacementRow.outOfPackageScope = true;
+    replacementRow.settlementMode = 'surcharge';
+    replacementRow.dimensions = targetRow.dimensions ? { ...targetRow.dimensions } : undefined;
+    replacementRow.templateMeta = tm
+      ? { ...tm, priceMin: null, priceMax: null, catalogMissing: undefined }
+      : undefined;
+
+    items.splice(idx + 1, 0, replacementRow);
+    affectedIds.push(replacementId);
+  } else {
+    // Wypełnij slot bezpośrednio wybranym produktem
+    const built = domain.buildEstimateRowFromCatalogItem(catalogItem, {
+      quantity: rawQty,
+      group: targetRow.group,
+      rowId: targetRow.id,
+      expectedUnit: targetRow.unit,
+      reservePct: targetRow.reservePct,
+      markupPct: pkgCfg.markupPct,
+      packageLabel: targetRow.package || pkgCfg.selectedPackageName
+    });
+    const cleanMeta = { ...tm };
+    delete cleanMeta.catalogMissing;
+
+    items[idx] = {
+      ...targetRow,
+      ...built,
+      isTemplate: false,
+      cancelled: false,
+      cancelledManual: undefined,
+      binding: targetRow.binding,
+      templateMeta: Object.keys(cleanMeta).length > 0 ? cleanMeta : undefined,
+      outOfPackageScope: exceedsPriceMax ? true : undefined
+    };
+    affectedIds.push(targetRow.id);
+
+    // Opcjonalnie wypełnij wszystkie pozostałe puste sloty tej samej kategorii („Uzupełnij wszystkie”)
+    if (fillAllMatchingSlots && tm.categoryPath) {
+      items = items.map(row => {
+        if (row.id === targetRow.id) return row;
+        if (!row.isTemplate || row.cancelled) return row;
+        if (row.templateMeta?.categoryPath !== tm.categoryPath) return row;
+        const rQty = row.packaging?.includesReserve ? (row.packaging.rawAreaM2 ?? row.quantity ?? 1) : (row.quantity ?? 1);
+        const rBuilt = domain.buildEstimateRowFromCatalogItem(catalogItem, {
+          quantity: rQty,
+          group: row.group,
+          rowId: row.id,
+          expectedUnit: row.unit,
+          reservePct: row.reservePct,
+          markupPct: pkgCfg.markupPct,
+          packageLabel: row.package || pkgCfg.selectedPackageName
+        });
+        const rMeta = { ...(row.templateMeta || {}) };
+        delete rMeta.catalogMissing;
+        affectedIds.push(row.id);
+        return {
+          ...row,
+          ...rBuilt,
+          isTemplate: false,
+          binding: row.binding,
+          templateMeta: rMeta
+        };
+      });
+    }
+  }
+
+  // Opcjonalnie dodaj powiązane usługi montażowe z relatedItems (jeśli nie ma ich jeszcze w tym samym slocie)
+  if (includeRelatedServices && Array.isArray(catalogItem.relatedItems)) {
+    const slotId = targetRow.binding?.slotId;
+    const ocrRoomId = targetRow.binding?.ocrRoomId;
+    const existingSlotSkus = new Set(
+      items
+        .filter(x => x.binding && x.binding.slotId === slotId && x.binding.ocrRoomId === ocrRoomId && x.type === 'SERVICE')
+        .map(x => domain.norm(x.SKU))
+    );
+
+    let insertPos = items.findIndex(x => x.id === affectedIds[affectedIds.length - 1]) + 1;
+    for (const rel of catalogItem.relatedItems.filter(r => r.type === 'service')) {
+      if (rel.sku && existingSlotSkus.has(domain.norm(rel.sku))) continue;
+      const srvRow = domain.buildEstimateRowFromCatalogItem(rel, {
+        quantity: rawQty,
+        group: targetRow.group,
+        markupPct: pkgCfg.markupPct,
+        packageLabel: pkgCfg.selectedPackageName
+      });
+      srvRow.parentId = targetRow.id;
+      items.splice(insertPos, 0, srvRow);
+      insertPos++;
+      affectedIds.push(srvRow.id);
+    }
+  }
+
+  if (dryRun) {
+    return {
+      dryRun: true,
+      mode,
+      affectedIds,
+      exceedsPriceMax,
+      priceMax,
+      unitPurchase
+    };
+  }
+
+  panelData.estimateItems = items;
+  dj.estimatePanelData = panelData;
+  const totals = domain.recalculateDocumentTotals(dj);
+  await patchDocument(documentId, { dataJson: dj }, { orgId });
+
+  return {
+    success: true,
+    documentId,
+    mode,
+    affectedIds,
+    exceedsPriceMax,
+    slotPriceMaxNet: priceMax,
+    productPurchasePriceNet: unitPurchase,
+    totalPrices: totals
+  };
+}
+
+/**
+ * Obsługa redukcji („rezygnacji”) i zamienników na pozycjach kosztorysu:
+ * - action: "reduce" — oznacza pozycję (i opcjonalnie powiązane usługi w tym samym slocie) jako cancelled: true, cancelledManual: true.
+ * - action: "restore" — przywraca pozycję z redukcji (cancelled: false) i usuwa ewentualny zamiennik.
+ * - action: "replace" — redukuje pozycję pakietową i wstawia bezpośrednio pod nią powiązany wiersz zamiennika.
+ * - action: "remove_permanently" — usuwa pozycję i dopisuje jej klucz do estimateBindings.removedBindingKeys.
+ */
+async function reduceOrReplaceItem(documentId, params = {}) {
+  const {
+    itemId,
+    slotKey,
+    roomGroup,
+    action = 'reduce',
+    includeSlotServices = false,
+    replacementCatalogItemId,
+    replacementSku,
+    replacementItem,
+    dryRun = false,
+    orgId = DEFAULT_ORG_ID
+  } = params;
+
+  if (!documentId) throw new Error('Wymagany jest parametr documentId.');
+  if (!itemId && !slotKey) throw new Error('Wymagany jest parametr itemId lub slotKey.');
+
+  if (action === 'replace' && (replacementCatalogItemId || replacementSku)) {
+    return await assignCatalogItemToEstimate(documentId, {
+      catalogItemId: replacementCatalogItemId,
+      sku: replacementSku,
+      rowId: itemId,
+      slotKey,
+      asReplacement: true,
+      dryRun,
+      orgId
+    });
+  }
+
+  const doc = await getDocument(documentId, { orgId });
+  const dj = doc.dataJson || {};
+  const panelData = dj.estimatePanelData || { estimateItems: [] };
+  let items = [...(panelData.estimateItems || [])];
+
+  const matchRow = (it) => {
+    if (itemId && String(it.id) === String(itemId)) return true;
+    if (slotKey) {
+      const sMatch = String(it.binding?.slotKey) === String(slotKey) ||
+        String(it.templateMeta?.slotName) === String(slotKey) ||
+        domain.norm(it.name).includes(domain.norm(slotKey));
+      if (!sMatch) return false;
+      if (roomGroup && !domain.norm(it.group).includes(domain.norm(roomGroup))) return false;
+      return true;
+    }
+    return false;
+  };
+
+  const targetIdx = items.findIndex(matchRow);
+  if (targetIdx < 0) {
+    throw new Error(`Nie znaleziono pozycji (itemId=${itemId || ''}, slotKey=${slotKey || ''}) w kosztorysie ${documentId}.`);
+  }
+
+  const target = items[targetIdx];
+  const affectedIds = [target.id];
+
+  // Znajdź powiązane pozycje w tym samym slocie i pokoju, jeśli includeSlotServices = true
+  const isSameSlot = (it) =>
+    includeSlotServices &&
+    target.binding?.slotId &&
+    it.binding?.slotId === target.binding.slotId &&
+    it.binding?.ocrRoomId === target.binding.ocrRoomId;
+
+  if (action === 'reduce') {
+    items = items.map(it => {
+      if (it.id === target.id || isSameSlot(it)) {
+        if (!affectedIds.includes(it.id)) affectedIds.push(it.id);
+        return { ...it, cancelled: true, cancelledManual: true };
+      }
+      return it;
+    });
+  } else if (action === 'restore') {
+    const replacementIdsToRemove = new Set();
+    items = items.map(it => {
+      if (it.id === target.id || isSameSlot(it)) {
+        if (!affectedIds.includes(it.id)) affectedIds.push(it.id);
+        if (it.replacedByItemId) replacementIdsToRemove.add(String(it.replacedByItemId));
+        const copy = { ...it, cancelled: false };
+        delete copy.cancelledManual;
+        delete copy.replacedByItemId;
+        return copy;
+      }
+      return it;
+    }).filter(it => !replacementIdsToRemove.has(String(it.id)) && String(it.replacesItemId) !== String(target.id));
+  } else if (action === 'replace') {
+    const repId = domain.newUuid();
+    const qty = Number(replacementItem?.quantity ?? target.quantity ?? 1);
+    const unitPrice = Number(replacementItem?.unitPrice ?? target.unitPrice ?? 0);
+    const vatRate = Number(replacementItem?.vatRate ?? target.vatRate ?? 8);
+    const prices = domain.calculateRowPrices(qty, unitPrice, vatRate);
+
+    const newRepRow = {
+      id: repId,
+      name: replacementItem?.name || `${target.name} (zamiennik)`,
+      group: replacementItem?.group || target.group,
+      unit: replacementItem?.unit || target.unit || 'szt',
+      quantity: qty,
+      unitPrice,
+      purchasePrice: Number(replacementItem?.purchasePrice ?? unitPrice * 0.7),
+      vatRate,
+      type: replacementItem?.type || target.type || 'PRODUCT',
+      itemKind: replacementItem?.itemKind || target.itemKind || 'material',
+      SKU: replacementItem?.SKU || '',
+      replacesItemId: target.id,
+      outOfPackageScope: true,
+      settlementMode: 'surcharge',
+      ...prices
+    };
+
+    items[targetIdx] = {
+      ...target,
+      cancelled: true,
+      cancelledManual: true,
+      replacedByItemId: repId
+    };
+    items.splice(targetIdx + 1, 0, newRepRow);
+    affectedIds.push(repId);
+  } else if (action === 'remove_permanently') {
+    if (!dj.estimateBindings) dj.estimateBindings = { removedBindingKeys: [] };
+    if (!Array.isArray(dj.estimateBindings.removedBindingKeys)) dj.estimateBindings.removedBindingKeys = [];
+    const remSet = new Set(dj.estimateBindings.removedBindingKeys);
+
+    const toRemoveIds = new Set();
+    for (const it of items) {
+      if (it.id === target.id || isSameSlot(it)) {
+        toRemoveIds.add(it.id);
+        if (it.binding) {
+          remSet.add(domain.looseBindingKey(it.binding));
+          remSet.add(domain.removedBindingKey(it.binding));
+        }
+      }
+    }
+    dj.estimateBindings.removedBindingKeys = [...remSet];
+    items = items.filter(it => !toRemoveIds.has(it.id));
+  } else {
+    throw new Error(`Nieznana akcja redukcji: ${action}`);
+  }
+
+  if (dryRun) {
+    return { dryRun: true, documentId, action, affectedIds, itemsCount: items.length };
+  }
+
+  panelData.estimateItems = items;
+  dj.estimatePanelData = panelData;
+  const totals = domain.recalculateDocumentTotals(dj);
+  await patchDocument(documentId, { dataJson: dj }, { orgId });
+
+  return {
+    success: true,
+    documentId,
+    action,
+    affectedIds,
+    totalPrices: totals
+  };
+}
+
+/**
+ * Pobiera pomieszczenia i obmiary (roomsAndMeasurements) oraz ich mapowania na wzorzec pakietowy (roomMappings).
+ */
+async function getRoomsAndMeasurements(documentId, { orgId = DEFAULT_ORG_ID } = {}) {
+  if (!documentId) throw new Error('Wymagany jest parametr documentId.');
+  const doc = await getDocument(documentId, { orgId });
+  const dj = doc.dataJson || {};
+  const analysis = dj.roomsAndMeasurements?.roomAnalyses?.[0] || { rooms: [] };
+  const rooms = analysis.rooms || [];
+  const totalArea = analysis.totalArea ?? domain.round2(rooms.reduce((s, r) => s + (Number(r.area) || 0), 0));
+
+  return {
+    documentId: doc.id,
+    documentName: doc.name,
+    totalArea,
+    balconyArea: analysis.balconyArea ?? 0,
+    roomsCount: rooms.length,
+    rooms,
+    roomMappings: dj.estimateBindings?.roomMappings || [],
+    dimensionsSnapshot: dj.estimateBindings?.dimensionsSnapshot || {}
+  };
+}
+
+/**
+ * Aktualizuje obmiary i listę pomieszczeń (dodawanie, edycja wymiarów/otworów, usuwanie, zmiana udziału aneksu kuchennego)
+ * oraz automatycznie przelicza ilości i ceny pozycji kosztorysu powiązanych z obmiarami.
+ */
+async function updateRoomsAndMeasurements(documentId, params = {}) {
+  const {
+    rooms: replaceRooms,
+    updateRooms = [],
+    addRooms = [],
+    removeRoomIds = [],
+    balconyArea,
+    recalculateItems = true,
+    dryRun = false,
+    orgId = DEFAULT_ORG_ID
+  } = params;
+
+  if (!documentId) throw new Error('Wymagany jest parametr documentId.');
+  const doc = await getDocument(documentId, { orgId });
+  const dj = doc.dataJson || {};
+
+  if (!dj.roomsAndMeasurements) {
+    dj.roomsAndMeasurements = { roomFiles: [], roomAnalyses: [{ id: `a_${Date.now()}`, status: 'completed', rooms: [] }] };
+  }
+  if (!Array.isArray(dj.roomsAndMeasurements.roomAnalyses) || dj.roomsAndMeasurements.roomAnalyses.length === 0) {
+    dj.roomsAndMeasurements.roomAnalyses = [{ id: `a_${Date.now()}`, status: 'completed', rooms: [] }];
+  }
+
+  const analysis = dj.roomsAndMeasurements.roomAnalyses[0];
+  let rooms = Array.isArray(replaceRooms) ? [...replaceRooms] : [...(analysis.rooms || [])];
+
+  // 1. Usunięcie wskazanych pokoi
+  if (Array.isArray(removeRoomIds) && removeRoomIds.length > 0) {
+    const rem = new Set(removeRoomIds.map(String));
+    rooms = rooms.filter(r => !rem.has(String(r.id)) && !rem.has(String(r.name)));
+  }
+
+  // 2. Aktualizacja istniejących pokoi (po id lub nazwie)
+  for (const upd of (updateRooms || [])) {
+    const idx = rooms.findIndex(r =>
+      (upd.id && String(r.id) === String(upd.id)) ||
+      (upd.name && domain.norm(r.name) === domain.norm(upd.name))
+    );
+    if (idx >= 0) {
+      const cur = rooms[idx];
+      const nextArea = upd.area !== undefined ? Number(upd.area) : Number(cur.area || 0);
+      const nextPerim = upd.perimeter !== undefined
+        ? Number(upd.perimeter)
+        : (cur.perimeter !== undefined ? Number(cur.perimeter) : domain.round2(4 * Math.sqrt(Math.max(1, nextArea))));
+      rooms[idx] = {
+        ...cur,
+        ...upd,
+        id: cur.id || domain.newUuid(),
+        name: upd.newName || upd.name || cur.name,
+        area: nextArea,
+        perimeter: nextPerim,
+        height: upd.height !== undefined ? Number(upd.height) : Number(cur.height || 2.7),
+        openings: upd.openings !== undefined ? upd.openings : (cur.openings || [])
+      };
+    }
+  }
+
+  // 3. Dodanie nowych pokoi
+  for (const add of (addRooms || [])) {
+    const area = Number(add.area) || 10;
+    const perim = add.perimeter !== undefined ? Number(add.perimeter) : domain.round2(4 * Math.sqrt(Math.max(1, area)));
+    rooms.push({
+      id: add.id || domain.newUuid(),
+      name: add.name || 'Nowe pomieszczenie',
+      area,
+      perimeter: perim,
+      height: Number(add.height) || 2.7,
+      openings: add.openings || [
+        { id: domain.newUuid(), kind: 'door', width: 0.9, count: 1, source: 'manual' }
+      ],
+      ...(add.kitchenAreaShare !== undefined ? { kitchenAreaShare: Number(add.kitchenAreaShare) } : {}),
+      ...(add.templateTargets !== undefined ? { templateTargets: add.templateTargets } : {})
+    });
+  }
+
+  // Upewnij się, że każdy pokój ma id, area, perimeter, height
+  rooms = rooms.map(r => {
+    const area = Number(r.area) || 0;
+    return {
+      ...r,
+      id: r.id || domain.newUuid(),
+      area,
+      perimeter: r.perimeter !== undefined ? Number(r.perimeter) : domain.round2(4 * Math.sqrt(Math.max(1, area))),
+      height: Number(r.height) || 2.7,
+      openings: Array.isArray(r.openings) ? r.openings : []
+    };
+  });
+
+  const totalArea = domain.round2(rooms.reduce((s, r) => s + (Number(r.area) || 0), 0));
+  analysis.rooms = rooms;
+  analysis.totalArea = totalArea;
+  analysis.status = 'completed';
+  if (balconyArea !== undefined) analysis.balconyArea = Number(balconyArea);
+  if (dj.project) dj.project.area = totalArea;
+
+  // Zaktualizuj mapowania pokoi i przelicz pozycje wzorca
+  if (!dj.templatesSnapshot || !Array.isArray(dj.templatesSnapshot.packages)) {
+    dj.templatesSnapshot = domain.getDefaultTemplatesSnapshot();
+  }
+  const pkgCfg = domain.resolvePackageConfig(dj.finishStandard?.selectedPackageId || dj.finishStandard?.selectedPackageName || 'SMART');
+  const pkg = dj.templatesSnapshot.packages.find(p => p.id === pkgCfg.packageUuid) || dj.templatesSnapshot.packages[0];
+
+  const roomMappings = domain.buildRoomMappingsForPackage(rooms, pkg, dj.estimateBindings?.roomMappings || []);
+  const { variantAnswers } = domain.collectQuestionsAndDefaultAnswers(
+    pkg,
+    roomMappings,
+    totalArea,
+    dj.finishStandard?.variantAnswers || {}
+  );
+
+  if (recalculateItems && pkg) {
+    const reconciled = domain.generateAndReconcilePackageItems({
+      pkg,
+      pkgConfig: pkgCfg,
+      ocrRooms: rooms,
+      roomMappings,
+      variantAnswers,
+      currentItems: dj.estimatePanelData?.estimateItems || [],
+      removedBindingKeys: dj.estimateBindings?.removedBindingKeys || [],
+      preserveChosenProducts: true
+    });
+    if (!dj.estimatePanelData) dj.estimatePanelData = {};
+    dj.estimatePanelData.estimateItems = reconciled.items;
+    if (!dj.estimateBindings) dj.estimateBindings = {};
+    dj.estimateBindings.dimensionsSnapshot = reconciled.dimensionsSnapshot;
+  }
+
+  const { signature, variantAnswersHash } = domain.computeEstimateSignature(
+    String(documentId),
+    pkgCfg.packageUuid,
+    variantAnswers,
+    rooms,
+    roomMappings
+  );
+
+  dj.estimateBindings = {
+    ...(dj.estimateBindings || {}),
+    packageId: pkgCfg.packageUuid,
+    finishPackageId: pkgCfg.selectedPackageId,
+    roomMappings,
+    variantAnswersHash,
+    signature
+  };
+  if (dj.finishStandard) {
+    dj.finishStandard.variantAnswers = variantAnswers;
+  }
+
+  const totals = domain.recalculateDocumentTotals(dj);
+
+  if (dryRun) {
+    return {
+      dryRun: true,
+      documentId,
+      totalArea,
+      roomsCount: rooms.length,
+      rooms,
+      roomMappings,
+      itemsCount: (dj.estimatePanelData?.estimateItems || []).length,
+      totalPrices: totals
+    };
+  }
+
+  await patchDocument(documentId, { dataJson: dj }, { orgId });
+
+  return {
+    success: true,
+    documentId,
+    totalArea,
+    roomsCount: rooms.length,
+    rooms,
+    roomMappings,
+    itemsCount: (dj.estimatePanelData?.estimateItems || []).length,
+    totalPrices: totals
+  };
+}
+
+/**
+ * Pobiera aktualnie wybrany pakiet kosztorysu, dostępne pakiety oraz listę pytań i odpowiedzi ankietowych (variantAnswers).
+ */
+async function getPackageAndVariants(documentId, { orgId = DEFAULT_ORG_ID } = {}) {
+  if (!documentId) throw new Error('Wymagany jest parametr documentId.');
+  const doc = await getDocument(documentId, { orgId });
+  const dj = doc.dataJson || {};
+  const templates = dj.templatesSnapshot?.packages ? dj.templatesSnapshot : domain.getDefaultTemplatesSnapshot();
+  const pkgCfg = domain.resolvePackageConfig(dj.finishStandard?.selectedPackageId || dj.finishStandard?.selectedPackageName || 'SMART');
+  const pkg = templates.packages.find(p => p.id === pkgCfg.packageUuid) || templates.packages[0];
+
+  const rooms = dj.roomsAndMeasurements?.roomAnalyses?.[0]?.rooms || [];
+  const totalArea = dj.roomsAndMeasurements?.roomAnalyses?.[0]?.totalArea || domain.round2(rooms.reduce((s, r) => s + (Number(r.area) || 0), 0));
+  const roomMappings = dj.estimateBindings?.roomMappings?.length
+    ? dj.estimateBindings.roomMappings
+    : domain.buildRoomMappingsForPackage(rooms, pkg, []);
+
+  const { questions, variantAnswers } = domain.collectQuestionsAndDefaultAnswers(
+    pkg,
+    roomMappings,
+    totalArea,
+    dj.finishStandard?.variantAnswers || {}
+  );
+
+  return {
+    documentId: doc.id,
+    documentName: doc.name,
+    currentPackage: {
+      key: pkgCfg.key,
+      selectedPackageId: pkgCfg.selectedPackageId,
+      selectedPackageName: pkgCfg.selectedPackageName,
+      packageUuid: pkgCfg.packageUuid,
+      unitPriceM2: dj.finishStandard?.unitPriceM2 ?? pkgCfg.unitPriceM2,
+      markupPct: pkgCfg.markupPct
+    },
+    availablePackages: Object.values(domain.PACKAGE_CONFIGS),
+    questionsCount: questions.length,
+    questions,
+    variantAnswers
+  };
+}
+
+/**
+ * Zmienia pakiet wykończeniowy kosztorysu (SMART / MODERN / HIGH) i/lub odpowiedzi ankietowe (variantAnswers),
+ * automatycznie mapuje pomieszczenia na nowy pakiet i przebudowuje/uzgadnia pozycje wzorca (estimateItems).
+ */
+async function setPackageAndVariants(documentId, params = {}) {
+  const {
+    package: pkgInput,
+    variantAnswers: customAnswers = {},
+    preserveChosenProducts = true,
+    resetReductions = false,
+    dryRun = false,
+    orgId = DEFAULT_ORG_ID
+  } = params;
+
+  if (!documentId) throw new Error('Wymagany jest parametr documentId.');
+  const doc = await getDocument(documentId, { orgId });
+  const dj = doc.dataJson || {};
+
+  if (!dj.templatesSnapshot || !Array.isArray(dj.templatesSnapshot.packages)) {
+    dj.templatesSnapshot = domain.getDefaultTemplatesSnapshot();
+  }
+
+  const currentPkgId = dj.finishStandard?.selectedPackageId || dj.finishStandard?.selectedPackageName || 'SMART';
+  const pkgCfg = domain.resolvePackageConfig(pkgInput || currentPkgId);
+  const pkg = dj.templatesSnapshot.packages.find(p => p.id === pkgCfg.packageUuid) || dj.templatesSnapshot.packages[0];
+
+  const rooms = dj.roomsAndMeasurements?.roomAnalyses?.[0]?.rooms || [];
+  const totalArea = dj.roomsAndMeasurements?.roomAnalyses?.[0]?.totalArea || domain.round2(rooms.reduce((s, r) => s + (Number(r.area) || 0), 0));
+  const roomMappings = domain.buildRoomMappingsForPackage(rooms, pkg, dj.estimateBindings?.roomMappings || []);
+
+  // Połącz dotychczasowe odpowiedzi z nowymi przekazanymi przez użytkownika
+  const mergedInputAnswers = {
+    ...(dj.finishStandard?.variantAnswers || {}),
+    ...(customAnswers || {})
+  };
+
+  const { questions, variantAnswers } = domain.collectQuestionsAndDefaultAnswers(
+    pkg,
+    roomMappings,
+    totalArea,
+    mergedInputAnswers
+  );
+
+  let baseItems = dj.estimatePanelData?.estimateItems || [];
+  if (resetReductions) {
+    baseItems = baseItems.map(it => ({ ...it, cancelled: false, cancelledManual: undefined }));
+  }
+
+  const reconciled = domain.generateAndReconcilePackageItems({
+    pkg,
+    pkgConfig: pkgCfg,
+    ocrRooms: rooms,
+    roomMappings,
+    variantAnswers,
+    currentItems: baseItems,
+    removedBindingKeys: resetReductions ? [] : (dj.estimateBindings?.removedBindingKeys || []),
+    preserveChosenProducts
+  });
+
+  const scopes = [];
+  for (const m of roomMappings) {
+    for (const t of (m.templateRoomIds || [])) {
+      scopes.push(`${m.ocrRoomId}|${t.templateRoomId}`);
+    }
+  }
+  const wholeRoom = (pkg.rooms || []).find(r => r.key === 'caly_lokal');
+  if (wholeRoom) {
+    scopes.push(`${domain.WHOLE_UNIT_OCR_ROOM_ID}|${wholeRoom.id}`);
+  }
+  const surveyConfirmedFor = `${pkgCfg.packageUuid}::${scopes.sort().join(';')}`;
+  const nowIso = new Date().toISOString();
+  const { signature, variantAnswersHash } = domain.computeEstimateSignature(
+    String(documentId),
+    pkgCfg.packageUuid,
+    variantAnswers,
+    rooms,
+    roomMappings
+  );
+
+  dj.finishStandard = {
+    ...(dj.finishStandard || {}),
+    selectedPackageId: pkgCfg.selectedPackageId,
+    selectedPackageName: pkgCfg.selectedPackageName,
+    unitPriceM2: pkgCfg.unitPriceM2,
+    variantAnswers,
+    surveyConfirmedAt: nowIso,
+    surveyConfirmedFor
+  };
+
+  dj.estimateBindings = {
+    ...(dj.estimateBindings || {}),
+    packageId: pkgCfg.packageUuid,
+    finishPackageId: pkgCfg.selectedPackageId,
+    roomMappings,
+    dimensionsSnapshot: reconciled.dimensionsSnapshot,
+    removedBindingKeys: resetReductions ? [] : (dj.estimateBindings?.removedBindingKeys || []),
+    variantAnswersHash,
+    signature
+  };
+
+  if (!dj.estimatePanelData) dj.estimatePanelData = {};
+  dj.estimatePanelData.estimateItems = reconciled.items;
+  const totals = domain.recalculateDocumentTotals(dj);
+
+  if (dryRun) {
+    return {
+      dryRun: true,
+      documentId,
+      selectedPackage: pkgCfg,
+      questionsCount: questions.length,
+      itemsCount: reconciled.items.length,
+      totalPrices: totals
+    };
+  }
+
+  await patchDocument(documentId, { dataJson: dj }, { orgId });
+
+  return {
+    success: true,
+    documentId,
+    selectedPackage: pkgCfg,
+    questionsCount: questions.length,
+    itemsCount: reconciled.items.length,
+    totalPrices: totals
+  };
+}
+
+/**
+ * Tworzy nowy dokument kosztorysu (POST /documents) dla wybranego projektu,
+ * z inicjalizacją pakietu (SMART / MODERN / HIGH), obmiarów pomieszczeń i wygenerowaniem pozycji ze wzorca.
+ */
+async function createEstimateDocument(params = {}) {
+  const {
+    projectId,
+    name,
+    package: pkgInput = 'SMART',
+    rooms: inputRooms = [],
+    variantAnswers: customAnswers = {},
+    orgId = DEFAULT_ORG_ID
+  } = params;
+
+  if (!projectId) throw new Error('Wymagany jest parametr projectId.');
+
+  const project = await callDevApi('GET', `/projects/${projectId}`, { orgId });
+  const pkgCfg = domain.resolvePackageConfig(pkgInput);
+  const templatesSnapshot = domain.getDefaultTemplatesSnapshot();
+  const pkg = templatesSnapshot.packages.find(p => p.id === pkgCfg.packageUuid) || templatesSnapshot.packages[0];
+
+  const defaultRooms = inputRooms.length > 0 ? inputRooms : [
+    { id: domain.newUuid(), name: 'Hall', area: 6.5, perimeter: 11.0, height: 2.7, openings: [{ id: domain.newUuid(), kind: 'door', width: 0.9, count: 1 }] },
+    { id: domain.newUuid(), name: 'Salon+kuchnia', area: 22.0, perimeter: 19.5, height: 2.7, kitchenAreaShare: 4.0, openings: [{ id: domain.newUuid(), kind: 'door', width: 0.9, count: 1 }] },
+    { id: domain.newUuid(), name: 'Sypialnia', area: 12.5, perimeter: 14.2, height: 2.7, openings: [{ id: domain.newUuid(), kind: 'door', width: 0.9, count: 1 }] },
+    { id: domain.newUuid(), name: 'Łazienka', area: 4.5, perimeter: 8.6, height: 2.7, openings: [{ id: domain.newUuid(), kind: 'door', width: 0.8, count: 1 }] }
+  ];
+
+  const rooms = defaultRooms.map(r => {
+    const area = Number(r.area) || 10;
+    return {
+      ...r,
+      id: r.id || domain.newUuid(),
+      area,
+      perimeter: r.perimeter !== undefined ? Number(r.perimeter) : domain.round2(4 * Math.sqrt(Math.max(1, area))),
+      height: Number(r.height) || 2.7,
+      openings: Array.isArray(r.openings) ? r.openings : []
+    };
+  });
+
+  const totalArea = domain.round2(rooms.reduce((s, r) => s + (Number(r.area) || 0), 0));
+  const roomMappings = domain.buildRoomMappingsForPackage(rooms, pkg, []);
+  const { variantAnswers } = domain.collectQuestionsAndDefaultAnswers(pkg, roomMappings, totalArea, customAnswers);
+
+  const reconciled = domain.generateAndReconcilePackageItems({
+    pkg,
+    pkgConfig: pkgCfg,
+    ocrRooms: rooms,
+    roomMappings,
+    variantAnswers,
+    currentItems: [],
+    removedBindingKeys: [],
+    preserveChosenProducts: false
+  });
+
+  const nowIso = new Date().toISOString();
+  const dataJson = {
+    project: {
+      id: String(project.id || projectId),
+      name: project.name || '',
+      type: project.projectType || 'MIESZKANIE',
+      number: project.number || '',
+      status: project.propertyStatus || 'RYNEK_PIERWOTNY',
+      address: project.address || null,
+      area: totalArea
+    },
+    client: project.clients || [],
+    organization: { id: String(orgId), name: 'Deer Design' },
+    roomsAndMeasurements: {
+      roomFiles: [],
+      roomAnalyses: [
+        {
+          id: `a_${Date.now()}`,
+          status: 'completed',
+          totalArea,
+          balconyArea: 0,
+          rooms
+        }
+      ]
+    },
+    finishStandard: {
+      selectedPackageId: pkgCfg.selectedPackageId,
+      selectedPackageName: pkgCfg.selectedPackageName,
+      unitPriceM2: pkgCfg.unitPriceM2,
+      variantAnswers,
+      surveyConfirmedAt: nowIso
+    },
+    estimateBindings: {
+      packageId: pkgCfg.packageUuid,
+      finishPackageId: pkgCfg.selectedPackageId,
+      roomMappings,
+      dimensionsSnapshot: reconciled.dimensionsSnapshot,
+      removedBindingKeys: [],
+      variantAnswersHash: domain.hashVariantAnswers(variantAnswers)
+    },
+    templatesSnapshot,
+    estimatePanelData: {
+      estimateItems: reconciled.items,
+      totalPrices: { totalNetPrice: 0, totalVatPrice: 0, totalGrossPrice: 0 }
+    },
+    additionalInfo: {
+      estimateRemarks: `Kosztorys pakietowy ${pkgCfg.selectedPackageName} (${totalArea} m²) utworzony przez DeerTools MCP.`
+    }
+  };
+
+  domain.recalculateDocumentTotals(dataJson);
+
+  const docName = name || `Kosztorys ${pkgCfg.selectedPackageName} — ${project.name || project.number || projectId}`;
+  const created = await callDevApi('POST', '/documents', {
+    body: {
+      name: docName,
+      type: 'ESTIMATE',
+      projectId: String(projectId),
+      dataJson
+    },
+    orgId
+  });
+
+  const docId = String(created.id);
+  const { signature } = domain.computeEstimateSignature(docId, pkgCfg.packageUuid, variantAnswers, rooms, roomMappings);
+  dataJson.estimateBindings.signature = signature;
+
+  const updated = await patchDocument(docId, { name: docName, type: 'ESTIMATE', dataJson }, { orgId });
+
+  return {
+    success: true,
+    documentId: docId,
+    documentNumber: updated.documentNumber || created.documentNumber,
+    name: docName,
+    projectId: String(projectId),
+    package: pkgCfg.selectedPackageName,
+    totalArea,
+    roomsCount: rooms.length,
+    itemsCount: reconciled.items.length,
+    totalPrices: dataJson.estimatePanelData.totalPrices
+  };
+}
+
+/**
+ * Bezpieczna, całościowa aktualizacja pozycji kosztorysu (estimateItems).
+ */
+async function updateAllEstimateItems(documentId, newItems, options = {}) {
+  const { recalculateTotals = true, dryRun = false, orgId = DEFAULT_ORG_ID } = options;
+
+  if (!documentId) throw new Error('Wymagany jest parametr documentId.');
+  if (!Array.isArray(newItems)) throw new Error('Parametr newItems musi być tablicą pozycji.');
+
+  const doc = await getDocument(documentId, { orgId });
+  const dataJson = doc.dataJson || {};
+  const panelData = dataJson.estimatePanelData || {};
+  const oldItems = panelData.estimateItems || [];
+
+  if (dryRun) {
+    return {
+      dryRun: true,
+      documentId,
+      oldCount: oldItems.length,
+      newCount: newItems.length,
+      itemsSample: newItems.slice(0, 3)
+    };
+  }
+
+  dataJson._lastBackup = {
+    updatedAt: new Date().toISOString(),
+    itemsCount: oldItems.length,
+    itemsSnapshot: oldItems
+  };
+
+  panelData.estimateItems = newItems;
+  dataJson.estimatePanelData = panelData;
+
+  let totals = panelData.totalPrices;
+  if (recalculateTotals) {
+    totals = domain.recalculateDocumentTotals(dataJson);
+  }
+
+  const updatedDoc = await patchDocument(documentId, { dataJson }, { orgId });
+
+  return {
+    success: true,
+    documentId,
+    itemsCount: newItems.length,
+    totalPrices: totals,
+    totalNet: panelData.totalNet,
+    totalGross: panelData.totalGross,
+    document: updatedDoc
+  };
+}
+
+/**
+ * Atomowa modyfikacja wybranych pozycji kosztorysu (add, update, remove).
+ */
+async function patchEstimateItems(documentId, changes = {}) {
+  const { add = [], update = [], remove = [], dryRun = false, orgId = DEFAULT_ORG_ID } = changes;
+
+  if (!documentId) throw new Error('Wymagany jest parametr documentId.');
+
+  const doc = await getDocument(documentId, { orgId });
+  const dataJson = doc.dataJson || {};
+  const panelData = dataJson.estimatePanelData || {};
+  let items = [...(panelData.estimateItems || [])];
+
+  const removeIds = new Set((remove || []).map(String));
+  const updateMap = new Map((update || []).map(u => [String(u.id || u.slotKey), u]));
+
+  if (removeIds.size > 0) {
+    items = items.filter(it => !removeIds.has(String(it.id)) && !removeIds.has(String(it.binding?.slotKey)));
+  }
+
+  items = items.map(it => {
+    const keyId = String(it.id);
+    const keySlot = it.binding?.slotKey ? String(it.binding.slotKey) : null;
+    const patch = updateMap.get(keyId) || (keySlot && updateMap.get(keySlot));
+
+    if (patch) {
+      return {
+        ...it,
+        ...patch,
+        binding: patch.binding ? { ...it.binding, ...patch.binding } : it.binding,
+        templateMeta: patch.templateMeta ? { ...it.templateMeta, ...patch.templateMeta } : it.templateMeta
+      };
+    }
+    return it;
+  });
+
+  if (Array.isArray(add) && add.length > 0) {
+    for (const itemToAdd of add) {
+      if (!itemToAdd.id) {
+        itemToAdd.id = domain.newUuid();
+      }
+      items.push(itemToAdd);
+    }
+  }
+
+  if (dryRun) {
+    return {
+      dryRun: true,
+      documentId,
+      added: (add || []).length,
+      updated: (update || []).length,
+      removed: (remove || []).length,
+      resultingCount: items.length
+    };
+  }
+
+  return await updateAllEstimateItems(documentId, items, { dryRun: false, orgId });
+}
+
+/**
+ * Zmiana statusu pakietowego pozycji (np. przejście na dopłatę SURCHARGE, INCLUDED lub REDUCTION).
+ */
+async function setItemBinding(documentId, itemId, bindingData = {}) {
+  const { binding = 'SURCHARGE', surchargeAmountNet = 0, dryRun = false, orgId = DEFAULT_ORG_ID } = bindingData;
+
+  const doc = await getDocument(documentId, { orgId });
+  const items = doc.dataJson?.estimatePanelData?.estimateItems || [];
+  const targetItem = items.find(it => String(it.id) === String(itemId) || String(it.binding?.slotKey) === String(itemId));
+
+  if (!targetItem) {
+    throw new Error(`Nie znaleziono pozycji o ID: ${itemId} w kosztorysie ${documentId}.`);
+  }
+
+  const updatedBinding = typeof targetItem.binding === 'object' && targetItem.binding !== null ? { ...targetItem.binding } : {};
+  updatedBinding.bindingStatus = binding;
+  if (surchargeAmountNet) {
+    updatedBinding.surchargeAmountNet = Number(surchargeAmountNet);
+  }
+
+  const settlementMode = binding === 'INCLUDED'
+    ? 'included'
+    : (binding === 'REDUCTION' ? 'reduction' : 'surcharge');
+
+  return await patchEstimateItems(documentId, {
+    update: [{
+      id: targetItem.id,
+      binding: updatedBinding,
+      settlementMode,
+      ...(binding === 'REDUCTION' ? { cancelled: true, cancelledManual: true } : {})
+    }],
+    dryRun,
+    orgId
+  });
+}
+
+/**
+ * Automatycznie dobiera produkty z Katalogu 5 do wszystkich (lub wybranych) pustych slotów wzorcowych w kosztorysie,
+ * z zachowaniem filtrów kategorii, pakietu i limitu cenowego (priceMax).
+ */
+async function autoFillTemplateSlots(documentId, params = {}) {
+  const {
+    onlyUnfilled = true,
+    keepIsTemplateFlag = false,
+    documentName,
+    dryRun = false,
+    orgId = DEFAULT_ORG_ID
+  } = params;
+
+  if (!documentId) throw new Error('Wymagany jest parametr documentId.');
+  const doc = await getDocument(documentId, { orgId });
+  const dj = doc.dataJson || {};
+  const pkgCfg = domain.resolvePackageConfig(dj.finishStandard?.selectedPackageId || dj.finishStandard?.selectedPackageName || dj.estimateBindings?.packageId || 'SMART');
+
+  // Upewnij się, że finishStandard ma pełne pola pakietu
+  if (!dj.finishStandard) dj.finishStandard = {};
+  if (!dj.finishStandard.selectedPackageId) dj.finishStandard.selectedPackageId = pkgCfg.selectedPackageId;
+  if (!dj.finishStandard.selectedPackageName) dj.finishStandard.selectedPackageName = pkgCfg.selectedPackageName;
+  if (!dj.finishStandard.unitPriceM2) dj.finishStandard.unitPriceM2 = pkgCfg.unitPriceM2;
+
+  const panelData = dj.estimatePanelData || { estimateItems: [] };
+  const items = [...(panelData.estimateItems || [])];
+
+  // Cache dobranych produktów per (categoryPath + priceMax) dla spójności w całym mieszkaniu
+  const chosenByCatAndLimit = new Map();
+  let filledCount = 0;
+  const filledDetails = [];
+
+  for (let i = 0; i < items.length; i++) {
+    const row = items[i];
+    if (row.cancelled) continue;
+    const isProductRow = row.type === 'PRODUCT' || row.itemKind === 'material';
+    if (!isProductRow) continue;
+    if (onlyUnfilled && !row.isTemplate && row.productId) continue;
+
+    const tm = row.templateMeta || {};
+    const catPath = tm.categoryPath || row.categoryPath;
+    if (!catPath) continue;
+    const priceMax = tm.priceMax != null ? Number(tm.priceMax) : null;
+    const cacheKey = `${catPath}::${priceMax ?? 'nolimit'}`;
+
+    let bestItem = chosenByCatAndLimit.get(cacheKey);
+    if (bestItem === undefined) {
+      // Krok 1: Szukaj w pakiecie i limicie ceny
+      let searchRes = await searchEstimateCatalog({
+        type: 'product',
+        categoryPathPrefix: catPath,
+        packageFilter: pkgCfg.packageKey,
+        priceMax: priceMax != null ? priceMax : undefined,
+        unit: row.unit,
+        unlockFilters: false,
+        pageSize: 15,
+        orgId
+      });
+
+      let candidates = searchRes.items || [];
+
+      // Krok 2: Jeśli brak w ścisłym limicie pakietu, szukaj w tej kategorii w pakiecie bez filtru ceny i wybierz najbliższy limitu
+      if (candidates.length === 0) {
+        const resPkg = await callDevApi('GET', `/catalogs/${ESTIMATE_CATALOG_ID}/items`, {
+          query: {
+            type: 'product',
+            categoryPathPrefix: catPath,
+            package: pkgCfg.packageKey,
+            includeRelated: 'true',
+            page: 1,
+            pageSize: 20
+          },
+          orgId
+        });
+        candidates = resPkg.items || [];
+      }
+
+      // Krok 3: Jeśli nadal brak, szukaj w całej kategorii (niezależnie od pakietu)
+      if (candidates.length === 0) {
+        const resAny = await callDevApi('GET', `/catalogs/${ESTIMATE_CATALOG_ID}/items`, {
+          query: {
+            type: 'product',
+            categoryPathPrefix: catPath,
+            includeRelated: 'true',
+            page: 1,
+            pageSize: 20
+          },
+          orgId
+        });
+        candidates = resAny.items || [];
+      }
+
+      if (candidates.length > 0) {
+        // Wybierz produkt o dodatniej cenie zakupu <= priceMax (najbliżej priceMax), lub pierwszy dostępny
+        const withPrice = candidates.filter(c => Number(c.purchasePricePerPricingUnit ?? c.purchasePrice ?? 0) > 0);
+        const pool = withPrice.length > 0 ? withPrice : candidates;
+        if (priceMax != null) {
+          const within = pool.filter(c => Number(c.purchasePricePerPricingUnit ?? c.purchasePrice ?? 0) <= priceMax + 0.01);
+          if (within.length > 0) {
+            within.sort((a, b) => Number(b.purchasePricePerPricingUnit ?? b.purchasePrice ?? 0) - Number(a.purchasePricePerPricingUnit ?? a.purchasePrice ?? 0));
+            bestItem = within[0];
+          } else {
+            pool.sort((a, b) => Number(a.purchasePricePerPricingUnit ?? a.purchasePrice ?? 0) - Number(b.purchasePricePerPricingUnit ?? b.purchasePrice ?? 0));
+            bestItem = pool[0];
+          }
+        } else {
+          bestItem = pool[0];
+        }
+        // Pobierz pełny obiekt katalogowy jeśli przyszedł ze wzbogaconej listy searchEstimateCatalog
+        if (bestItem && bestItem.computedUnitPriceNet !== undefined) {
+          bestItem = await getEstimateCatalogItem(bestItem.id, { markupPct: pkgCfg.markupPct, orgId });
+        }
+      } else {
+        bestItem = null;
+      }
+
+      chosenByCatAndLimit.set(cacheKey, bestItem);
+    }
+
+    if (!bestItem) continue;
+
+    const rawQty = row.packaging?.includesReserve ? (row.packaging.rawAreaM2 ?? row.quantity ?? 1) : (row.quantity ?? 1);
+    const isPaint = catPath.toLowerCase().includes('farby');
+    let built;
+    if (isPaint && priceMax != null) {
+      // Farby wyceniane są w m² wg stawki wzorca (np. 11.71 zł/m² netto zakupu)
+      built = domain.buildEstimateRowFromCatalogItem(bestItem, {
+        quantity: rawQty,
+        group: row.group,
+        rowId: row.id,
+        expectedUnit: row.unit,
+        reservePct: row.reservePct,
+        markupPct: pkgCfg.markupPct,
+        packageLabel: pkgCfg.selectedPackageName
+      });
+      built.unit = row.unit || 'm2';
+      built.quantity = rawQty;
+      built.purchasePrice = priceMax;
+      built.unitPrice = domain.round2(priceMax * (1 + pkgCfg.markupPct / 100));
+      Object.assign(built, domain.calculateRowPrices(rawQty, built.unitPrice, built.vatRate));
+    } else {
+      built = domain.buildEstimateRowFromCatalogItem(bestItem, {
+        quantity: rawQty,
+        group: row.group,
+        rowId: row.id,
+        expectedUnit: row.unit,
+        reservePct: row.reservePct,
+        markupPct: pkgCfg.markupPct,
+        packageLabel: pkgCfg.selectedPackageName
+      });
+    }
+
+    const cleanMeta = { ...tm };
+    delete cleanMeta.catalogMissing;
+
+    items[i] = {
+      ...row,
+      ...built,
+      isTemplate: keepIsTemplateFlag ? true : false,
+      binding: row.binding,
+      templateMeta: cleanMeta
+    };
+    filledCount++;
+    filledDetails.push({
+      rowId: row.id,
+      group: row.group,
+      slotName: tm.slotName || row.name,
+      assignedProductId: bestItem.id,
+      assignedSku: bestItem.sku,
+      assignedName: bestItem.name,
+      quantity: items[i].quantity,
+      unit: items[i].unit,
+      unitPriceNet: items[i].unitPrice,
+      totalNetPrice: items[i].totalNetPrice
+    });
+  }
+
+  panelData.estimateItems = items;
+  dj.estimatePanelData = panelData;
+  const totals = domain.recalculateDocumentTotals(dj);
+
+  if (dryRun) {
+    return {
+      dryRun: true,
+      documentId,
+      package: pkgCfg.selectedPackageName,
+      filledCount,
+      filledSample: filledDetails.slice(0, 10),
+      totalPrices: totals
+    };
+  }
+
+  const patchPayload = { dataJson: dj };
+  if (documentName && String(documentName).trim()) {
+    patchPayload.name = String(documentName).trim();
+  }
+  await patchDocument(documentId, patchPayload, { orgId });
+
+  return {
+    success: true,
+    documentId,
+    documentName: patchPayload.name || doc.name,
+    package: pkgCfg.selectedPackageName,
+    filledCount,
+    filledDetails,
+    totalPrices: totals
+  };
+}
+
+module.exports = {
+  callDevApi,
+  listProjects,
+  getProject,
+  listDocuments,
+  getDocument,
+  patchDocument,
+  createEstimateDocument,
+  searchEstimateCatalog,
+  getEstimateCatalogItem,
+  listTemplateSuggestions,
+  assignCatalogItemToEstimate,
+  reduceOrReplaceItem,
+  getRoomsAndMeasurements,
+  updateRoomsAndMeasurements,
+  getPackageAndVariants,
+  setPackageAndVariants,
+  autoFillTemplateSlots,
+  updateAllEstimateItems,
+  patchEstimateItems,
+  setItemBinding
+};