@lonca/trendyol 0.14.0 → 0.15.0

package/dist/index.cjs

@@ -954,18 +954,23 @@ var LabelsResource = class {
    * returns, call `getCommon()` with the same `cargoTrackingNumber` to
    * retrieve the generated label.
    *
+   * Trendyol documents this endpoint (`createCommonLabel`) as a bare
+   * `200 OK` with no response body, so the SDK returns a `MutationResult`
+   * whose `raw` is whatever the gateway sent (normally `undefined`).
+   *
    * @throws {ValidationError} when `format` is missing.
    */
   async createCommon(cargoTrackingNumber, input) {
     if (!input?.format) {
       throw new core.ValidationError({ message: "labels.createCommon: format is required" });
     }
-    return this.transport.request({
+    const raw = await this.transport.request({
       method: "POST",
       path: `/integration/sellers/${this.transport.sellerId}/common-label/${encodeURIComponent(String(cargoTrackingNumber))}`,
       body: input,
       rateLimiter: this.limiter
     });
+    return { raw };
   }
   /**
    * Retrieve the previously-created common label. Trendyol returns
@@ -2415,6 +2420,9 @@ var QuestionsResource = class {
    * Reply to a question. Trendyol enforces 10–2000 characters on the
    * answer text; the SDK pre-validates client-side.
    *
+   * Trendyol documents the response as `{ answerId: number }`; the SDK
+   * surfaces it as `answerId` and keeps the untouched body on `raw`.
+   *
    * @throws {ValidationError} when `text` is outside the 10–2000 char range.
    */
   async answer(questionId, text) {
@@ -2428,12 +2436,15 @@ var QuestionsResource = class {
         message: `questions.answer: text must be at most 2000 chars (got ${text.length})`
       });
     }
-    return this.transport.request({
+    const raw = await this.transport.request({
       method: "POST",
       path: `/integration/qna/sellers/${this.transport.sellerId}/questions/${encodeURIComponent(String(questionId))}/answers`,
       body: { text },
       rateLimiter: this.limiter
     });
+    const out = { raw };
+    if (typeof raw?.answerId === "number") out.answerId = raw.answerId;
+    return out;
   }
 };
 var VALID_TYPES = /* @__PURE__ */ new Set([
@@ -2526,6 +2537,9 @@ var TestOrdersResource = class {
    * SDK forwards the typed payload verbatim — drill into Trendyol's
    * `createTestOrder` doc for inner field rules.
    *
+   * Trendyol documents the response as `{ orderNumber: string }`; the SDK
+   * surfaces it as `orderNumber` and keeps the untouched body on `raw`.
+   *
    * @throws {ValidationError} when required top-level fields are missing.
    */
   async create(input) {
@@ -2534,29 +2548,52 @@ var TestOrdersResource = class {
         throw new core.ValidationError({ message: `testOrders.create: ${k} is required` });
       }
     }
-    return this.transport.request({
+    const raw = await this.transport.request({
       method: "POST",
       path: `/integration/test/order/orders/core`,
       body: input,
       rateLimiter: this.limiter
     });
+    const out = { raw };
+    if (typeof raw?.orderNumber === "string") out.orderNumber = raw.orderNumber;
+    else if (typeof raw?.orderNumber === "number") out.orderNumber = String(raw.orderNumber);
+    return out;
   }
-  /** Push a test shipment package to the given status. */
-  async updateStatus(packageId, status) {
-    return this.transport.request({
+  /**
+   * Push a test shipment package to the given status. Trendyol's
+   * `status-updates-on-test-orders` doc shows a `{ lines, params, status }`
+   * body — pass `options` to send the documented `lines` / `params`;
+   * omitted, the body stays `{ status }` alone as before. Documented
+   * response is a bare `200 OK` (no body), hence `MutationResult`.
+   */
+  async updateStatus(packageId, status, options = {}) {
+    const raw = await this.transport.request({
       method: "PUT",
       path: `/integration/test/order/sellers/${this.transport.sellerId}/shipment-packages/${encodeURIComponent(String(packageId))}/status`,
-      body: { status },
+      body: {
+        ...options.lines !== void 0 ? { lines: options.lines } : {},
+        ...options.params !== void 0 ? { params: options.params } : {},
+        status
+      },
       rateLimiter: this.limiter
     });
+    return { raw };
   }
-  /** Move test claims to the `WaitingInAction` state. */
-  async setClaimsWaitingInAction() {
-    return this.transport.request({
+  /**
+   * Move test claims to the `WaitingInAction` state. Trendyol's
+   * `updateTestOrderStatus` doc shows a `{ shipmentPackageId }` body (the
+   * `orderShipmentPackageId` from `claims.list`); pass `input` to send it —
+   * omitted, the request goes out body-less as before. Documented response
+   * is a bare `200 OK` (no body), hence `MutationResult`.
+   */
+  async setClaimsWaitingInAction(input) {
+    const raw = await this.transport.request({
       method: "PUT",
       path: `/integration/test/order/sellers/${this.transport.sellerId}/claims/waiting-in-action`,
+      ...input ? { body: input } : {},
       rateLimiter: this.limiter
     });
+    return { raw };
   }
 };
 var VideosResource = class {
@@ -2572,18 +2609,25 @@ var VideosResource = class {
    * Queue a video for upload. Trendyol downloads from the URL in the
    * body asynchronously; poll `list()` (filtered by id) for status.
    *
+   * Trendyol documents the response as `{ videoId: string }`; the SDK
+   * surfaces it as `videoId` (pass it to `list({ id })`) and keeps the
+   * untouched body on `raw`.
+   *
    * @throws {ValidationError} when `input` is empty / not an object.
    */
   async create(input) {
     if (!input || typeof input !== "object") {
       throw new core.ValidationError({ message: "videos.create: input is required" });
     }
-    return this.transport.request({
+    const raw = await this.transport.request({
       method: "POST",
       path: `/integration/video/sellers/${this.transport.sellerId}/videos`,
       body: input,
       rateLimiter: this.createLimiter
     });
+    const out = { raw };
+    if (typeof raw?.videoId === "string") out.videoId = raw.videoId;
+    return out;
   }
   /** List the seller's integration videos (optionally filtered by id / status). */
   async list(params = {}) {
@@ -2635,16 +2679,24 @@ var WebhooksResource = class {
    * per seller — the SDK does NOT pre-check (you'd need to call `list()`
    * first), but Trendyol returns 400 when the cap is exceeded.
    *
+   * Trendyol documents the response as `{ id: string }` — the webhook ID
+   * you need for `update` / `delete` / `activate` / `deactivate`. The SDK
+   * surfaces it as `id` and keeps the untouched body on `raw`.
+   *
    * @throws {ValidationError} when `url` or `authenticationType` is missing.
    */
   async create(input) {
     this.validateInput(input, "create");
-    return this.transport.request({
+    const raw = await this.transport.request({
       method: "POST",
       path: `/integration/sellers/${this.transport.sellerId}/webhooks`,
       body: input,
       rateLimiter: this.limiter
     });
+    const out = { raw };
+    if (typeof raw?.id === "string") out.id = raw.id;
+    else if (typeof raw?.id === "number") out.id = String(raw.id);
+    return out;
   }
   /** List all registered webhook subscriptions. */
   async list() {
@@ -2659,43 +2711,57 @@ var WebhooksResource = class {
   /**
    * Update a webhook subscription. Same input shape as `create`; replaces
    * the whole subscription (Trendyol does NOT partially update).
+   *
+   * Documented response is a bare `200 OK` (no body), hence `MutationResult`.
    */
   async update(webhookId, input) {
     this.validateInput(input, "update");
-    return this.transport.request({
+    const raw = await this.transport.request({
       method: "PUT",
       path: this.webhookPath(webhookId),
       body: input,
       rateLimiter: this.limiter
     });
+    return { raw };
   }
-  /** Permanently delete a webhook subscription. */
+  /**
+   * Permanently delete a webhook subscription. Documented response is a
+   * bare `200 OK` (no body), hence `MutationResult`.
+   */
   async delete(webhookId) {
-    return this.transport.request({
+    const raw = await this.transport.request({
       method: "DELETE",
       path: this.webhookPath(webhookId),
       rateLimiter: this.limiter
     });
+    return { raw };
   }
-  /** Re-activate a previously-deactivated webhook subscription. */
+  /**
+   * Re-activate a previously-deactivated webhook subscription. Documented
+   * response is a bare `200 OK` (no body), hence `MutationResult`.
+   */
   async activate(webhookId) {
-    return this.transport.request({
+    const raw = await this.transport.request({
       method: "PUT",
       path: `${this.webhookPath(webhookId)}/activate`,
       rateLimiter: this.limiter
     });
+    return { raw };
   }
   /**
    * 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.
+   *
+   * Documented response is a bare `200 OK` (no body), hence `MutationResult`.
    */
   async deactivate(webhookId) {
-    return this.transport.request({
+    const raw = await this.transport.request({
       method: "PUT",
       path: `${this.webhookPath(webhookId)}/deactivate`,
       rateLimiter: this.limiter
     });
+    return { raw };
   }
   validateInput(input, method) {
     if (!input?.url || typeof input.url !== "string") {
@@ -2743,6 +2809,13 @@ function buildUserAgent(sellerId, integratorName) {
   return `${sellerId} - ${integratorName}`;
 }
 function mapHttpError(status, body, retryAfterMs) {
+  if ((status === 401 || status === 403) && typeof body === "string") {
+    return new core.AuthError({
+      message: `Trendyol rejected the request before it reached the API (HTTP ${status}, non-JSON body) \u2014 check IP allowlisting / credentials / User-Agent`,
+      status,
+      data: { bodyKind: /^\s*</.test(body) ? "html" : "text", bodyLength: body.length }
+    });
+  }
   const data = { body };
   const issues = normalizeErrorIssues(body);
   switch (status) {