@lonca/trendyol 0.2.0 → 0.4.0

package/dist/index.cjs

@@ -36,6 +36,29 @@ var BrandsResource = class {
     const nextCursor = page + 1 < data.totalPages ? String(page + 1) : void 0;
     return nextCursor !== void 0 ? { items, nextCursor } : { items };
   }
+  /**
+   * Search brands by name. Useful when you need a brand's numeric ID for
+   * `createProducts` and don't want to page through the full `list()`
+   * (1000 brands per page).
+   *
+   * **Discovery-first wire fact (verified STAGE 2026-05-25):** Trendyol's
+   * doc claims this is a case-sensitive *exact* match, but live behaviour
+   * is **substring + case-insensitive** — `search('Trendyol')` returns
+   * 17 hits including `TRENDYOLMILLA`, `trendyol vavist`, `Trendyol Üyelik`.
+   * Plan for ranking your results client-side if you need an exact match.
+   * The endpoint returns an empty array when nothing matches (no 404).
+   *
+   * @param name The brand name to search for.
+   */
+  async search(name) {
+    const data = await this.transport.request({
+      method: "GET",
+      path: "/integration/product/brands/by-name",
+      query: { name },
+      rateLimiter: this.limiter
+    });
+    return (data ?? []).map((b) => ({ id: String(b.id), name: b.name }));
+  }
 };
 function normalizeCategory(node) {
   return {
@@ -65,12 +88,16 @@ function normalizeAttribute(node) {
   }
   return out;
 }
+var MAX_ATTR_VALUES_PAGE_SIZE = 1e3;
+var DEFAULT_ATTR_VALUES_PAGE_SIZE = 100;
 var CategoriesResource = class {
-  constructor(transport, limiter) {
+  constructor(transport, limiter, sellerId) {
     this.transport = transport;
+    this.sellerId = sellerId;
     this.limiter = limiter ?? new core.TokenBucketRateLimiter({ capacity: 50, intervalMs: 6e4 });
   }
   transport;
+  sellerId;
   limiter;
   /**
    * Fetch the full Trendyol category tree.
@@ -112,6 +139,87 @@ var CategoriesResource = class {
     }
     return list.map(normalizeAttribute);
   }
+  /**
+   * Fetch the allowed values for a single category attribute (paginated).
+   *
+   * `getCategoryAttributes` returns attribute metadata + flags but typically
+   * omits the value catalog. Use this method to fetch the catalog for an
+   * attribute when `allowCustom` is `false` and you need to map your data
+   * onto Trendyol's accepted values.
+   *
+   * @param categoryId  Trendyol numeric category ID; accepts `string` or `number`.
+   * @param attributeId Attribute ID returned by `getAttributes`.
+   * @param params      Cursor pagination (max page size 1000; default 100).
+   *
+   * @example
+   * ```ts
+   * import { paginate } from '@lonca/core';
+   * for await (const value of paginate((p) =>
+   *   client.categories.getAttributeValues(catId, attrId, p),
+   * )) {
+   *   console.log(value.id, value.name);
+   * }
+   * ```
+   */
+  async getAttributeValues(categoryId, attributeId, params = {}) {
+    const catId = encodeURIComponent(String(categoryId));
+    const attrId = encodeURIComponent(String(attributeId));
+    const size = Math.min(params.limit ?? DEFAULT_ATTR_VALUES_PAGE_SIZE, MAX_ATTR_VALUES_PAGE_SIZE);
+    const page = params.cursor ? Number.parseInt(params.cursor, 10) : 0;
+    const data = await this.transport.request({
+      method: "GET",
+      path: `/integration/product/categories/${catId}/attributes/${attrId}/values`,
+      query: { page, size },
+      rateLimiter: this.limiter
+    });
+    const items = (data.content ?? []).map((item) => ({
+      id: item.attributeValueId !== void 0 ? String(item.attributeValueId) : "",
+      name: item.attributeValue ?? item.attributeValueName ?? ""
+    }));
+    const result = { items };
+    const totalPages = typeof data.totalPages === "number" ? data.totalPages : 0;
+    if (page + 1 < totalPages) {
+      result.nextCursor = String(page + 1);
+    }
+    return result;
+  }
+  /**
+   * Look up category info for a list of barcodes (Trendyol Export Center
+   * / AutoFT endpoint).
+   *
+   * **Requires Export Center enrollment.** Sellers who have not joined
+   * Trendyol's "İhracat Merkezi" program will get an auth error on this
+   * endpoint even though their regular Marketplace credentials are valid.
+   *
+   * @param barcodes 1–N barcodes to look up.
+   * @throws {ValidationError} when `barcodes` is empty.
+   * @throws Error when the client was created without a `sellerId` and this
+   *   method is called directly (use `createTrendyolClient` to wire it).
+   */
+  async getByBarcodes(barcodes) {
+    if (!Array.isArray(barcodes) || barcodes.length === 0) {
+      throw new core.ValidationError({ message: "getByBarcodes: barcodes must not be empty" });
+    }
+    if (this.sellerId === void 0) {
+      throw new Error(
+        "CategoriesResource.getByBarcodes requires a sellerId; instantiate via createTrendyolClient"
+      );
+    }
+    const data = await this.transport.request({
+      method: "POST",
+      path: `/integration/ecgw/v1/${this.sellerId}/lookup/product-categories/by-barcodes`,
+      body: { barcodes },
+      rateLimiter: this.limiter
+    });
+    const matches = Object.entries(data.barcodeCategories ?? {}).map(([barcode, cat]) => ({
+      barcode,
+      category: {
+        id: cat.id !== void 0 ? String(cat.id) : "",
+        name: cat.displayName ?? ""
+      }
+    }));
+    return { matches, notFound: data.notFound ?? [] };
+  }
 };
 function extractAttributeList(data) {
   if (Array.isArray(data)) return data;
@@ -251,8 +359,9 @@ function normalizeCustomer(node) {
   return out;
 }
 function normalizePackage(node) {
+  const pkgId = node.shipmentPackageId ?? node.id;
   const out = {
-    id: node.shipmentPackageId !== void 0 ? String(node.shipmentPackageId) : "",
+    id: pkgId !== void 0 ? String(pkgId) : "",
     orderNumber: node.orderNumber ?? "",
     status: node.status ?? "",
     customer: normalizeCustomer(node),
@@ -360,9 +469,346 @@ var OrdersResource = class {
     }
     return result;
   }
+  /**
+   * Push a shipment-package status update.
+   *
+   * Trendyol restricts the seller-side push to two transitions:
+   * - `Picking`  — order picked up from the shelf / being prepared
+   * - `Invoiced` — invoice issued, ready for cargo handoff
+   *
+   * Other transitions (`Shipped`, `Delivered`, etc.) are driven by Trendyol
+   * or the cargo provider — call `processAlternativeDelivery` or
+   * `manualDeliverByPackageId` if you ship outside Trendyol's cargo
+   * network.
+   *
+   * Returns void; Trendyol responds with 200 + empty body on success.
+   */
+  async updatePackageStatus(packageId, input) {
+    await this.transport.request({
+      method: "PUT",
+      path: this.packagePath(packageId),
+      body: input,
+      rateLimiter: this.limiter
+    });
+  }
+  /**
+   * Notify Trendyol that one or more line items cannot be supplied
+   * ("Tedarik Edememe Bildirimi"). Marks the listed line IDs as
+   * `UnSupplied`. Trendyol cancels those quantities and notifies the
+   * customer.
+   *
+   * `reasonId` is a numeric code Trendyol publishes separately — consult
+   * the seller panel or the "Tedarik Edememe" docs for current values.
+   *
+   * Returns void; Trendyol responds with 200 + empty body on success.
+   */
+  async cancelPackageItem(packageId, input) {
+    if (!Array.isArray(input?.lines) || input.lines.length === 0) {
+      throw new core.ValidationError({ message: "cancelPackageItem: lines must not be empty" });
+    }
+    await this.transport.request({
+      method: "PUT",
+      path: `${this.packagePath(packageId)}/items/unsupplied`,
+      body: input,
+      rateLimiter: this.limiter
+    });
+  }
+  /**
+   * Extend the agreed delivery date for a shipment package by 1, 2, or 3 days.
+   * Trendyol enforces the [1, 3] range server-side; the SDK validates client-side
+   * to fail fast.
+   *
+   * Returns void; Trendyol responds with 200 + empty body on success.
+   */
+  async extendDeliveryDate(packageId, extendedDayCount) {
+    if (![1, 2, 3].includes(extendedDayCount)) {
+      throw new core.ValidationError({
+        message: `extendDeliveryDate: extendedDayCount must be 1, 2, or 3 (got ${extendedDayCount})`
+      });
+    }
+    await this.transport.request({
+      method: "PUT",
+      path: `${this.packagePath(packageId)}/extended-agreed-delivery-date`,
+      body: { extendedDayCount },
+      rateLimiter: this.limiter
+    });
+  }
+  /**
+   * Notify Trendyol of an alternative delivery channel — used when the
+   * seller is shipping via a non-Trendyol cargo provider. Trendyol then
+   * either SMSes the customer the tracking link (when `isPhoneNumber` is
+   * `true`) or stores the tracking URL on the package directly.
+   *
+   * Returns void; Trendyol responds with 200 + empty body on success.
+   */
+  async processAlternativeDelivery(packageId, input) {
+    await this.transport.request({
+      method: "PUT",
+      path: `${this.packagePath(packageId)}/alternative-delivery`,
+      body: input,
+      rateLimiter: this.limiter
+    });
+  }
+  /**
+   * Split a shipment package by moving a set of line IDs into a new
+   * package. The original package keeps the remaining lines.
+   *
+   * @param packageId    The package to split.
+   * @param orderLineIds Line IDs to move into the new package (1+).
+   * @throws {ValidationError} when `orderLineIds` is empty.
+   */
+  async splitPackage(packageId, orderLineIds) {
+    if (!Array.isArray(orderLineIds) || orderLineIds.length === 0) {
+      throw new core.ValidationError({ message: "splitPackage: orderLineIds must not be empty" });
+    }
+    await this.transport.request({
+      method: "POST",
+      path: `${this.packagePath(packageId)}/split`,
+      body: { orderLineIds },
+      rateLimiter: this.limiter
+    });
+  }
+  /**
+   * Split a shipment package by quantity. Each `QuantitySplit` entry
+   * carves a single line into multiple packages — e.g. `{ orderLineId: 100,
+   * quantities: [2, 2, 1] }` splits 5 units of line 100 into three packages
+   * of 2 + 2 + 1.
+   *
+   * @throws {ValidationError} when `quantitySplit` is empty.
+   */
+  async splitPackageByQuantity(packageId, quantitySplit) {
+    if (!Array.isArray(quantitySplit) || quantitySplit.length === 0) {
+      throw new core.ValidationError({
+        message: "splitPackageByQuantity: quantitySplit must not be empty"
+      });
+    }
+    await this.transport.request({
+      method: "POST",
+      path: `${this.packagePath(packageId)}/quantity-split`,
+      body: { quantitySplit },
+      rateLimiter: this.limiter
+    });
+  }
+  /**
+   * Split a shipment package into multiple new packages by grouping line
+   * IDs. Each `SplitGroup` becomes one new package containing the listed
+   * line IDs.
+   *
+   * @throws {ValidationError} when `splitGroups` is empty.
+   */
+  async multiSplitPackage(packageId, splitGroups) {
+    if (!Array.isArray(splitGroups) || splitGroups.length === 0) {
+      throw new core.ValidationError({ message: "multiSplitPackage: splitGroups must not be empty" });
+    }
+    await this.transport.request({
+      method: "POST",
+      path: `${this.packagePath(packageId)}/multi-split`,
+      body: { splitGroups },
+      rateLimiter: this.limiter
+    });
+  }
+  /**
+   * Split a shipment package into multiple new packages, each containing a
+   * mix of line items at specific quantities. This is the most expressive
+   * split — use it when you need fine-grained control over which line IDs
+   * and how many of each end up in each new package.
+   *
+   * @throws {ValidationError} when `splitPackages` is empty.
+   */
+  async splitMultiPackagesByQuantity(packageId, splitPackages) {
+    if (!Array.isArray(splitPackages) || splitPackages.length === 0) {
+      throw new core.ValidationError({
+        message: "splitMultiPackagesByQuantity: splitPackages must not be empty"
+      });
+    }
+    await this.transport.request({
+      method: "POST",
+      path: `${this.packagePath(packageId)}/split-packages`,
+      body: { splitPackages },
+      rateLimiter: this.limiter
+    });
+  }
+  /**
+   * Change the cargo provider on an existing shipment package. Use one of
+   * Trendyol's documented marketplace cargo codes (`'YKMP'`, `'ARASMP'`,
+   * `'SURATMP'`, etc.) — see `TrendyolCargoProvider` for the full list.
+   */
+  async changeCargoProvider(packageId, cargoProvider) {
+    await this.transport.request({
+      method: "PUT",
+      path: `${this.packagePath(packageId)}/cargo-providers`,
+      body: { cargoProvider },
+      rateLimiter: this.limiter
+    });
+  }
+  /**
+   * Mark a shipment package as manually delivered via its package ID.
+   * Used when the seller delivered the order outside Trendyol's cargo
+   * network and needs to flip the package to `Delivered` after handover.
+   *
+   * No request body; Trendyol responds with 200 + empty body on success.
+   */
+  async manualDeliverByPackageId(packageId) {
+    await this.transport.request({
+      method: "PUT",
+      path: `${this.packagePath(packageId)}/manual-invoice-delivery`,
+      rateLimiter: this.limiter
+    });
+  }
+  /**
+   * Manual-deliver variant that takes the cargo tracking number instead
+   * of the package ID. Useful when you only have the tracking number on
+   * hand (e.g., from a cargo provider webhook).
+   *
+   * Note the path structure: tracking number sits at a sibling location,
+   * not under `/shipment-packages/{id}/...`.
+   */
+  async manualDeliverByTrackingNumber(cargoTrackingNumber) {
+    await this.transport.request({
+      method: "PUT",
+      path: `/integration/order/sellers/${this.sellerId}/shipment-packages/manual-invoice-delivery-by-tracking-number/${encodeURIComponent(String(cargoTrackingNumber))}`,
+      rateLimiter: this.limiter
+    });
+  }
+  /**
+   * Mark a package as delivered through an authorized service ("yetkili
+   * servis"). For appliance / installation-required products that are
+   * delivered + installed by a third-party service partner.
+   */
+  async markDeliveredByService(packageId) {
+    await this.transport.request({
+      method: "PUT",
+      path: `${this.packagePath(packageId)}/delivered-by-service`,
+      rateLimiter: this.limiter
+    });
+  }
+  /**
+   * Update box / packaging metadata on a shipment package (desi value
+   * and/or number of boxes). Either field can be sent alone.
+   */
+  async updateBoxInfo(packageId, input) {
+    await this.transport.request({
+      method: "PUT",
+      path: `${this.packagePath(packageId)}/box-info`,
+      body: input,
+      rateLimiter: this.limiter
+    });
+  }
+  /**
+   * Update labor costs for one or more order lines.
+   *
+   * **Wire note:** Trendyol's request body is a raw array (no envelope),
+   * not `{ items: [...] }`. The SDK forwards `items` verbatim.
+   *
+   * @throws {ValidationError} when `items` is empty.
+   */
+  async updateLaborCosts(packageId, items) {
+    if (!Array.isArray(items) || items.length === 0) {
+      throw new core.ValidationError({ message: "updateLaborCosts: items must not be empty" });
+    }
+    await this.transport.request({
+      method: "PUT",
+      path: `${this.packagePath(packageId)}/labor-costs`,
+      body: items,
+      rateLimiter: this.limiter
+    });
+  }
+  /**
+   * Reassign a shipment package to a different warehouse. `warehouseId`
+   * comes from `client.suppliers.getAddresses()` (filter by `isShipmentAddress`).
+   */
+  async updateWarehouse(packageId, warehouseId) {
+    await this.transport.request({
+      method: "PUT",
+      path: `${this.packagePath(packageId)}/warehouse`,
+      body: { warehouseId },
+      rateLimiter: this.limiter
+    });
+  }
+  /**
+   * Stream variant of `list()`. Trendyol's `getShipmentPackagesStream`
+   * returns the same `ShipmentPackage` shape but paginates with an opaque
+   * cursor — useful when the dataset is large and page-based pagination
+   * would hit the 10 000-record cap.
+   *
+   * @example
+   * ```ts
+   * import { paginate } from '@lonca/core';
+   * for await (const pkg of paginate((p) =>
+   *   client.orders.listStream({ ...p, packageItemStatuses: 'Created,Picking' }),
+   * )) {
+   *   console.log(pkg.id, pkg.status);
+   * }
+   * ```
+   */
+  async listStream(params = {}) {
+    const size = Math.min(params.limit ?? DEFAULT_PAGE_SIZE2, MAX_PAGE_SIZE);
+    const query = { size };
+    if (params.cursor) query.nextCursor = params.cursor;
+    if (params.packageItemStatuses) query.packageItemStatuses = params.packageItemStatuses;
+    if (params.lastModifiedStartDate) {
+      query.lastModifiedStartDate = params.lastModifiedStartDate.getTime();
+    }
+    if (params.lastModifiedEndDate) {
+      query.lastModifiedEndDate = params.lastModifiedEndDate.getTime();
+    }
+    const data = await this.transport.request({
+      method: "GET",
+      path: `/integration/order/sellers/${this.sellerId}/orders/stream`,
+      query,
+      rateLimiter: this.limiter
+    });
+    const items = (data.content ?? []).map(normalizePackage);
+    const result = { items };
+    if (data.hasMore && data.nextCursor) {
+      result.nextCursor = data.nextCursor;
+    }
+    return result;
+  }
+  /**
+   * Fetch the per-parcel cargo-fee breakdown for a single cargo invoice
+   * (Trendyol's `getCargoInvoiceItems`). Useful for reconciling Trendyol's
+   * cargo deductions against your shipped packages.
+   *
+   * `invoiceSerialNumber` is sourced from the Current Account Statement
+   * ("Cari Hesap Ekstresi") with `transactionType=DeductionInvoices`.
+   *
+   * Page-based pagination internally (cursor encodes the page index).
+   */
+  async getCargoInvoiceItems(invoiceSerialNumber, params = {}) {
+    const size = Math.min(params.limit ?? 500, 500);
+    const page = params.cursor ? Number.parseInt(params.cursor, 10) : 0;
+    const data = await this.transport.request({
+      method: "GET",
+      path: `/integration/finance/che/sellers/${this.sellerId}/cargo-invoice/${encodeURIComponent(invoiceSerialNumber)}/items`,
+      query: { page, size },
+      rateLimiter: this.limiter
+    });
+    const items = (data.content ?? []).map((row) => {
+      const out = { raw: row };
+      if (row.shipmentPackageType !== void 0) out.shipmentPackageType = row.shipmentPackageType;
+      if (row.parcelUniqueId !== void 0) {
+        out.parcelUniqueId = typeof row.parcelUniqueId === "string" ? row.parcelUniqueId : String(row.parcelUniqueId);
+      }
+      if (row.orderNumber !== void 0) out.orderNumber = row.orderNumber;
+      if (typeof row.amount === "number") out.amount = row.amount;
+      if (typeof row.desi === "number") out.desi = row.desi;
+      return out;
+    });
+    const totalPages = typeof data.totalPages === "number" ? data.totalPages : 0;
+    const result = { items };
+    if (page + 1 < totalPages) {
+      result.nextCursor = String(page + 1);
+    }
+    return result;
+  }
+  packagePath(packageId) {
+    return `/integration/order/sellers/${this.sellerId}/shipment-packages/${encodeURIComponent(String(packageId))}`;
+  }
 };
 var DEFAULT_PAGE_SIZE3 = 50;
 var MAX_PAGE_SIZE2 = 1e3;
+var MAX_BUYBOX_BARCODES = 10;
 function normalizeRef(ref) {
   return {
     id: ref?.id !== void 0 ? String(ref.id) : "",
@@ -427,6 +873,82 @@ function normalizeProduct(node) {
   if (node.lastModifiedBy !== void 0) out.lastModifiedBy = node.lastModifiedBy;
   return out;
 }
+function normalizeUnapprovedRejectReason(r) {
+  const out = {};
+  if (r.rejectReason !== void 0) out.rejectReason = r.rejectReason;
+  if (r.rejectReasonDetail !== void 0) out.rejectReasonDetail = r.rejectReasonDetail;
+  return out;
+}
+function normalizeUnapproved(node) {
+  const imagesSource = node.images ?? node.media;
+  const out = {
+    productMainId: node.productMainId ?? "",
+    brand: normalizeRef(node.brand),
+    category: normalizeRef(node.category),
+    barcode: node.barcode ?? "",
+    title: node.title ?? "",
+    images: normalizeImages(imagesSource),
+    attributes: (node.attributes ?? []).map(normalizeAttribute2),
+    rejectReasonDetails: (node.rejectReasonDetails ?? []).map(normalizeUnapprovedRejectReason),
+    raw: node
+  };
+  if (node.supplierId !== void 0) out.supplierId = String(node.supplierId);
+  if (node.status !== void 0) out.status = node.status;
+  if (node.description !== void 0) out.description = node.description;
+  if (typeof node.quantity === "number") out.quantity = node.quantity;
+  if (typeof node.listPrice === "number") out.listPrice = node.listPrice;
+  if (typeof node.salePrice === "number") out.salePrice = node.salePrice;
+  if (typeof node.vatRate === "number") out.vatRate = node.vatRate;
+  if (node.dimensionalWeight !== void 0 && node.dimensionalWeight !== null) {
+    out.dimensionalWeight = node.dimensionalWeight;
+  }
+  if (node.stockCode !== void 0) out.stockCode = node.stockCode;
+  if (node.origin !== void 0) out.origin = node.origin;
+  if (node.locationBasedDelivery !== void 0) {
+    out.locationBasedDelivery = node.locationBasedDelivery;
+  }
+  if (node.lotNumber !== void 0) out.lotNumber = node.lotNumber;
+  if (node.specialConsumptionTax !== void 0) {
+    out.specialConsumptionTax = node.specialConsumptionTax;
+  }
+  if (node.sgrPrice !== void 0) out.sgrPrice = node.sgrPrice;
+  const createdAt = toIso2(node.createDateTime);
+  if (createdAt) out.createdAt = createdAt;
+  const updatedAt = toIso2(node.lastUpdateDate);
+  if (updatedAt) out.updatedAt = updatedAt;
+  const priceChanged = toIso2(node.lastPriceChangeDate);
+  if (priceChanged) out.lastPriceChangedAt = priceChanged;
+  const stockChanged = toIso2(node.lastStockChangeDate);
+  if (stockChanged) out.lastStockChangedAt = stockChanged;
+  return out;
+}
+function normalizeBuyboxInfo(node) {
+  const out = {
+    barcode: node.barcode ?? "",
+    raw: node
+  };
+  if (typeof node.buyboxOrder === "number") out.buyboxOrder = node.buyboxOrder;
+  if (typeof node.buyboxPrice === "number") out.buyboxPrice = node.buyboxPrice;
+  if (typeof node.hasMultipleSeller === "boolean") {
+    out.hasMultipleSeller = node.hasMultipleSeller;
+  }
+  if (node.secondBuyboxPrice !== void 0) out.secondBuyboxPrice = node.secondBuyboxPrice;
+  if (node.thirdBuyboxPrice !== void 0) out.thirdBuyboxPrice = node.thirdBuyboxPrice;
+  return out;
+}
+function normalizeProductBase(data) {
+  const out = {
+    barcode: data.barcode ?? "",
+    approved: !!data.approved,
+    archived: !!data.archived,
+    raw: data
+  };
+  const approvedAt = toIso2(data.approvedDate);
+  if (approvedAt) out.approvedAt = approvedAt;
+  if (data.listingId !== void 0) out.listingId = data.listingId;
+  if (data.contentId !== void 0) out.contentId = String(data.contentId);
+  return out;
+}
 function normalizeBatchResult(data) {
   const items = (data.items ?? []).map((item) => {
     const result = {};
@@ -454,17 +976,52 @@ function normalizeBatchResult(data) {
   if (data.storeFrontCode !== void 0) out.storeFrontCode = data.storeFrontCode;
   return out;
 }
+var MAX_WRITE_ITEMS = 1e3;
+var DELETE_RATE_PER_MIN = 100;
 var ProductsResource = class {
   constructor(transport, sellerId, options = {}) {
     this.transport = transport;
     this.sellerId = sellerId;
     this.filterLimiter = options.filterLimiter ?? new core.TokenBucketRateLimiter({ capacity: 2e3, intervalMs: 6e4 });
     this.batchLimiter = options.batchLimiter ?? new core.TokenBucketRateLimiter({ capacity: 1e3, intervalMs: 6e4 });
+    this.buyboxLimiter = options.buyboxLimiter ?? new core.TokenBucketRateLimiter({ capacity: 1e3, intervalMs: 6e4 });
+    this.writeLimiter = options.writeLimiter ?? new core.TokenBucketRateLimiter({ capacity: 1e3, intervalMs: 6e4 });
+    this.deleteLimiter = options.deleteLimiter ?? new core.TokenBucketRateLimiter({ capacity: DELETE_RATE_PER_MIN, intervalMs: 6e4 });
   }
   transport;
   sellerId;
   filterLimiter;
   batchLimiter;
+  buyboxLimiter;
+  writeLimiter;
+  deleteLimiter;
+  validateBarcodes(barcodes, methodLabel) {
+    if (!Array.isArray(barcodes) || barcodes.length === 0) {
+      throw new core.ValidationError({ message: `${methodLabel}: barcodes must not be empty` });
+    }
+    if (barcodes.length > MAX_WRITE_ITEMS) {
+      throw new core.ValidationError({
+        message: `${methodLabel}: max ${MAX_WRITE_ITEMS} barcodes per call (got ${barcodes.length})`
+      });
+    }
+  }
+  async submitWrite(endpoint, items, methodLabel) {
+    if (!Array.isArray(items) || items.length === 0) {
+      throw new core.ValidationError({ message: `${methodLabel}: items must not be empty` });
+    }
+    if (items.length > MAX_WRITE_ITEMS) {
+      throw new core.ValidationError({
+        message: `${methodLabel}: max ${MAX_WRITE_ITEMS} items per call (got ${items.length})`
+      });
+    }
+    const data = await this.transport.request({
+      method: "POST",
+      path: `/integration/product/sellers/${this.sellerId}${endpoint}`,
+      body: { items },
+      rateLimiter: this.writeLimiter
+    });
+    return { batchRequestId: data?.batchRequestId ?? "" };
+  }
   /**
    * List approved products. Use `paginate()` from `@lonca/core` to iterate
    * lazily across pages.
@@ -526,6 +1083,235 @@ var ProductsResource = class {
     });
     return normalizeBatchResult(data);
   }
+  /**
+   * List **unapproved** (draft / rejected / pending-review) products.
+   *
+   * Wire shape is intentionally flatter than the approved-product shape:
+   * each barcode is one top-level item with `barcode`, `quantity`, `salePrice`
+   * etc. at the root. Rejected drafts carry `rejectReasonDetails` so you can
+   * surface why Trendyol's content team turned them down.
+   *
+   * Pagination follows the same convention as `list()`: `cursor` from the
+   * previous response forwards as `nextPageToken`.
+   *
+   * @example
+   * ```ts
+   * const page = await client.products.listUnapproved({ limit: 50 });
+   * for (const draft of page.items) {
+   *   if (draft.status === 'rejected') {
+   *     console.warn(draft.barcode, draft.rejectReasonDetails);
+   *   }
+   * }
+   * ```
+   */
+  async listUnapproved(params = {}) {
+    const size = Math.min(params.limit ?? DEFAULT_PAGE_SIZE3, MAX_PAGE_SIZE2);
+    const query = { size };
+    if (params.cursor) {
+      query.nextPageToken = params.cursor;
+    } else {
+      query.page = 0;
+    }
+    if (params.barcode) query.barcode = params.barcode;
+    if (params.startDate) query.startDate = params.startDate.getTime();
+    if (params.endDate) query.endDate = params.endDate.getTime();
+    if (params.dateQueryType) query.dateQueryType = params.dateQueryType;
+    if (params.supplierId !== void 0) query.supplierId = params.supplierId;
+    const data = await this.transport.request({
+      method: "GET",
+      path: `/integration/product/sellers/${this.sellerId}/products/unapproved`,
+      query,
+      rateLimiter: this.filterLimiter
+    });
+    const items = (data.content ?? []).map(normalizeUnapproved);
+    const page = { items };
+    if (data.nextPageToken) {
+      page.nextCursor = data.nextPageToken;
+    }
+    return page;
+  }
+  /**
+   * Fetch the basic lifecycle status of a single product by barcode.
+   *
+   * Cheap and useful as a polling primitive after `createProducts`: poll
+   * this endpoint until `approved` flips to `true` (or use
+   * `client.products.getBatchStatus()` to track the originating batch).
+   *
+   * @param barcode The product barcode to look up.
+   */
+  async getBase(barcode) {
+    const code = encodeURIComponent(barcode);
+    const data = await this.transport.request({
+      method: "GET",
+      path: `/integration/product/sellers/${this.sellerId}/product/${code}`,
+      rateLimiter: this.filterLimiter
+    });
+    return normalizeProductBase(data);
+  }
+  /**
+   * Fetch buybox information for up to 10 barcodes in one call.
+   *
+   * Returns rank (`buyboxOrder === 1` means you hold the buybox), the
+   * current buybox price, and — beyond the spec — the second and third
+   * competing prices when other sellers are present.
+   *
+   * @param barcodes 1–10 product barcodes.
+   * @throws {ValidationError} when `barcodes` is empty or longer than 10.
+   */
+  async getBuyboxInfo(barcodes) {
+    if (!Array.isArray(barcodes) || barcodes.length === 0) {
+      throw new core.ValidationError({
+        message: "getBuyboxInfo: barcodes must be a non-empty array"
+      });
+    }
+    if (barcodes.length > MAX_BUYBOX_BARCODES) {
+      throw new core.ValidationError({
+        message: `getBuyboxInfo: max ${MAX_BUYBOX_BARCODES} barcodes per call (got ${barcodes.length})`
+      });
+    }
+    const data = await this.transport.request({
+      method: "POST",
+      path: `/integration/product/sellers/${this.sellerId}/products/buybox-information`,
+      body: { barcodes },
+      rateLimiter: this.buyboxLimiter
+    });
+    const list = data.buyboxInfo ?? data.content ?? [];
+    return list.map(normalizeBuyboxInfo);
+  }
+  /**
+   * Create products (V2). Async batch — returns a `batchRequestId` you can
+   * poll with `getBatchStatus`. Max 1000 items per call.
+   *
+   * Trendyol requires the full V2 attribute payload — fetch via
+   * `categories.getAttributes` (and `categories.getAttributeValues` for
+   * values when `allowCustom === false`). Shipment / returning warehouse
+   * IDs come from `suppliers.getAddresses`.
+   *
+   * @throws {ValidationError} when `items` is empty or longer than 1000.
+   */
+  async create(items) {
+    return this.submitWrite("/v2/products", items, "createProducts");
+  }
+  /**
+   * Update **content** of approved products (title, description, images,
+   * attributes). Identified by `contentId`. Partial update is supported
+   * except for attributes — if you update ANY attribute, send ALL of them.
+   *
+   * @throws {ValidationError} when `items` is empty or longer than 1000.
+   */
+  async updateContent(items) {
+    return this.submitWrite("/products/content-bulk-update", items, "updateContent");
+  }
+  /**
+   * Update **variant** fields of approved products (stockCode, vatRate,
+   * dimensionalWeight, warehouse IDs, location-based delivery, lot). Identified
+   * by `barcode`. The barcode itself cannot be changed via this endpoint.
+   *
+   * @throws {ValidationError} when `items` is empty or longer than 1000.
+   */
+  async updateVariants(items) {
+    return this.submitWrite("/products/variant-bulk-update", items, "updateVariants");
+  }
+  /**
+   * Update **unapproved** (draft) products. Identified by `barcode`. All
+   * other fields are optional partial updates. Use this to fix drafts that
+   * Trendyol rejected — `client.products.listUnapproved` surfaces the
+   * `rejectReasonDetails` you need to act on.
+   *
+   * **Gotcha (verified live STAGE 2026-05-25):** Trendyol's V2 spec claims
+   * only `barcode` is required, but the endpoint returns HTTP 500
+   * (`TrendyolSystemException` / `TypeError`) when too many optional fields
+   * are omitted. In practice, send at least `title`, `description`,
+   * `productMainId`, `brandId`, `categoryId`, `stockCode`,
+   * `dimensionalWeight`, `vatRate`, `images[]`, and `attributes[]` (an
+   * empty array is OK for the latter). The SDK forwards your payload
+   * as-is; trim fields only if you have verified the server accepts it.
+   *
+   * @throws {ValidationError} when `items` is empty or longer than 1000.
+   */
+  async updateUnapproved(items) {
+    return this.submitWrite("/products/unapproved-bulk-update", items, "updateUnapproved");
+  }
+  /**
+   * Update product **delivery information** (deliveryDuration,
+   * fastDeliveryType). Identified by `barcode`.
+   *
+   * @throws {ValidationError} when `items` is empty or longer than 1000.
+   */
+  async updateDeliveryInfo(items) {
+    return this.submitWrite("/products/delivery-info-bulk-update", items, "updateDeliveryInfo");
+  }
+  /**
+   * Delete products by barcode. Trendyol allows deletion of unapproved
+   * products and approved products that have been archived for more than a
+   * day (and have not been sales-stopped by Trendyol).
+   *
+   * Async batch — returns `{ batchRequestId }` to poll via `getBatchStatus`.
+   * Separately rate-limited at **100 req/min** (much tighter than create/update).
+   *
+   * @param barcodes 1–1000 barcodes.
+   * @throws {ValidationError} when `barcodes` is empty or longer than 1000.
+   */
+  async delete(barcodes) {
+    this.validateBarcodes(barcodes, "delete");
+    const data = await this.transport.request({
+      method: "DELETE",
+      path: `/integration/product/sellers/${this.sellerId}/products`,
+      body: { items: barcodes.map((barcode) => ({ barcode })) },
+      rateLimiter: this.deleteLimiter
+    });
+    return { batchRequestId: data?.batchRequestId ?? "" };
+  }
+  /**
+   * Archive products by barcode (Trendyol's `archived=true` state).
+   * Archived products are not visible to customers; pair with `delete`
+   * after the 24-hour archive cool-down to remove them entirely.
+   *
+   * Async batch — returns `{ batchRequestId }`.
+   *
+   * @throws {ValidationError} when `barcodes` is empty or longer than 1000.
+   */
+  async archive(barcodes) {
+    return this.setArchivedState(barcodes, true, "archive");
+  }
+  /**
+   * Unarchive products by barcode (Trendyol's `archived=false` state).
+   * Restores visibility for previously-archived products.
+   *
+   * @throws {ValidationError} when `barcodes` is empty or longer than 1000.
+   */
+  async unarchive(barcodes) {
+    return this.setArchivedState(barcodes, false, "unarchive");
+  }
+  async setArchivedState(barcodes, archived, methodLabel) {
+    this.validateBarcodes(barcodes, methodLabel);
+    const data = await this.transport.request({
+      method: "PUT",
+      path: `/integration/product/sellers/${this.sellerId}/products/archive-state`,
+      body: { items: barcodes.map((barcode) => ({ barcode, archived })) },
+      rateLimiter: this.writeLimiter
+    });
+    return { batchRequestId: data?.batchRequestId ?? "" };
+  }
+  /**
+   * Unlock products whose sale was paused by Trendyol due to pricing
+   * issues (under/over-pricing, critical price error, supplier issues).
+   * Restores selling status for the listed barcodes.
+   *
+   * Async batch — returns `{ batchRequestId }`.
+   *
+   * @throws {ValidationError} when `barcodes` is empty or longer than 1000.
+   */
+  async unlock(barcodes) {
+    this.validateBarcodes(barcodes, "unlock");
+    const data = await this.transport.request({
+      method: "PUT",
+      path: `/integration/product/sellers/${this.sellerId}/products/unlock`,
+      body: { items: barcodes.map((barcode) => ({ barcode })) },
+      rateLimiter: this.writeLimiter
+    });
+    return { batchRequestId: data?.batchRequestId ?? "" };
+  }
 };
 var VALID_TYPES = /* @__PURE__ */ new Set([
   "SHIPMENT",
@@ -810,7 +1596,7 @@ function createTrendyolClient(opts) {
   });
   return {
     brands: new BrandsResource(transport),
-    categories: new CategoriesResource(transport),
+    categories: new CategoriesResource(transport, void 0, opts.sellerId),
     suppliers: new SuppliersResource(transport, opts.sellerId),
     products: new ProductsResource(transport, opts.sellerId),
     inventory: new InventoryResource(transport, opts.sellerId),