@lonca/trendyol 0.8.0 → 0.10.0

package/dist/testing.js

@@ -0,0 +1,2917 @@
+import { noopLogger, retry, TimeoutError, NetworkError, LoncaError, ServerError, RateLimitError, NotFoundError, ValidationError, AuthError, TokenBucketRateLimiter } from '@lonca/core';
+import { randomUUID } from 'crypto';
+
+// src/resources/brands.ts
+var DEFAULT_PAGE_SIZE = 1e3;
+var BrandsResource = class {
+  constructor(transport, limiter) {
+    this.transport = transport;
+    this.limiter = limiter ?? new TokenBucketRateLimiter({ capacity: 50, intervalMs: 6e4 });
+  }
+  transport;
+  limiter;
+  /**
+   * List Trendyol brands, one page at a time.
+   *
+   * @example
+   * ```ts
+   * import { paginate } from '@lonca/core';
+   * for await (const brand of paginate((p) => client.brands.list(p))) {
+   *   console.log(brand.id, brand.name);
+   * }
+   * ```
+   */
+  async list(params = {}) {
+    const page = params.cursor ? Number.parseInt(params.cursor, 10) : 0;
+    const size = params.limit ?? DEFAULT_PAGE_SIZE;
+    const data = await this.transport.request({
+      method: "GET",
+      path: "/integration/product/brands",
+      query: { page, size },
+      rateLimiter: this.limiter
+    });
+    const items = data.brands.map((b) => ({ id: String(b.id), name: b.name }));
+    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 {
+    id: String(node.id),
+    name: node.name,
+    parentId: node.parentId === null || node.parentId === void 0 ? null : String(node.parentId),
+    subCategories: (node.subCategories ?? []).map(normalizeCategory)
+  };
+}
+function normalizeAttribute(node) {
+  const attr = node.attribute ?? { id: 0, name: "" };
+  const rawValues = node.attributeValues ?? [];
+  const out = {
+    id: String(attr.id),
+    name: attr.name,
+    required: !!node.required,
+    allowCustom: !!node.allowCustom,
+    varianter: !!node.varianter,
+    slicer: !!node.slicer,
+    values: rawValues.map((v) => ({ id: String(v.id), name: v.name }))
+  };
+  if (node.categoryId !== void 0) {
+    out.categoryId = String(node.categoryId);
+  }
+  if (node.allowMultipleAttributeValues !== void 0) {
+    out.allowMultipleAttributeValues = node.allowMultipleAttributeValues;
+  }
+  return out;
+}
+var MAX_ATTR_VALUES_PAGE_SIZE = 1e3;
+var DEFAULT_ATTR_VALUES_PAGE_SIZE = 100;
+var CategoriesResource = class {
+  constructor(transport, limiter) {
+    this.transport = transport;
+    this.limiter = limiter ?? new TokenBucketRateLimiter({ capacity: 50, intervalMs: 6e4 });
+  }
+  transport;
+  limiter;
+  /**
+   * Fetch the full Trendyol category tree.
+   *
+   * Trendyol returns the entire tree in one response — there is no pagination.
+   * Cache the result aggressively in your application; the tree changes rarely.
+   */
+  async list() {
+    const data = await this.transport.request({
+      method: "GET",
+      path: "/integration/product/product-categories",
+      rateLimiter: this.limiter
+    });
+    const list = Array.isArray(data) ? data : data.categories;
+    return list.map(normalizeCategory);
+  }
+  /**
+   * Fetch the attributes (required and optional) for a single category.
+   *
+   * Call this before `createProduct V2` so you know which attributes are
+   * mandatory — the API rejects products that omit any `required` attribute.
+   *
+   * @param categoryId Trendyol numeric category ID; accepts `string` or `number`.
+   */
+  async getAttributes(categoryId) {
+    const id = encodeURIComponent(String(categoryId));
+    const data = await this.transport.request({
+      method: "GET",
+      path: `/integration/product/categories/${id}/attributes`,
+      rateLimiter: this.limiter
+    });
+    const list = extractAttributeList(data);
+    if (!list) {
+      console.error(
+        "[@lonca/trendyol] getCategoryAttributes: unexpected response shape:",
+        JSON.stringify(data).slice(0, 800)
+      );
+      return [];
+    }
+    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.
+   */
+  async getByBarcodes(barcodes) {
+    if (!Array.isArray(barcodes) || barcodes.length === 0) {
+      throw new ValidationError({ message: "getByBarcodes: barcodes must not be empty" });
+    }
+    const data = await this.transport.request({
+      method: "POST",
+      path: `/integration/ecgw/v1/${this.transport.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;
+  if (data && typeof data === "object") {
+    const obj = data;
+    if (Array.isArray(obj.categoryAttributes)) {
+      return obj.categoryAttributes;
+    }
+    if (Array.isArray(obj.attributes)) {
+      return obj.attributes;
+    }
+  }
+  return null;
+}
+function toIso(epochMs) {
+  if (typeof epochMs !== "number" || !Number.isFinite(epochMs) || epochMs === 0) {
+    return void 0;
+  }
+  return new Date(epochMs).toISOString();
+}
+function normalizeClaim(node) {
+  const out = {
+    id: node.id ?? node.claimId ?? "",
+    orderNumber: node.orderNumber ?? "",
+    raw: node
+  };
+  const orderDate = toIso(node.orderDate);
+  if (orderDate) out.orderDate = orderDate;
+  const claimDate = toIso(node.claimDate);
+  if (claimDate) out.claimDate = claimDate;
+  if (node.customerFirstName !== void 0) out.customerFirstName = node.customerFirstName;
+  if (node.customerLastName !== void 0) out.customerLastName = node.customerLastName;
+  return out;
+}
+var ClaimsResource = class {
+  constructor(transport, limiter) {
+    this.transport = transport;
+    this.limiter = limiter ?? new TokenBucketRateLimiter({ capacity: 1e3, intervalMs: 6e4 });
+  }
+  transport;
+  limiter;
+  /**
+   * Create a return claim against an order. Use this to file a return on
+   * behalf of a customer (e.g. when they called your CS line). For
+   * customer-initiated returns coming from trendyol.com, you receive them
+   * via `claims.list()` — no need to call `create`.
+   *
+   * Returns whatever Trendyol returns (typically the new claim's identifier).
+   *
+   * @throws {ValidationError} when `claimItems` is empty.
+   */
+  async create(input) {
+    if (!Array.isArray(input?.claimItems) || input.claimItems.length === 0) {
+      throw new ValidationError({ message: "claims.create: claimItems must not be empty" });
+    }
+    return this.transport.request({
+      method: "POST",
+      path: `/integration/order/sellers/${this.transport.sellerId}/claims/create`,
+      body: input,
+      rateLimiter: this.limiter
+    });
+  }
+  /**
+   * File a seller-side rejection ("ret talebi") against a customer claim.
+   *
+   * **Wire format: `multipart/form-data`** — the SDK builds the FormData
+   * internally from the typed input. `claimItemIdList` is joined with
+   * commas (Trendyol expects a single comma-separated string field).
+   * Attach supporting docs (PDF / JPEG) via `files: [Blob, ...]`.
+   */
+  async createIssue(claimId, input) {
+    if (!Array.isArray(input?.claimItemIdList) || input.claimItemIdList.length === 0) {
+      throw new ValidationError({
+        message: "claims.createIssue: claimItemIdList must not be empty"
+      });
+    }
+    if (typeof input.description !== "string" || input.description.length === 0) {
+      throw new ValidationError({ message: "claims.createIssue: description is required" });
+    }
+    if (input.description.length > 500) {
+      throw new ValidationError({
+        message: `claims.createIssue: description must be \u2264500 chars (got ${input.description.length})`
+      });
+    }
+    const form = new FormData();
+    form.append("claimIssueReasonId", String(input.claimIssueReasonId));
+    form.append("claimItemIdList", input.claimItemIdList.join(","));
+    form.append("description", input.description);
+    if (input.files) {
+      for (const file of input.files) {
+        form.append("files", file);
+      }
+    }
+    return this.transport.request({
+      method: "POST",
+      path: `/integration/order/sellers/${this.transport.sellerId}/claims/${encodeURIComponent(claimId)}/issue`,
+      body: form,
+      rateLimiter: this.limiter
+    });
+  }
+  /**
+   * Approve specific claim line items. After approval, Trendyol moves
+   * those line items into the post-approval refund / return-shipping flow.
+   *
+   * @throws {ValidationError} when `claimLineItemIdList` is empty.
+   */
+  async approveLineItems(claimId, input) {
+    if (!Array.isArray(input?.claimLineItemIdList) || input.claimLineItemIdList.length === 0) {
+      throw new ValidationError({
+        message: "claims.approveLineItems: claimLineItemIdList must not be empty"
+      });
+    }
+    return this.transport.request({
+      method: "PUT",
+      path: `/integration/order/sellers/${this.transport.sellerId}/claims/${encodeURIComponent(claimId)}/items/approve`,
+      body: input,
+      rateLimiter: this.limiter
+    });
+  }
+  /**
+   * List claims (page-based; SDK exposes opaque cursor convention).
+   *
+   * @example
+   * ```ts
+   * import { paginate } from '@lonca/core';
+   * for await (const c of paginate((p) =>
+   *   client.claims.list({ ...p, claimItemStatus: 'WaitingInAction' }),
+   * )) {
+   *   console.log(c.id, c.orderNumber, c.claimDate);
+   * }
+   * ```
+   */
+  async list(params = {}) {
+    const size = Math.min(params.limit ?? 50, 200);
+    const page = params.cursor ? Number.parseInt(params.cursor, 10) : 0;
+    const query = { page, size };
+    if (params.startDate) query.startDate = params.startDate.getTime();
+    if (params.endDate) query.endDate = params.endDate.getTime();
+    if (params.claimItemStatus) query.claimItemStatus = params.claimItemStatus;
+    const data = await this.transport.request({
+      method: "GET",
+      path: `/integration/order/sellers/${this.transport.sellerId}/claims`,
+      query,
+      rateLimiter: this.limiter
+    });
+    const items = (data.content ?? []).map(normalizeClaim);
+    const result = { items };
+    const totalPages = typeof data.totalPages === "number" ? data.totalPages : 0;
+    if (page + 1 < totalPages) {
+      result.nextCursor = String(page + 1);
+    }
+    return result;
+  }
+  /**
+   * Fetch the catalog of rejection-reason IDs the seller can use on
+   * `claims.createIssue()`. Cache the result — it changes rarely.
+   *
+   * Note: this endpoint is **not seller-scoped** (no `sellerId` in path).
+   */
+  async getIssueReasons() {
+    const data = await this.transport.request({
+      method: "GET",
+      path: `/integration/order/claim-issue-reasons`,
+      rateLimiter: this.limiter
+    });
+    return (data ?? []).map((r) => ({
+      id: typeof r.id === "number" ? r.id : 0,
+      name: r.name ?? ""
+    }));
+  }
+  /**
+   * Fetch the audit log for a single claim item (state transitions,
+   * actor, timestamp). Trendyol's response shape varies — the SDK
+   * surfaces each row as `{ raw }` and leaves field extraction to the
+   * caller until we observe a stable shape on the wire.
+   */
+  async getItemAudits(claimItemId) {
+    const data = await this.transport.request({
+      method: "GET",
+      path: `/integration/order/sellers/${this.transport.sellerId}/claims/items/${encodeURIComponent(claimItemId)}/audit`,
+      rateLimiter: this.limiter
+    });
+    const rows = Array.isArray(data) ? data : Array.isArray(data?.content) ? data.content : [];
+    return rows.map((row) => ({ raw: row }));
+  }
+};
+var MAX_BATCH_ITEMS = 5e3;
+var ExportCenterResource = class {
+  constructor(transport, limiter) {
+    this.transport = transport;
+    this.limiter = limiter ?? new TokenBucketRateLimiter({ capacity: 1e3, intervalMs: 6e4 });
+  }
+  transport;
+  limiter;
+  // ─── Products ────────────────────────────────────────────────────────────
+  /**
+   * List Export Center-approved products. Uses Trendyol's `pageKey`
+   * pagination — the first call leaves `pageKey` empty; subsequent
+   * calls pass the `x-paging-key` value from the previous response.
+   */
+  async listProducts(params = {}) {
+    const query = {};
+    if (params.barcodes && params.barcodes.length > 0) query.barcodes = params.barcodes.join(",");
+    if (params.pageKey) query.pageKey = params.pageKey;
+    if (params.size !== void 0) query.size = params.size;
+    const data = await this.transport.request({
+      method: "GET",
+      path: `/integration/ecgw/v2/${this.transport.sellerId}/products`,
+      query: Object.keys(query).length ? query : void 0,
+      rateLimiter: this.limiter
+    });
+    const rows = pickArray(data);
+    return rows.map((r) => ({ raw: r ?? {} }));
+  }
+  /**
+   * Create Export Center products. Maximum 5000 per call. Returns a
+   * `batchId` you can poll via `getBatchStatus(batchId)`.
+   *
+   * @throws {ValidationError} when `products` is empty / oversized.
+   */
+  async createProducts(products) {
+    this.assertBatch(products, "createProducts");
+    const data = await this.transport.request({
+      method: "POST",
+      path: `/integration/ecgw/v2/${this.transport.sellerId}/products`,
+      body: { products },
+      rateLimiter: this.limiter
+    });
+    return normalizeBatchResponse(data);
+  }
+  /**
+   * Update Export Center prices. **Trendyol allows one price update per
+   * barcode per day.** Returns a `batchId`.
+   *
+   * @throws {ValidationError} when `priceInfos` is empty / oversized.
+   */
+  async updatePrices(priceInfos) {
+    this.assertBatch(priceInfos, "updatePrices");
+    const data = await this.transport.request({
+      method: "POST",
+      path: `/integration/ecgw/v1/${this.transport.sellerId}/prices`,
+      body: { priceInfos },
+      rateLimiter: this.limiter
+    });
+    return normalizeBatchResponse(data);
+  }
+  /**
+   * Update Export Center stocks. Returns a `batchId`. Sellers using
+   * Trendyol's shared inventory cannot use this endpoint (per portal docs).
+   *
+   * @throws {ValidationError} when `items` is empty / oversized.
+   */
+  async updateStocks(items) {
+    this.assertBatch(items, "updateStocks");
+    const data = await this.transport.request({
+      method: "POST",
+      path: `/integration/ecgw/v1/${this.transport.sellerId}/stocks`,
+      body: { items },
+      rateLimiter: this.limiter
+    });
+    return normalizeBatchResponse(data);
+  }
+  // ─── Batch status ────────────────────────────────────────────────────────
+  /**
+   * Look up the status of a previously-submitted batch. Trendyol retains
+   * batch records for **24 hours** only — older `batchId`s return `404`.
+   */
+  async getBatchStatus(batchId) {
+    if (!batchId) {
+      throw new ValidationError({ message: "exportCenter.getBatchStatus: batchId is required" });
+    }
+    const data = await this.transport.request({
+      method: "GET",
+      path: `/integration/ecgw/v1/${this.transport.sellerId}/check-status`,
+      query: { batchId },
+      rateLimiter: this.limiter
+    });
+    return normalizeBatchStatus(data);
+  }
+  // ─── Packages ────────────────────────────────────────────────────────────
+  /** List daily Export Center packages (V2 — query-based filters). */
+  async listPackagesV2(params = {}) {
+    const data = await this.transport.request({
+      method: "GET",
+      path: `/integration/ecgw/v2/${this.transport.sellerId}/packages`,
+      query: {
+        trackingNumber: params.trackingNumber,
+        status: params.status,
+        creationStartDate: params.creationStartDate,
+        creationEndDate: params.creationEndDate,
+        size: params.size,
+        boutiqueId: params.boutiqueId
+      },
+      rateLimiter: this.limiter
+    });
+    return pickArray(data).map(normalizePackage);
+  }
+  /** List Export Center packages (V3 — consolidated, page-based). */
+  async listPackagesV3(params = {}) {
+    const data = await this.transport.request({
+      method: "GET",
+      path: `/integration/ecgw/v3/${this.transport.sellerId}/packages`,
+      query: {
+        status: params.status,
+        page: params.offset !== void 0 ? params.offset : void 0,
+        size: params.limit,
+        creationStartDate: params.creationStartDate,
+        creationEndDate: params.creationEndDate
+      },
+      rateLimiter: this.limiter
+    });
+    return pickArray(data).map(normalizePackage);
+  }
+  /** Get the line items inside an Export Center package. */
+  async getPackageItems(params) {
+    if (!params || !params.packageId) {
+      throw new ValidationError({
+        message: "exportCenter.getPackageItems: packageId is required"
+      });
+    }
+    const data = await this.transport.request({
+      method: "GET",
+      path: `/integration/ecgw/v2/${this.transport.sellerId}/packages/items`,
+      query: {
+        packageId: params.packageId,
+        status: params.status,
+        page: params.offset,
+        size: params.limit
+      },
+      rateLimiter: this.limiter
+    });
+    return pickArray(data).map((r) => ({ raw: r ?? {} }));
+  }
+  // ─── Lookup ──────────────────────────────────────────────────────────────
+  /** Get the required attributes for an Export Center category. */
+  async getCategoryAttributes(categoryId) {
+    if (categoryId === void 0 || categoryId === null || categoryId === "") {
+      throw new ValidationError({
+        message: "exportCenter.getCategoryAttributes: categoryId is required"
+      });
+    }
+    const data = await this.transport.request({
+      method: "GET",
+      path: `/integration/ecgw/v1/${this.transport.sellerId}/lookup/product-categories/${encodeURIComponent(String(categoryId))}/attributes`,
+      rateLimiter: this.limiter
+    });
+    return pickArray(data).map((r) => {
+      const row = r ?? {};
+      const out = { raw: row };
+      if (typeof row.attributeId === "number" || typeof row.attributeId === "string") {
+        out.attributeId = row.attributeId;
+      }
+      if (typeof row.attributeName === "string") out.attributeName = row.attributeName;
+      if (typeof row.required === "boolean") out.required = row.required;
+      if (Array.isArray(row.values)) out.values = row.values;
+      return out;
+    });
+  }
+  /** Get the care-instruction lookup values used by `createProducts`. */
+  async getCareInstructions() {
+    const data = await this.transport.request({
+      method: "GET",
+      path: `/integration/ecgw/v1/${this.transport.sellerId}/lookup/care-instructions`,
+      rateLimiter: this.limiter
+    });
+    return pickArray(data).map(normalizeNamedRef);
+  }
+  /** Get the material-composition lookup values used by `createProducts`. */
+  async getCompositions() {
+    const data = await this.transport.request({
+      method: "GET",
+      path: `/integration/ecgw/v1/${this.transport.sellerId}/lookup/compositions`,
+      rateLimiter: this.limiter
+    });
+    return pickArray(data).map(normalizeNamedRef);
+  }
+  /** Get the country-of-origin lookup values used by `createProducts`. */
+  async getOrigins() {
+    const data = await this.transport.request({
+      method: "GET",
+      path: `/integration/ecgw/v1/${this.transport.sellerId}/lookup/origins`,
+      rateLimiter: this.limiter
+    });
+    return pickArray(data).map((r) => {
+      const row = r ?? {};
+      const out = { raw: row };
+      if (typeof row.id === "number" || typeof row.id === "string") out.id = row.id;
+      if (typeof row.name === "string") out.name = row.name;
+      if (typeof row.countryCode === "string") out.countryCode = row.countryCode;
+      return out;
+    });
+  }
+  // ─── Helpers ─────────────────────────────────────────────────────────────
+  assertBatch(items, methodLabel) {
+    if (!Array.isArray(items) || items.length === 0) {
+      throw new ValidationError({
+        message: `exportCenter.${methodLabel}: items must not be empty`
+      });
+    }
+    if (items.length > MAX_BATCH_ITEMS) {
+      throw new ValidationError({
+        message: `exportCenter.${methodLabel}: max ${MAX_BATCH_ITEMS} items per call (got ${items.length})`
+      });
+    }
+  }
+};
+function pickArray(data) {
+  if (Array.isArray(data)) return data;
+  if (data && typeof data === "object") {
+    const obj = data;
+    if (Array.isArray(obj.content)) return obj.content;
+    if (Array.isArray(obj.items)) return obj.items;
+    if (Array.isArray(obj.data)) return obj.data;
+    if (Array.isArray(obj.products)) return obj.products;
+    if (Array.isArray(obj.packages)) return obj.packages;
+  }
+  return [];
+}
+function normalizeBatchResponse(data) {
+  const obj = data && typeof data === "object" ? data : {};
+  return {
+    batchId: String(obj.batchId ?? obj.batchRequestId ?? obj.id ?? ""),
+    raw: obj
+  };
+}
+function normalizeBatchStatus(data) {
+  const obj = data && typeof data === "object" ? data : {};
+  const out = { raw: obj };
+  if (typeof obj.batchId === "string") out.batchId = obj.batchId;
+  if (typeof obj.status === "string") out.status = obj.status;
+  if (typeof obj.itemCount === "number") out.itemCount = obj.itemCount;
+  if (typeof obj.failedItemCount === "number") out.failedItemCount = obj.failedItemCount;
+  if (Array.isArray(obj.items)) out.items = obj.items;
+  return out;
+}
+function normalizePackage(row) {
+  const r = row ?? {};
+  const out = { raw: r };
+  if (typeof r.packageNumber === "string") out.packageNumber = r.packageNumber;
+  if (typeof r.status === "string") out.status = r.status;
+  return out;
+}
+function normalizeNamedRef(row) {
+  const r = row ?? {};
+  const out = { raw: r };
+  if (typeof r.id === "number" || typeof r.id === "string") out.id = r.id;
+  if (typeof r.name === "string") out.name = r.name;
+  return out;
+}
+function toIso2(epochMs) {
+  if (typeof epochMs !== "number" || !Number.isFinite(epochMs) || epochMs === 0) {
+    return void 0;
+  }
+  return new Date(epochMs).toISOString();
+}
+function normalizeRow(row) {
+  const out = {
+    id: row.id !== void 0 ? String(row.id) : "",
+    raw: row
+  };
+  const tx = toIso2(row.transactionDate);
+  if (tx) out.transactionDate = tx;
+  if (row.barcode !== void 0) out.barcode = row.barcode;
+  if (row.transactionType !== void 0) out.transactionType = row.transactionType;
+  if (row.receiptId !== void 0) out.receiptId = row.receiptId;
+  if (row.description !== void 0) out.description = row.description;
+  if (typeof row.debt === "number") out.debt = row.debt;
+  if (typeof row.credit === "number") out.credit = row.credit;
+  if (row.paymentPeriod !== void 0) out.paymentPeriod = row.paymentPeriod;
+  if (row.commissionRate !== void 0) out.commissionRate = row.commissionRate;
+  if (row.commissionAmount !== void 0) out.commissionAmount = row.commissionAmount;
+  if (row.commissionInvoiceSerialNumber !== void 0) {
+    out.commissionInvoiceSerialNumber = row.commissionInvoiceSerialNumber;
+  }
+  if (row.sellerRevenue !== void 0) out.sellerRevenue = row.sellerRevenue;
+  if (row.orderNumber !== void 0) out.orderNumber = row.orderNumber;
+  if (row.paymentOrderId !== void 0) out.paymentOrderId = row.paymentOrderId;
+  const pay = toIso2(row.paymentDate);
+  if (pay) out.paymentDate = pay;
+  if (typeof row.sellerId === "number") out.sellerId = row.sellerId;
+  if (row.storeId !== void 0) out.storeId = row.storeId;
+  if (row.storeName !== void 0) out.storeName = row.storeName;
+  if (row.storeAddress !== void 0) out.storeAddress = row.storeAddress;
+  if (row.country !== void 0) out.country = row.country;
+  return out;
+}
+var FinanceResource = class {
+  constructor(transport, limiter) {
+    this.transport = transport;
+    this.limiter = limiter ?? new TokenBucketRateLimiter({ capacity: 100, intervalMs: 6e4 });
+  }
+  transport;
+  limiter;
+  async getSettlements(params = {}) {
+    return this.queryPage(
+      `/integration/finance/che/sellers/${this.transport.sellerId}/settlements`,
+      params
+    );
+  }
+  async getOtherFinancials(params = {}) {
+    return this.queryPage(
+      `/integration/finance/che/sellers/${this.transport.sellerId}/otherfinancials`,
+      params
+    );
+  }
+  async queryPage(path, params) {
+    const size = Math.min(params.limit ?? 50, 200);
+    const page = params.cursor ? Number.parseInt(params.cursor, 10) : 0;
+    const query = { page, size };
+    if (params.startDate) query.startDate = params.startDate.getTime();
+    if (params.endDate) query.endDate = params.endDate.getTime();
+    if (params.transactionType) query.transactionType = params.transactionType;
+    const data = await this.transport.request({
+      method: "GET",
+      path,
+      query,
+      rateLimiter: this.limiter
+    });
+    const items = (data.content ?? []).map(normalizeRow);
+    const result = { items };
+    const totalPages = typeof data.totalPages === "number" ? data.totalPages : 0;
+    if (page + 1 < totalPages) {
+      result.nextCursor = String(page + 1);
+    }
+    return result;
+  }
+};
+var MAX_ITEMS_PER_REQUEST = 1e3;
+async function pollBatchStatus(getStatus, batchRequestId, opts = {}) {
+  const pollIntervalMs = opts.pollIntervalMs ?? 2e3;
+  const timeoutMs = opts.timeoutMs ?? 12e4;
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    opts.signal?.throwIfAborted();
+    const result = await getStatus(batchRequestId);
+    if (result.status === "COMPLETED" || result.status === "FAILED") {
+      return result;
+    }
+    if (Date.now() >= deadline) {
+      throw new TimeoutError({
+        message: `Trendyol batch ${batchRequestId} did not settle within ${timeoutMs}ms (last status: ${result.status})`,
+        data: { batchRequestId, lastStatus: result.status, lastResult: result }
+      });
+    }
+    await delay(pollIntervalMs, opts.signal);
+  }
+}
+var InventoryResource = class {
+  /**
+   * @param transport Trendyol transport.
+   * @param getBatchStatus Batch-status poller (wired by `createTrendyolClient`
+   *   to `products.getBatchStatus`). Required only for `updateAndWait`.
+   */
+  constructor(transport, getBatchStatus) {
+    this.transport = transport;
+    this.getBatchStatus = getBatchStatus;
+  }
+  transport;
+  getBatchStatus;
+  /**
+   * Update price and/or stock for one or more SKUs (by barcode).
+   *
+   * @example
+   * ```ts
+   * const { batchRequestId } = await client.inventory.update([
+   *   { barcode: 'ABC123', quantity: 42, salePrice: 199.9, listPrice: 249.9 },
+   *   { barcode: 'XYZ789', quantity: 0 },
+   * ]);
+   * const status = await client.products.getBatchStatus(batchRequestId);
+   * ```
+   *
+   * @throws {ValidationError} when `items` is empty or longer than 1000.
+   * @throws {ServerError} when Trendyol accepts the request but returns no
+   *   `batchRequestId` (an unpollable response — surfaced loudly instead of
+   *   handing back an empty id).
+   */
+  async update(items) {
+    if (items.length === 0) {
+      throw new ValidationError({ message: "updatePriceAndInventory: items must not be empty" });
+    }
+    if (items.length > MAX_ITEMS_PER_REQUEST) {
+      throw new ValidationError({
+        message: `updatePriceAndInventory: max ${MAX_ITEMS_PER_REQUEST} items per request, got ${items.length}`
+      });
+    }
+    const data = await this.transport.request({
+      method: "POST",
+      path: `/integration/inventory/sellers/${this.transport.sellerId}/products/price-and-inventory`,
+      body: { items }
+    });
+    if (!data.batchRequestId) {
+      throw new ServerError({
+        message: "Trendyol updatePriceAndInventory returned no batchRequestId",
+        data: { response: data }
+      });
+    }
+    return { batchRequestId: data.batchRequestId };
+  }
+  /**
+   * Submit price/stock updates and wait for them to settle.
+   *
+   * Splits `items` into chunks of ≤1000, submits each via {@link update}, and
+   * polls each `batchRequestId` to a terminal state. Returns one
+   * `BatchRequestResult` per chunk (read `failedItemCount` / `items[]` for
+   * per-barcode outcomes). Compose `@lonca/core`'s `retry` around this for
+   * transient-error resilience.
+   *
+   * @throws {ValidationError} when `items` is empty.
+   * @throws {TimeoutError} when any chunk does not settle within `timeoutMs`;
+   *   `error.data.batchRequestId` identifies the stuck chunk.
+   */
+  async updateAndWait(items, opts = {}) {
+    if (items.length === 0) {
+      throw new ValidationError({ message: "updateAndWait: items must not be empty" });
+    }
+    const getStatus = this.getBatchStatus;
+    if (!getStatus) {
+      throw new Error(
+        "updateAndWait requires a batch-status poller; obtain the client via createTrendyolClient()"
+      );
+    }
+    const results = [];
+    for (const batch of chunk(items, MAX_ITEMS_PER_REQUEST)) {
+      const { batchRequestId } = await this.update(batch);
+      results.push(await pollBatchStatus(getStatus, batchRequestId, opts));
+    }
+    return results;
+  }
+};
+function chunk(items, size) {
+  if (items.length <= size) return [items];
+  const chunks = [];
+  for (let i = 0; i < items.length; i += size) {
+    chunks.push(items.slice(i, i + size));
+  }
+  return chunks;
+}
+function delay(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason ?? new Error("Aborted"));
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal?.reason ?? new Error("Aborted"));
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+var InvoicesResource = class {
+  constructor(transport, limiter) {
+    this.transport = transport;
+    this.limiter = limiter ?? new TokenBucketRateLimiter({ capacity: 500, intervalMs: 6e4 });
+  }
+  transport;
+  limiter;
+  /**
+   * Upload an invoice file for a shipment package. **Multipart**: the
+   * SDK builds the FormData internally from the typed input.
+   *
+   * Max 10 MB. Accepted formats: PDF, JPEG, PNG.
+   */
+  async uploadFile(input) {
+    if (!input?.file) {
+      throw new ValidationError({ message: "invoices.uploadFile: file is required" });
+    }
+    if (!input.shipmentPackageId) {
+      throw new ValidationError({ message: "invoices.uploadFile: shipmentPackageId is required" });
+    }
+    const form = new FormData();
+    form.append("shipmentPackageId", String(input.shipmentPackageId));
+    form.append("file", input.file);
+    if (input.invoiceDateTime !== void 0) {
+      form.append("invoiceDateTime", String(input.invoiceDateTime));
+    }
+    if (input.invoiceNumber !== void 0) {
+      form.append("invoiceNumber", input.invoiceNumber);
+    }
+    return this.transport.request({
+      method: "POST",
+      path: `/integration/sellers/${this.transport.sellerId}/seller-invoice-file`,
+      body: form,
+      rateLimiter: this.limiter
+    });
+  }
+  /** Register an invoice URL with Trendyol (alternative to uploading the file). */
+  async sendLink(input) {
+    if (!input?.invoiceLink) {
+      throw new ValidationError({ message: "invoices.sendLink: invoiceLink is required" });
+    }
+    return this.transport.request({
+      method: "POST",
+      path: `/integration/sellers/${this.transport.sellerId}/seller-invoice-links`,
+      body: input,
+      rateLimiter: this.limiter
+    });
+  }
+  /** Remove a previously-registered invoice link. */
+  async deleteLink(input) {
+    return this.transport.request({
+      method: "POST",
+      path: `/integration/sellers/${this.transport.sellerId}/seller-invoice-links/delete`,
+      body: input,
+      rateLimiter: this.limiter
+    });
+  }
+};
+var LabelsResource = class {
+  constructor(transport, limiter) {
+    this.transport = transport;
+    this.limiter = limiter ?? new TokenBucketRateLimiter({ capacity: 100, intervalMs: 6e4 });
+  }
+  transport;
+  limiter;
+  /**
+   * Request a common ZPL label for a cargo tracking number. After this
+   * returns, call `getCommon()` with the same `cargoTrackingNumber` to
+   * retrieve the generated label.
+   *
+   * @throws {ValidationError} when `format` is missing.
+   */
+  async createCommon(cargoTrackingNumber, input) {
+    if (!input?.format) {
+      throw new ValidationError({ message: "labels.createCommon: format is required" });
+    }
+    return this.transport.request({
+      method: "POST",
+      path: `/integration/sellers/${this.transport.sellerId}/common-label/${encodeURIComponent(String(cargoTrackingNumber))}`,
+      body: input,
+      rateLimiter: this.limiter
+    });
+  }
+  /**
+   * Retrieve the previously-created common label. Trendyol returns
+   * `{ data: [{ label, format }] }`; the SDK surfaces the array as
+   * `labels[]` for ergonomic access.
+   *
+   * Typically `labels.length === 1` per tracking number, but kept as an
+   * array to match the wire shape.
+   */
+  async getCommon(cargoTrackingNumber) {
+    const raw = await this.transport.request({
+      method: "GET",
+      path: `/integration/sellers/${this.transport.sellerId}/common-label/${encodeURIComponent(String(cargoTrackingNumber))}`,
+      rateLimiter: this.limiter
+    });
+    const labels = (raw?.data ?? []).map((row) => ({
+      label: row.label ?? "",
+      format: row.format ?? "ZPL"
+    }));
+    return { labels, raw: raw ?? {} };
+  }
+};
+function n(rows, extract) {
+  const list = Array.isArray(rows) ? rows : [];
+  return list.map((r) => {
+    const node = r;
+    return { ...extract(node), raw: node };
+  });
+}
+var LocationsResource = class {
+  constructor(transport, limiter) {
+    this.transport = transport;
+    this.limiter = limiter ?? new TokenBucketRateLimiter({ capacity: 60, intervalMs: 6e4 });
+  }
+  transport;
+  limiter;
+  /** List all supported countries (Türkiye + AZ + GULF + CEE). */
+  async getCountries() {
+    const data = await this.transport.request({
+      method: "GET",
+      path: `/integration/member/countries`,
+      rateLimiter: this.limiter
+    });
+    return n(data, (node) => ({
+      code: String(node.code ?? node.id ?? ""),
+      name: node.name
+    }));
+  }
+  // ─── Domestic (TR / AZ) ───────────────────────────────────────────────
+  async getTurkeyCities() {
+    return this.cities(`/integration/member/countries/domestic/TR/cities`);
+  }
+  async getTurkeyDistricts(cityCode) {
+    return this.districts(
+      `/integration/member/countries/domestic/TR/cities/${encodeURIComponent(String(cityCode))}/districts`
+    );
+  }
+  async getTurkeyNeighborhoods(cityCode, districtCode) {
+    return this.neighborhoods(
+      `/integration/member/countries/domestic/TR/cities/${encodeURIComponent(String(cityCode))}/districts/${encodeURIComponent(String(districtCode))}/neighborhoods`
+    );
+  }
+  async getAzerbaijanCities() {
+    return this.cities(`/integration/member/countries/domestic/AZ/cities`);
+  }
+  async getAzerbaijanDistricts(cityCode) {
+    return this.districts(
+      `/integration/member/countries/domestic/AZ/cities/${encodeURIComponent(String(cityCode))}/districts`
+    );
+  }
+  // ─── International (GULF / CEE) ───────────────────────────────────────
+  async getCitiesByCountry(countryCode) {
+    return this.cities(`/integration/member/countries/${encodeURIComponent(countryCode)}/cities`);
+  }
+  async getDistrictsByCity(countryCode, cityId) {
+    return this.districts(
+      `/integration/member/countries/${encodeURIComponent(countryCode)}/cities/${encodeURIComponent(String(cityId))}/districts`
+    );
+  }
+  // ─── Shared paginators ────────────────────────────────────────────────
+  async cities(path) {
+    const data = await this.transport.request({
+      method: "GET",
+      path,
+      rateLimiter: this.limiter
+    });
+    return n(data, (node) => ({
+      code: String(node.code ?? node.id ?? ""),
+      name: node.name,
+      countryCode: node.countryCode
+    }));
+  }
+  async districts(path) {
+    const data = await this.transport.request({
+      method: "GET",
+      path,
+      rateLimiter: this.limiter
+    });
+    return n(data, (node) => ({
+      code: String(node.code ?? node.id ?? ""),
+      name: node.name,
+      cityCode: node.cityCode !== void 0 ? String(node.cityCode) : void 0
+    }));
+  }
+  async neighborhoods(path) {
+    const data = await this.transport.request({
+      method: "GET",
+      path,
+      rateLimiter: this.limiter
+    });
+    return n(data, (node) => ({
+      code: String(node.code ?? node.id ?? ""),
+      name: node.name,
+      districtCode: node.districtCode !== void 0 ? String(node.districtCode) : void 0
+    }));
+  }
+};
+var MAX_PAGE_SIZE = 200;
+var DEFAULT_PAGE_SIZE2 = 50;
+function toIso3(epochMs) {
+  if (typeof epochMs !== "number" || !Number.isFinite(epochMs) || epochMs === 0) {
+    return void 0;
+  }
+  return new Date(epochMs).toISOString();
+}
+function normalizeAddress(node) {
+  if (!node) return void 0;
+  const out = {};
+  if (node.id !== void 0) out.id = String(node.id);
+  if (node.firstName !== void 0) out.firstName = node.firstName;
+  if (node.lastName !== void 0) out.lastName = node.lastName;
+  if (node.fullName !== void 0) out.fullName = node.fullName;
+  if (node.company !== void 0) out.company = node.company;
+  if (node.address1 !== void 0) out.address1 = node.address1;
+  if (node.address2 !== void 0) out.address2 = node.address2;
+  if (node.fullAddress !== void 0) out.fullAddress = node.fullAddress;
+  if (node.shortAddress !== void 0) out.shortAddress = node.shortAddress;
+  if (node.city !== void 0) out.city = node.city;
+  if (node.cityCode !== void 0) out.cityCode = node.cityCode;
+  if (node.district !== void 0) out.district = node.district;
+  if (node.districtId !== void 0) out.districtId = node.districtId;
+  if (node.neighborhoodId !== void 0) out.neighborhoodId = node.neighborhoodId;
+  if (node.countyId !== void 0) out.countyId = node.countyId;
+  if (node.countyName !== void 0) out.countyName = node.countyName;
+  if (node.stateName !== void 0) out.stateName = node.stateName;
+  if (node.postalCode !== void 0) out.postalCode = node.postalCode;
+  if (node.countryCode !== void 0) out.countryCode = node.countryCode;
+  if (node.phone !== void 0) out.phone = node.phone;
+  if (node.addressLines !== void 0) out.addressLines = node.addressLines;
+  return out;
+}
+function normalizeLine(node) {
+  const out = {
+    id: node.lineId !== void 0 ? String(node.lineId) : "",
+    quantity: typeof node.quantity === "number" ? node.quantity : 0,
+    productName: node.productName ?? "",
+    barcode: node.barcode ?? "",
+    lineUnitPrice: typeof node.lineUnitPrice === "number" ? node.lineUnitPrice : 0,
+    lineGrossAmount: typeof node.lineGrossAmount === "number" ? node.lineGrossAmount : 0,
+    raw: node
+  };
+  if (node.productSize !== void 0) out.productSize = node.productSize;
+  if (node.productColor !== void 0) out.productColor = node.productColor;
+  if (node.stockCode !== void 0) out.stockCode = node.stockCode;
+  if (node.contentId !== void 0) out.contentId = String(node.contentId);
+  if (node.sellerId !== void 0) out.sellerId = String(node.sellerId);
+  if (node.productCategoryId !== void 0) out.productCategoryId = String(node.productCategoryId);
+  if (node.salesCampaignId !== void 0) out.salesCampaignId = String(node.salesCampaignId);
+  if (node.currencyCode !== void 0) out.currencyCode = node.currencyCode;
+  if (node.lineSellerDiscount !== void 0) out.lineSellerDiscount = node.lineSellerDiscount;
+  if (node.lineTyDiscount !== void 0) out.lineTyDiscount = node.lineTyDiscount;
+  if (node.lineTotalDiscount !== void 0) out.lineTotalDiscount = node.lineTotalDiscount;
+  if (node.vatRate !== void 0) out.vatRate = node.vatRate;
+  if (node.commission !== void 0) out.commission = node.commission;
+  if (node.orderLineItemStatusName !== void 0) {
+    out.orderLineItemStatusName = node.orderLineItemStatusName;
+  }
+  if (node.businessUnit !== void 0) out.businessUnit = node.businessUnit;
+  if (Array.isArray(node.fastDeliveryOptions)) out.fastDeliveryOptions = node.fastDeliveryOptions;
+  if (Array.isArray(node.discountDetails)) {
+    out.discountDetails = node.discountDetails;
+  }
+  return out;
+}
+function normalizeHistory(node) {
+  const out = { raw: node };
+  if (node.status !== void 0) out.status = node.status;
+  const createdAt = toIso3(node.createdDate);
+  if (createdAt) out.createdAt = createdAt;
+  return out;
+}
+function normalizeCustomer(node) {
+  const out = {
+    firstName: node.customerFirstName ?? "",
+    lastName: node.customerLastName ?? ""
+  };
+  if (node.customerId !== void 0) out.id = String(node.customerId);
+  if (node.customerEmail !== void 0) out.email = node.customerEmail;
+  if (node.taxNumber !== void 0 && node.taxNumber !== null) out.taxNumber = node.taxNumber;
+  if (node.identityNumber !== void 0) out.identityNumber = node.identityNumber;
+  return out;
+}
+function normalizePackage2(node) {
+  const pkgId = node.shipmentPackageId ?? node.id;
+  const out = {
+    id: pkgId !== void 0 ? String(pkgId) : "",
+    orderNumber: node.orderNumber ?? "",
+    status: node.status ?? "",
+    customer: normalizeCustomer(node),
+    orderDate: toIso3(node.orderDate) ?? "",
+    lastModifiedDate: toIso3(node.lastModifiedDate) ?? "",
+    currencyCode: node.currencyCode ?? "",
+    packageTotalPrice: typeof node.packageTotalPrice === "number" ? node.packageTotalPrice : 0,
+    packageGrossAmount: typeof node.packageGrossAmount === "number" ? node.packageGrossAmount : 0,
+    packageSellerDiscount: typeof node.packageSellerDiscount === "number" ? node.packageSellerDiscount : 0,
+    packageTyDiscount: typeof node.packageTyDiscount === "number" ? node.packageTyDiscount : 0,
+    packageTotalDiscount: typeof node.packageTotalDiscount === "number" ? node.packageTotalDiscount : 0,
+    lines: (node.lines ?? []).map(normalizeLine),
+    packageHistories: (node.packageHistories ?? []).map(normalizeHistory),
+    raw: node
+  };
+  if (node.shipmentNumber !== void 0) out.shipmentNumber = String(node.shipmentNumber);
+  if (node.originPackageIds !== void 0 && node.originPackageIds !== null) {
+    out.originPackageIds = node.originPackageIds.map((id) => String(id));
+  }
+  if (node.warehouseId !== void 0) out.warehouseId = String(node.warehouseId);
+  if (node.supplierId !== void 0) out.supplierId = String(node.supplierId);
+  if (node.shipmentPackageStatus !== void 0) {
+    out.shipmentPackageStatus = node.shipmentPackageStatus;
+  }
+  const agreed = toIso3(node.agreedDeliveryDate);
+  if (agreed) out.agreedDeliveryDate = agreed;
+  const estStart = toIso3(node.estimatedDeliveryStartDate);
+  if (estStart) out.estimatedDeliveryStartDate = estStart;
+  const estEnd = toIso3(node.estimatedDeliveryEndDate);
+  if (estEnd) out.estimatedDeliveryEndDate = estEnd;
+  const origin = toIso3(node.originShipmentDate);
+  if (origin) out.originShipmentDate = origin;
+  const invoice = normalizeAddress(node.invoiceAddress);
+  if (invoice) out.invoiceAddress = invoice;
+  const shipment = normalizeAddress(node.shipmentAddress);
+  if (shipment) out.shipmentAddress = shipment;
+  if (node.deliveryAddressType !== void 0) out.deliveryAddressType = node.deliveryAddressType;
+  if (node.cargoTrackingNumber !== void 0) {
+    out.cargoTrackingNumber = String(node.cargoTrackingNumber);
+  }
+  if (node.cargoProviderName !== void 0) out.cargoProviderName = node.cargoProviderName;
+  if (node.cargoProviderId !== void 0) out.cargoProviderId = String(node.cargoProviderId);
+  if (node.cargoSenderNumber !== void 0) out.cargoSenderNumber = node.cargoSenderNumber;
+  if (node.deliveryType !== void 0) out.deliveryType = node.deliveryType;
+  if (node.whoPays !== void 0) out.whoPays = node.whoPays;
+  if (node.timeSlotId !== void 0) out.timeSlotId = node.timeSlotId;
+  if (typeof node.fastDelivery === "boolean") out.fastDelivery = node.fastDelivery;
+  if (node.fastDeliveryType !== void 0) out.fastDeliveryType = node.fastDeliveryType;
+  if (typeof node.deliveredByService === "boolean")
+    out.deliveredByService = node.deliveredByService;
+  if (typeof node.commercial === "boolean") out.commercial = node.commercial;
+  if (typeof node.micro === "boolean") out.micro = node.micro;
+  if (typeof node.giftBoxRequested === "boolean") out.giftBoxRequested = node.giftBoxRequested;
+  if (typeof node["3pByTrendyol"] === "boolean") {
+    out.threePByTrendyol = node["3pByTrendyol"];
+  }
+  if (typeof node.containsDangerousProduct === "boolean") {
+    out.containsDangerousProduct = node.containsDangerousProduct;
+  }
+  if (typeof node.isCod === "boolean") out.isCod = node.isCod;
+  if (typeof node.is4P === "boolean") out.is4P = node.is4P;
+  if (node.invoiceLink !== void 0) out.invoiceLink = node.invoiceLink;
+  if (node.createdBy !== void 0) out.createdBy = node.createdBy;
+  return out;
+}
+var OrdersResource = class {
+  constructor(transport, limiter) {
+    this.transport = transport;
+    this.limiter = limiter ?? new TokenBucketRateLimiter({ capacity: 1e3, intervalMs: 6e4 });
+  }
+  transport;
+  limiter;
+  /**
+   * List shipment packages for the seller.
+   *
+   * @example
+   * ```ts
+   * import { paginate } from '@lonca/core';
+   * for await (const pkg of paginate((p) => client.orders.list({ ...p, status: 'Created' }))) {
+   *   console.log(pkg.id, pkg.status, pkg.customer.firstName);
+   * }
+   * ```
+   */
+  async list(params = {}) {
+    const size = Math.min(params.limit ?? DEFAULT_PAGE_SIZE2, MAX_PAGE_SIZE);
+    const page = params.cursor ? Number.parseInt(params.cursor, 10) : 0;
+    const query = { page, size };
+    if (params.status) query.status = params.status;
+    if (params.orderNumber) query.orderNumber = params.orderNumber;
+    if (params.startDate) query.startDate = params.startDate.getTime();
+    if (params.endDate) query.endDate = params.endDate.getTime();
+    const data = await this.transport.request({
+      method: "GET",
+      path: `/integration/order/sellers/${this.transport.sellerId}/orders`,
+      query,
+      rateLimiter: this.limiter
+    });
+    const items = (data.content ?? []).map(normalizePackage2);
+    const totalPages = typeof data.totalPages === "number" ? data.totalPages : 0;
+    const result = { items };
+    if (page + 1 < totalPages) {
+      result.nextCursor = String(page + 1);
+    }
+    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 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 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 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 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 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 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.transport.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 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.transport.sellerId}/orders/stream`,
+      query,
+      rateLimiter: this.limiter
+    });
+    const items = (data.content ?? []).map(normalizePackage2);
+    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.transport.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;
+  }
+  /**
+   * Notify Trendyol that a shipped package was returned to you (manual
+   * return flow, e.g. customer dropped it at your address or you got the
+   * package back without going through Trendyol's return cargo).
+   *
+   * No body; Trendyol responds with 200 + empty body on success.
+   */
+  async manualReturnByPackageId(packageId) {
+    await this.transport.request({
+      method: "PUT",
+      path: `${this.packagePath(packageId)}/manual-return`,
+      rateLimiter: this.limiter
+    });
+  }
+  /**
+   * Manual-return variant that takes the cargo tracking number instead of
+   * the package ID. Useful when the cargo provider's webhook only carries
+   * the tracking number.
+   *
+   * Sibling path (not under `/{packageId}/...`).
+   */
+  async manualReturnByTrackingNumber(cargoTrackingNumber) {
+    await this.transport.request({
+      method: "PUT",
+      path: `/integration/order/sellers/${this.transport.sellerId}/shipment-packages/manual-return-by-tracking-number/${encodeURIComponent(String(cargoTrackingNumber))}`,
+      rateLimiter: this.limiter
+    });
+  }
+  /**
+   * Fetch Trendyol Express compensation tickets (claims filed when a
+   * shipment is lost or damaged in transit). Page-based pagination
+   * internally; the SDK exposes the cursor convention.
+   *
+   * Note the different base path — `/integration/tex/compensation/...`,
+   * not the regular `/integration/order/...`.
+   *
+   * @example
+   * ```ts
+   * import { paginate } from '@lonca/core';
+   * const tickets = await client.orders.getCompensationTickets({
+   *   startDate: new Date('2026-01-01'),
+   *   endDate: new Date('2026-02-01'),
+   * });
+   * for (const t of tickets.items) {
+   *   console.log(t.orderNumber, t.currentState, t.stateMessage);
+   * }
+   * ```
+   */
+  async getCompensationTickets(params = {}) {
+    const size = Math.min(params.limit ?? 200, 200);
+    const page = params.cursor ? Number.parseInt(params.cursor, 10) : 0;
+    const query = { page, size };
+    if (params.startDate) query.startDate = params.startDate.getTime();
+    if (params.endDate) query.endDate = params.endDate.getTime();
+    const res = await this.transport.request({
+      method: "GET",
+      path: `/integration/tex/compensation/sellers/${this.transport.sellerId}/tickets`,
+      query,
+      rateLimiter: this.limiter
+    });
+    const tickets = Array.isArray(res.data) ? res.data : res.data?.items ?? res.data?.content ?? res.content ?? [];
+    const items = tickets.map((t) => {
+      const itemDetails = (t.itemDetails ?? []).map((d) => {
+        const out2 = {};
+        if (typeof d.itemAmount === "number") out2.itemAmount = d.itemAmount;
+        if (d.itemCode !== void 0) out2.itemCode = d.itemCode;
+        if (typeof d.itemCount === "number") out2.itemCount = d.itemCount;
+        if (d.itemName !== void 0) out2.itemName = d.itemName;
+        return out2;
+      });
+      const out = {
+        itemDetails,
+        raw: t
+      };
+      if (t.cargoProvider !== void 0) out.cargoProvider = t.cargoProvider;
+      if (t.compensateReason !== void 0) out.compensateReason = t.compensateReason;
+      const createdAt = toIso3(t.createDate);
+      if (createdAt) out.createdAt = createdAt;
+      if (t.currentState !== void 0) {
+        out.currentState = t.currentState;
+      }
+      if (t.deliveryNumber !== void 0) out.deliveryNumber = t.deliveryNumber;
+      if (t.orderNumber !== void 0) out.orderNumber = t.orderNumber;
+      if (t.requestedBy !== void 0) out.requestedBy = t.requestedBy;
+      if (t.stateMessage !== void 0) out.stateMessage = t.stateMessage;
+      if (t.totalItemsAmount !== void 0) out.totalItemsAmount = t.totalItemsAmount;
+      return out;
+    });
+    const result = { items };
+    const total = typeof res.totalCount === "number" ? res.totalCount : 0;
+    if ((page + 1) * size < total) {
+      result.nextCursor = String(page + 1);
+    }
+    return result;
+  }
+  packagePath(packageId) {
+    return `/integration/order/sellers/${this.transport.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) : "",
+    name: ref?.name ?? ""
+  };
+}
+function normalizeAttribute2(attr) {
+  const out = {
+    attributeId: attr.attributeId !== void 0 ? String(attr.attributeId) : ""
+  };
+  if (attr.attributeName !== void 0) out.attributeName = attr.attributeName;
+  if (attr.attributeValueId !== void 0) {
+    out.attributeValueId = String(attr.attributeValueId);
+  }
+  if (attr.attributeValue !== void 0) out.attributeValue = attr.attributeValue;
+  return out;
+}
+function normalizeImages(images) {
+  if (!images) return [];
+  return images.map((img) => typeof img === "string" ? img : img?.url).filter((u) => typeof u === "string" && u.length > 0);
+}
+function normalizeStock(stock) {
+  if (typeof stock === "number") return stock;
+  if (stock && typeof stock === "object" && typeof stock.quantity === "number") {
+    return stock.quantity;
+  }
+  return void 0;
+}
+function normalizeVariant(variant) {
+  const out = {
+    variantId: variant.variantId !== void 0 ? String(variant.variantId) : "",
+    barcode: variant.barcode ?? "",
+    attributes: (variant.attributes ?? []).map(normalizeAttribute2),
+    raw: variant
+  };
+  if (typeof variant.commission === "number") out.commission = variant.commission;
+  if (variant.productUrl !== void 0) out.productUrl = variant.productUrl;
+  if (typeof variant.onSale === "boolean") out.onSale = variant.onSale;
+  const stock = normalizeStock(variant.stock);
+  if (stock !== void 0) out.stock = stock;
+  return out;
+}
+function toIso4(epochMs) {
+  if (typeof epochMs !== "number" || !Number.isFinite(epochMs)) return void 0;
+  return new Date(epochMs).toISOString();
+}
+function normalizeProduct(node) {
+  const out = {
+    contentId: node.contentId !== void 0 ? String(node.contentId) : "",
+    productMainId: node.productMainId ?? "",
+    title: node.title ?? "",
+    brand: normalizeRef(node.brand),
+    category: normalizeRef(node.category),
+    images: normalizeImages(node.images),
+    attributes: (node.attributes ?? []).map(normalizeAttribute2),
+    variants: (node.variants ?? []).map(normalizeVariant),
+    createdAt: toIso4(node.creationDate) ?? "",
+    updatedAt: toIso4(node.lastModifiedDate) ?? "",
+    raw: node
+  };
+  if (node.description !== void 0) out.description = node.description;
+  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 = toIso4(node.createDateTime);
+  if (createdAt) out.createdAt = createdAt;
+  const updatedAt = toIso4(node.lastUpdateDate);
+  if (updatedAt) out.updatedAt = updatedAt;
+  const priceChanged = toIso4(node.lastPriceChangeDate);
+  if (priceChanged) out.lastPriceChangedAt = priceChanged;
+  const stockChanged = toIso4(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 = toIso4(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 = {};
+    if (item.requestItem !== void 0) result.requestItem = item.requestItem;
+    if (item.status !== void 0) result.status = item.status;
+    if (item.failureReasons !== void 0) result.failureReasons = item.failureReasons;
+    return result;
+  });
+  const out = {
+    batchRequestId: typeof data.batchRequestId === "string" ? data.batchRequestId : "",
+    status: data.status ?? "PROCESSING",
+    items,
+    raw: data
+  };
+  if (typeof data.itemCount === "number") out.itemCount = data.itemCount;
+  if (typeof data.failedItemCount === "number") out.failedItemCount = data.failedItemCount;
+  const createdAt = toIso4(data.creationDate);
+  if (createdAt) out.createdAt = createdAt;
+  const lastModifiedAt = toIso4(data.lastModification);
+  if (lastModifiedAt) out.lastModifiedAt = lastModifiedAt;
+  if (data.sourceType !== void 0) out.sourceType = data.sourceType;
+  if (data.batchRequestType !== void 0) out.batchRequestType = data.batchRequestType;
+  if (data.notes !== void 0) out.notes = data.notes;
+  if (data.objectKey !== void 0) out.objectKey = data.objectKey;
+  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, options = {}) {
+    this.transport = transport;
+    this.filterLimiter = options.filterLimiter ?? new TokenBucketRateLimiter({ capacity: 2e3, intervalMs: 6e4 });
+    this.batchLimiter = options.batchLimiter ?? new TokenBucketRateLimiter({ capacity: 1e3, intervalMs: 6e4 });
+    this.buyboxLimiter = options.buyboxLimiter ?? new TokenBucketRateLimiter({ capacity: 1e3, intervalMs: 6e4 });
+    this.writeLimiter = options.writeLimiter ?? new TokenBucketRateLimiter({ capacity: 1e3, intervalMs: 6e4 });
+    this.deleteLimiter = options.deleteLimiter ?? new TokenBucketRateLimiter({ capacity: DELETE_RATE_PER_MIN, intervalMs: 6e4 });
+  }
+  transport;
+  filterLimiter;
+  batchLimiter;
+  buyboxLimiter;
+  writeLimiter;
+  deleteLimiter;
+  validateBarcodes(barcodes, methodLabel) {
+    if (!Array.isArray(barcodes) || barcodes.length === 0) {
+      throw new ValidationError({ message: `${methodLabel}: barcodes must not be empty` });
+    }
+    if (barcodes.length > MAX_WRITE_ITEMS) {
+      throw new 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 ValidationError({ message: `${methodLabel}: items must not be empty` });
+    }
+    if (items.length > MAX_WRITE_ITEMS) {
+      throw new 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.transport.sellerId}${endpoint}`,
+      body: { items },
+      rateLimiter: this.writeLimiter
+    });
+    return { batchRequestId: data?.batchRequestId ?? "" };
+  }
+  /**
+   * List approved products. Use `paginate()` from `@lonca/core` to iterate
+   * lazily across pages.
+   *
+   * Trendyol exposes both page-based and `nextPageToken`-based pagination
+   * (the latter required when the dataset exceeds 10,000 items). The SDK
+   * picks the right strategy automatically — pass our opaque `cursor` from
+   * the previous response and we forward it as `nextPageToken`.
+   *
+   * @example
+   * ```ts
+   * import { paginate } from '@lonca/core';
+   * for await (const product of paginate((p) => client.products.list(p))) {
+   *   for (const variant of product.variants) {
+   *     console.log(variant.barcode, product.title);
+   *   }
+   * }
+   * ```
+   */
+  async list(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();
+    const data = await this.transport.request({
+      method: "GET",
+      path: `/integration/product/sellers/${this.transport.sellerId}/products/approved`,
+      query,
+      rateLimiter: this.filterLimiter
+    });
+    const items = (data.content ?? []).map(normalizeProduct);
+    const page = { items };
+    if (data.nextPageToken) {
+      page.nextCursor = data.nextPageToken;
+    }
+    return page;
+  }
+  /**
+   * Poll a batch request returned by an async write (e.g. `createProducts`,
+   * `updatePriceAndInventory`).
+   *
+   * Trendyol retains batch results for **4 hours** after the originating
+   * request — poll within that window.
+   *
+   * @param batchRequestId The opaque ID returned by the originating call.
+   */
+  async getBatchStatus(batchRequestId) {
+    const id = encodeURIComponent(batchRequestId);
+    const data = await this.transport.request({
+      method: "GET",
+      path: `/integration/product/sellers/${this.transport.sellerId}/products/batch-requests/${id}`,
+      rateLimiter: this.batchLimiter
+    });
+    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.transport.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.transport.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 ValidationError({
+        message: "getBuyboxInfo: barcodes must be a non-empty array"
+      });
+    }
+    if (barcodes.length > MAX_BUYBOX_BARCODES) {
+      throw new 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.transport.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.transport.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.transport.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.transport.sellerId}/products/unlock`,
+      body: { items: barcodes.map((barcode) => ({ barcode })) },
+      rateLimiter: this.writeLimiter
+    });
+    return { batchRequestId: data?.batchRequestId ?? "" };
+  }
+};
+function toIso5(epochMs) {
+  if (typeof epochMs !== "number" || !Number.isFinite(epochMs) || epochMs === 0) {
+    return void 0;
+  }
+  return new Date(epochMs).toISOString();
+}
+function normalizeAnswer(a) {
+  if (!a) return void 0;
+  const out = {};
+  if (a.text !== void 0) out.text = a.text;
+  const createdAt = toIso5(a.creationDate);
+  if (createdAt) out.createdAt = createdAt;
+  if (a.status !== void 0) out.status = a.status;
+  return out;
+}
+function normalizeQuestion(node) {
+  const out = {
+    id: node.id !== void 0 ? String(node.id) : "",
+    raw: node
+  };
+  if (node.text !== void 0) out.text = node.text;
+  if (node.customerId !== void 0) out.customerId = String(node.customerId);
+  if (node.userName !== void 0) out.userName = node.userName;
+  if (typeof node.showUserName === "boolean") out.showUserName = node.showUserName;
+  if (node.status !== void 0) out.status = node.status;
+  if (typeof node.public === "boolean") out.public = node.public;
+  if (node.productMainId !== void 0) out.productMainId = node.productMainId;
+  if (node.productName !== void 0) out.productName = node.productName;
+  if (node.imageUrl !== void 0) out.imageUrl = node.imageUrl;
+  if (node.webUrl !== void 0) out.webUrl = node.webUrl;
+  const createdAt = toIso5(node.creationDate);
+  if (createdAt) out.createdAt = createdAt;
+  if (node.answeredDateMessage !== void 0) out.answeredDateMessage = node.answeredDateMessage;
+  const answer = normalizeAnswer(node.answer);
+  if (answer) out.answer = answer;
+  const rejectedAnswer = normalizeAnswer(node.rejectedAnswer);
+  if (rejectedAnswer) out.rejectedAnswer = rejectedAnswer;
+  const rejectedAt = toIso5(node.rejectedDate);
+  if (rejectedAt) out.rejectedAt = rejectedAt;
+  if (node.reason !== void 0) out.reason = node.reason;
+  if (node.reportReason !== void 0) out.reportReason = node.reportReason;
+  const reportedAt = toIso5(node.reportedDate);
+  if (reportedAt) out.reportedAt = reportedAt;
+  return out;
+}
+var QuestionsResource = class {
+  constructor(transport, limiter) {
+    this.transport = transport;
+    this.limiter = limiter ?? new TokenBucketRateLimiter({ capacity: 500, intervalMs: 6e4 });
+  }
+  transport;
+  limiter;
+  /** Fetch a single question by its numeric ID. */
+  async get(questionId) {
+    const data = await this.transport.request({
+      method: "GET",
+      path: `/integration/qna/sellers/${this.transport.sellerId}/questions/${encodeURIComponent(String(questionId))}`,
+      rateLimiter: this.limiter
+    });
+    return normalizeQuestion(data);
+  }
+  /**
+   * Filter questions by barcode / date range / status. Page-based
+   * pagination internally; SDK exposes the opaque-cursor convention.
+   */
+  async list(params = {}) {
+    const size = Math.min(params.limit ?? 50, 200);
+    const page = params.cursor ? Number.parseInt(params.cursor, 10) : 0;
+    const query = { page, size };
+    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.status) query.status = params.status;
+    const data = await this.transport.request({
+      method: "GET",
+      path: `/integration/qna/sellers/${this.transport.sellerId}/questions/filter`,
+      query,
+      rateLimiter: this.limiter
+    });
+    const items = (data.content ?? []).map(normalizeQuestion);
+    const result = { items };
+    const totalPages = typeof data.totalPages === "number" ? data.totalPages : 0;
+    if (page + 1 < totalPages) {
+      result.nextCursor = String(page + 1);
+    }
+    return result;
+  }
+  /**
+   * Reply to a question. Trendyol enforces 10–2000 characters on the
+   * answer text; the SDK pre-validates client-side.
+   *
+   * @throws {ValidationError} when `text` is outside the 10–2000 char range.
+   */
+  async answer(questionId, text) {
+    if (typeof text !== "string" || text.length < 10) {
+      throw new ValidationError({
+        message: `questions.answer: text must be at least 10 chars (got ${text?.length ?? 0})`
+      });
+    }
+    if (text.length > 2e3) {
+      throw new ValidationError({
+        message: `questions.answer: text must be at most 2000 chars (got ${text.length})`
+      });
+    }
+    return this.transport.request({
+      method: "POST",
+      path: `/integration/qna/sellers/${this.transport.sellerId}/questions/${encodeURIComponent(String(questionId))}/answers`,
+      body: { text },
+      rateLimiter: this.limiter
+    });
+  }
+};
+var VALID_TYPES = /* @__PURE__ */ new Set([
+  "SHIPMENT",
+  "RETURNING",
+  "INVOICE",
+  "WAREHOUSE"
+]);
+function normalizeAddressType(raw) {
+  if (raw && VALID_TYPES.has(raw)) {
+    return raw;
+  }
+  const stripped = raw?.replace(/_ADDRESS$/, "");
+  if (stripped && VALID_TYPES.has(stripped)) {
+    return stripped;
+  }
+  return "SHIPMENT";
+}
+function normalizeAddress2(node) {
+  return {
+    id: String(node.id),
+    name: node.name,
+    addressType: normalizeAddressType(node.addressType),
+    isShipmentAddress: node.isShipmentAddress ?? false,
+    isReturningAddress: node.isReturningAddress ?? false,
+    isInvoiceAddress: node.isInvoiceAddress ?? false,
+    isDefault: node.isDefault ?? false,
+    address: node.address,
+    city: node.city,
+    district: node.district,
+    postCode: node.postCode,
+    fullName: node.fullName
+  };
+}
+var DEFAULT_CACHE_TTL_MS = 60 * 60 * 1e3;
+var SuppliersResource = class {
+  constructor(transport, options = {}) {
+    this.transport = transport;
+    this.cacheTtlMs = options.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
+    this.limiter = new TokenBucketRateLimiter({
+      capacity: 1,
+      intervalMs: DEFAULT_CACHE_TTL_MS
+    });
+  }
+  transport;
+  cache = null;
+  cacheTtlMs;
+  limiter;
+  inflight = null;
+  /**
+   * List the seller's registered addresses (shipment, returning, invoice, warehouse).
+   *
+   * Returns the cached value if it is still fresh. Concurrent calls share a
+   * single in-flight request.
+   */
+  async getAddresses(options = {}) {
+    if (!options.forceRefresh && this.cache && this.cache.expiresAt > Date.now()) {
+      return this.cache.value;
+    }
+    if (this.inflight) return this.inflight;
+    this.inflight = this.fetchFresh().finally(() => {
+      this.inflight = null;
+    });
+    return this.inflight;
+  }
+  /** Drop the cache; the next `getAddresses()` call hits the API. */
+  invalidateCache() {
+    this.cache = null;
+  }
+  async fetchFresh() {
+    const data = await this.transport.request({
+      method: "GET",
+      path: `/integration/sellers/${this.transport.sellerId}/addresses`,
+      rateLimiter: this.limiter
+    });
+    const items = data.supplierAddresses.map(normalizeAddress2);
+    this.cache = { value: items, expiresAt: Date.now() + this.cacheTtlMs };
+    return items;
+  }
+};
+var TestOrdersResource = class {
+  constructor(transport, limiter) {
+    this.transport = transport;
+    this.limiter = limiter ?? new TokenBucketRateLimiter({ capacity: 60, intervalMs: 6e4 });
+  }
+  transport;
+  limiter;
+  /**
+   * Create a test order with the given customer / addresses / lines. The
+   * SDK forwards the typed payload verbatim — drill into Trendyol's
+   * `createTestOrder` doc for inner field rules.
+   *
+   * @throws {ValidationError} when required top-level fields are missing.
+   */
+  async create(input) {
+    for (const k of ["customer", "invoiceAddress", "shippingAddress", "seller", "lines"]) {
+      if (!input?.[k]) {
+        throw new ValidationError({ message: `testOrders.create: ${k} is required` });
+      }
+    }
+    return this.transport.request({
+      method: "POST",
+      path: `/integration/test/order/orders/core`,
+      body: input,
+      rateLimiter: this.limiter
+    });
+  }
+  /** Push a test shipment package to the given status. */
+  async updateStatus(packageId, status) {
+    return this.transport.request({
+      method: "PUT",
+      path: `/integration/test/order/sellers/${this.transport.sellerId}/shipment-packages/${encodeURIComponent(String(packageId))}/status`,
+      body: { status },
+      rateLimiter: this.limiter
+    });
+  }
+  /** Move test claims to the `WaitingInAction` state. */
+  async setClaimsWaitingInAction() {
+    return this.transport.request({
+      method: "PUT",
+      path: `/integration/test/order/sellers/${this.transport.sellerId}/claims/waiting-in-action`,
+      rateLimiter: this.limiter
+    });
+  }
+};
+var VideosResource = class {
+  constructor(transport, options = {}) {
+    this.transport = transport;
+    this.createLimiter = options.createLimiter ?? new TokenBucketRateLimiter({ capacity: 200, intervalMs: 6e4 });
+    this.listLimiter = options.listLimiter ?? new TokenBucketRateLimiter({ capacity: 1e3, intervalMs: 6e4 });
+  }
+  transport;
+  createLimiter;
+  listLimiter;
+  /**
+   * Queue a video for upload. Trendyol downloads from the URL in the
+   * body asynchronously; poll `list()` (filtered by id) for status.
+   *
+   * @throws {ValidationError} when `input` is empty / not an object.
+   */
+  async create(input) {
+    if (!input || typeof input !== "object") {
+      throw new ValidationError({ message: "videos.create: input is required" });
+    }
+    return this.transport.request({
+      method: "POST",
+      path: `/integration/video/sellers/${this.transport.sellerId}/videos`,
+      body: input,
+      rateLimiter: this.createLimiter
+    });
+  }
+  /** List the seller's integration videos (optionally filtered by id / status). */
+  async list(params = {}) {
+    const data = await this.transport.request({
+      method: "GET",
+      path: `/integration/video/sellers/${this.transport.sellerId}/videos`,
+      query: {
+        id: params.id,
+        sellerIntegrationStatus: params.sellerIntegrationStatus,
+        page: params.offset,
+        size: params.limit
+      },
+      rateLimiter: this.listLimiter
+    });
+    const rows = Array.isArray(data) ? data : Array.isArray(data?.content) ? data.content : Array.isArray(data?.items) ? data.items : [];
+    return rows.map((r) => {
+      const row = r ?? {};
+      const out = { raw: row };
+      if (typeof row.id === "string") out.id = row.id;
+      if (typeof row.status === "string") out.status = row.status;
+      return out;
+    });
+  }
+};
+function normalizeWebhook(node) {
+  const out = {
+    id: node.id !== void 0 ? String(node.id) : "",
+    raw: node
+  };
+  if (node.url !== void 0) out.url = node.url;
+  if (node.authenticationType !== void 0) out.authenticationType = node.authenticationType;
+  if (node.username !== void 0) out.username = node.username;
+  if (node.apiKey !== void 0) out.apiKey = node.apiKey;
+  if (node.subscribedStatuses !== void 0) out.subscribedStatuses = node.subscribedStatuses;
+  if (typeof node.active === "boolean") out.active = node.active;
+  else if (typeof node.isActive === "boolean") out.active = node.isActive;
+  else if (typeof node.status === "string") out.active = node.status.toUpperCase() === "ACTIVE";
+  return out;
+}
+var WebhooksResource = class {
+  constructor(transport, limiter) {
+    this.transport = transport;
+    this.limiter = limiter ?? new TokenBucketRateLimiter({ capacity: 50, intervalMs: 6e4 });
+  }
+  transport;
+  limiter;
+  /**
+   * Create a new webhook subscription. Trendyol caps subscriptions at 15
+   * per seller — the SDK does NOT pre-check (you'd need to call `list()`
+   * first), but Trendyol returns 400 when the cap is exceeded.
+   *
+   * @throws {ValidationError} when `url` or `authenticationType` is missing.
+   */
+  async create(input) {
+    this.validateInput(input, "create");
+    return this.transport.request({
+      method: "POST",
+      path: `/integration/sellers/${this.transport.sellerId}/webhooks`,
+      body: input,
+      rateLimiter: this.limiter
+    });
+  }
+  /** List all registered webhook subscriptions. */
+  async list() {
+    const data = await this.transport.request({
+      method: "GET",
+      path: `/integration/sellers/${this.transport.sellerId}/webhooks`,
+      rateLimiter: this.limiter
+    });
+    const rows = Array.isArray(data) ? data : Array.isArray(data?.webhooks) ? data.webhooks : Array.isArray(data?.content) ? data.content : [];
+    return rows.map((r) => normalizeWebhook(r));
+  }
+  /**
+   * Update a webhook subscription. Same input shape as `create`; replaces
+   * the whole subscription (Trendyol does NOT partially update).
+   */
+  async update(webhookId, input) {
+    this.validateInput(input, "update");
+    return this.transport.request({
+      method: "PUT",
+      path: this.webhookPath(webhookId),
+      body: input,
+      rateLimiter: this.limiter
+    });
+  }
+  /** Permanently delete a webhook subscription. */
+  async delete(webhookId) {
+    return this.transport.request({
+      method: "DELETE",
+      path: this.webhookPath(webhookId),
+      rateLimiter: this.limiter
+    });
+  }
+  /** Re-activate a previously-deactivated webhook subscription. */
+  async activate(webhookId) {
+    return this.transport.request({
+      method: "PUT",
+      path: `${this.webhookPath(webhookId)}/activate`,
+      rateLimiter: this.limiter
+    });
+  }
+  /**
+   * Deactivate a webhook subscription. Trendyol automatically deactivates
+   * a subscription after persistent delivery failures (and sends 2 emails);
+   * use `activate()` to bring it back online once your endpoint is healthy.
+   */
+  async deactivate(webhookId) {
+    return this.transport.request({
+      method: "PUT",
+      path: `${this.webhookPath(webhookId)}/deactivate`,
+      rateLimiter: this.limiter
+    });
+  }
+  validateInput(input, method) {
+    if (!input?.url || typeof input.url !== "string") {
+      throw new ValidationError({ message: `webhooks.${method}: url is required` });
+    }
+    if (input.authenticationType !== "BASIC_AUTHENTICATION" && input.authenticationType !== "API_KEY") {
+      throw new ValidationError({
+        message: `webhooks.${method}: authenticationType must be 'BASIC_AUTHENTICATION' or 'API_KEY'`
+      });
+    }
+    if (input.authenticationType === "BASIC_AUTHENTICATION") {
+      if (!input.username || !input.password) {
+        throw new ValidationError({
+          message: `webhooks.${method}: BASIC_AUTHENTICATION requires username + password`
+        });
+      }
+    } else if (!input.apiKey) {
+      throw new ValidationError({
+        message: `webhooks.${method}: API_KEY requires apiKey`
+      });
+    }
+    if (input.subscribedStatuses && input.subscribedStatuses.length === 0) ;
+  }
+  webhookPath(webhookId) {
+    return `/integration/sellers/${this.transport.sellerId}/webhooks/${encodeURIComponent(String(webhookId))}`;
+  }
+};
+
+// src/capabilities.ts
+var trendyolCapabilities = {
+  /** Trendyol has no time-bounded / scheduled pricing (`pricings[]`). */
+  scheduledPricing: false,
+  /** `inventory.update` accepts stock-only items (`quantity` with no price). */
+  stockOnlyBatch: true,
+  /** Products expose `updatedAt`, so last-write-wins guards are supported. */
+  listingUpdatedAt: true
+};
+
+// src/auth.ts
+function buildAuthHeader(apiKey, apiSecret) {
+  const token = Buffer.from(`${apiKey}:${apiSecret}`, "utf8").toString("base64");
+  return `Basic ${token}`;
+}
+function buildUserAgent(sellerId, integratorName) {
+  return `${sellerId} - ${integratorName}`;
+}
+function mapHttpError(status, body, retryAfterMs) {
+  const data = { body };
+  const issues = normalizeErrorIssues(body);
+  switch (status) {
+    case 401:
+      return new AuthError({
+        message: "Trendyol authentication failed (check apiKey / apiSecret)",
+        status,
+        data,
+        issues
+      });
+    case 403:
+      return new ValidationError({
+        message: "Trendyol forbidden (check User-Agent header or endpoint path)",
+        status,
+        data,
+        issues
+      });
+    case 404:
+      return new NotFoundError({ message: "Trendyol resource not found", status, data, issues });
+    case 429:
+      return new RateLimitError({
+        message: "Trendyol rate limit exceeded",
+        status,
+        retryAfterMs,
+        data,
+        issues
+      });
+    case 500:
+    case 502:
+    case 503:
+    case 504:
+      return new ServerError({
+        message: `Trendyol server error (${status})`,
+        status,
+        data,
+        issues
+      });
+    default:
+      return new LoncaError({
+        code: "UNKNOWN",
+        message: `Trendyol unexpected response (${status})`,
+        status,
+        data,
+        issues,
+        retryable: false
+      });
+  }
+}
+function normalizeErrorIssues(body) {
+  const errors = extractErrorsArray(body);
+  if (!errors) return [];
+  const issues = [];
+  for (const entry of errors) {
+    if (typeof entry === "string") {
+      issues.push({ message: entry });
+      continue;
+    }
+    if (entry && typeof entry === "object") {
+      const e = entry;
+      if (typeof e.message !== "string") continue;
+      const issue = { message: e.message };
+      if (typeof e.field === "string") issue.field = e.field;
+      if (typeof e.code === "string") issue.code = e.code;
+      issues.push(issue);
+    }
+  }
+  return issues;
+}
+function extractErrorsArray(body) {
+  if (!body || typeof body !== "object") return void 0;
+  const b = body;
+  if (Array.isArray(b.errors)) return b.errors;
+  const nested = b.body;
+  if (nested && typeof nested === "object") {
+    const n2 = nested;
+    if (Array.isArray(n2.errors)) return n2.errors;
+  }
+  return void 0;
+}
+function parseRetryAfter(header) {
+  if (!header) return void 0;
+  const seconds = Number(header);
+  if (!Number.isNaN(seconds)) return Math.max(0, seconds * 1e3);
+  const epoch = Date.parse(header);
+  if (!Number.isNaN(epoch)) return Math.max(0, epoch - Date.now());
+  return void 0;
+}
+
+// src/transport.ts
+var BASE_URLS = {
+  prod: "https://apigw.trendyol.com",
+  stage: "https://stageapigw.trendyol.com"
+};
+var TrendyolTransport = class {
+  constructor(config) {
+    this.config = config;
+    this.baseUrl = BASE_URLS[config.env];
+    this.logger = config.logger ?? noopLogger;
+    this.timeoutMs = config.timeoutMs ?? 3e4;
+    this.fetchImpl = config.fetch ?? fetch;
+  }
+  config;
+  baseUrl;
+  logger;
+  timeoutMs;
+  fetchImpl;
+  /** Seller ID this transport is configured with. Resources read it for path-building. */
+  get sellerId() {
+    return this.config.sellerId;
+  }
+  async request(opts) {
+    return retry(
+      async (attempt) => {
+        if (opts.rateLimiter) await opts.rateLimiter.acquire(opts.signal);
+        const url = this.buildUrl(opts.path, opts.query);
+        const correlationId = randomUUID();
+        const headers = this.buildHeaders(correlationId);
+        const init = {
+          method: opts.method,
+          headers,
+          signal: this.composeSignal(opts.signal)
+        };
+        if (opts.body !== void 0 && opts.method !== "GET") {
+          if (opts.body instanceof FormData) {
+            init.body = opts.body;
+            delete headers["Content-Type"];
+          } else {
+            init.body = JSON.stringify(opts.body);
+          }
+        }
+        this.logger.debug("trendyol.request", {
+          method: opts.method,
+          url,
+          correlationId,
+          attempt
+        });
+        let response;
+        try {
+          response = await this.fetchImpl(url, init);
+        } catch (err) {
+          if (err instanceof Error && err.name === "AbortError") {
+            throw new TimeoutError({
+              message: `Trendyol request timed out after ${this.timeoutMs}ms`,
+              cause: err
+            });
+          }
+          throw new NetworkError({
+            message: "Trendyol network failure",
+            cause: err
+          });
+        }
+        if (!response.ok) {
+          const body = await safeJson(response);
+          const retryAfterMs = parseRetryAfter(response.headers.get("retry-after"));
+          const error = mapHttpError(response.status, body, retryAfterMs);
+          this.logger.warn("trendyol.error", {
+            method: opts.method,
+            url,
+            correlationId,
+            status: response.status,
+            code: error.code,
+            retryable: error.retryable
+          });
+          throw error;
+        }
+        this.logger.debug("trendyol.response", {
+          correlationId,
+          status: response.status
+        });
+        if (response.status === 204) return void 0;
+        return await safeJson(response);
+      },
+      {
+        signal: opts.signal,
+        onRetry: (err, attempt, delay2) => {
+          if (err instanceof LoncaError) {
+            this.logger.warn("trendyol.retry", {
+              attempt,
+              delayMs: delay2,
+              code: err.code,
+              status: err.status
+            });
+          }
+        }
+      }
+    );
+  }
+  buildUrl(path, query) {
+    const url = new URL(path, this.baseUrl);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value === void 0) continue;
+        url.searchParams.set(key, String(value));
+      }
+    }
+    return url.toString();
+  }
+  buildHeaders(correlationId) {
+    return {
+      Authorization: buildAuthHeader(this.config.apiKey, this.config.apiSecret),
+      "x-clientip": this.config.clientIp ?? "127.0.0.1",
+      "x-correlationid": correlationId,
+      "x-agentname": this.config.integratorName,
+      "User-Agent": buildUserAgent(this.config.sellerId, this.config.integratorName),
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    };
+  }
+  composeSignal(external) {
+    const timeoutSignal = AbortSignal.timeout(this.timeoutMs);
+    if (!external) return timeoutSignal;
+    return AbortSignal.any([external, timeoutSignal]);
+  }
+};
+async function safeJson(response) {
+  const text = await response.text();
+  if (!text) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+// src/client.ts
+function buildClient(transport) {
+  const products = new ProductsResource(transport);
+  return {
+    brands: new BrandsResource(transport),
+    categories: new CategoriesResource(transport),
+    suppliers: new SuppliersResource(transport),
+    products,
+    inventory: new InventoryResource(transport, (id) => products.getBatchStatus(id)),
+    orders: new OrdersResource(transport),
+    claims: new ClaimsResource(transport),
+    webhooks: new WebhooksResource(transport),
+    questions: new QuestionsResource(transport),
+    invoices: new InvoicesResource(transport),
+    finance: new FinanceResource(transport),
+    labels: new LabelsResource(transport),
+    testOrders: new TestOrdersResource(transport),
+    locations: new LocationsResource(transport),
+    exportCenter: new ExportCenterResource(transport),
+    videos: new VideosResource(transport),
+    capabilities: trendyolCapabilities
+  };
+}
+
+// src/testing.ts
+function createFakeTrendyolClient(seed = {}) {
+  const batchRequestId = seed.batchRequestId ?? "fake-batch-1";
+  const batchStatus = seed.batchStatus ?? "COMPLETED";
+  const fakeFetch = (input, init) => {
+    const rawUrl = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    const url = new URL(rawUrl);
+    const req = {
+      method: (init?.method ?? "GET").toUpperCase(),
+      path: url.pathname,
+      query: url.searchParams,
+      body: parseBody(init?.body)
+    };
+    const handled = seed.handler?.(req);
+    const data = handled !== void 0 ? handled : defaultResponse(req, batchRequestId, batchStatus);
+    return Promise.resolve(jsonResponse(data));
+  };
+  const transport = new TrendyolTransport({
+    sellerId: 1,
+    apiKey: "fake",
+    apiSecret: "fake",
+    env: "stage",
+    integratorName: "fake",
+    fetch: fakeFetch
+  });
+  return buildClient(transport);
+}
+function defaultResponse(req, batchRequestId, batchStatus) {
+  if (req.method === "POST" && req.path.endsWith("/products/price-and-inventory")) {
+    return { batchRequestId };
+  }
+  if (req.method === "GET" && req.path.includes("/products/batch-requests/")) {
+    const id = decodeURIComponent(req.path.split("/").pop() ?? batchRequestId);
+    return { batchRequestId: id, status: batchStatus, itemCount: 0, failedItemCount: 0, items: [] };
+  }
+  return {};
+}
+function parseBody(body) {
+  if (typeof body !== "string") return void 0;
+  try {
+    return JSON.parse(body);
+  } catch {
+    return body;
+  }
+}
+function jsonResponse(data) {
+  return new Response(JSON.stringify(data), {
+    status: 200,
+    headers: { "content-type": "application/json" }
+  });
+}
+
+export { createFakeTrendyolClient };
+//# sourceMappingURL=testing.js.map
+//# sourceMappingURL=testing.js.map