@delopay/sdk 0.289.0 → 0.291.0

package/dist/internal.cjs

@@ -132,7 +132,9 @@ __export(internal_exports, {
   PlatformSettings: () => PlatformSettings,
   PresentationCache: () => PresentationCache,
   ProcessorCosts: () => ProcessorCosts,
+  ProcessorImports: () => ProcessorImports,
   Products: () => Products,
+  PspImportEventStream: () => PspImportEventStream,
   RTL_CHECKOUT_LOCALES: () => RTL_CHECKOUT_LOCALES,
   Regions: () => Regions,
   Risk: () => Risk,
@@ -2020,6 +2022,44 @@ var Disputes = class {
       options
     );
   }
+  /**
+   * What a bulk action would do to the selected cases, changing nothing:
+   * each case as eligible or skipped with a reason, and what the eligible ones
+   * add up to per currency. Name the cases by `ids` or by the list's
+   * `filters`, exactly one of the two; at most `max_cases` are read.
+   *
+   * `POST /disputes/workspace/bulk/preview`. Needs a dashboard JWT.
+   */
+  async bulkPreview(request) {
+    const { filters, ...rest } = request;
+    return this.request("POST", "/disputes/workspace/bulk/preview", {
+      body: filters ? { ...rest, filters: workspaceQuery(filters) } : rest
+    });
+  }
+  /**
+   * Accept the listed cases at their processors, at most the preview's
+   * `max_run_cases` per call; send a larger set in parts under one
+   * `request_id`. Eligibility is decided again at run time, and every case
+   * gets its own result. An `unknown` result means the processor may have
+   * acted: read the case before acting on it again.
+   *
+   * `POST /disputes/workspace/bulk/accept`. Needs a dashboard JWT.
+   */
+  async bulkAccept(request) {
+    return this.request("POST", "/disputes/workspace/bulk/accept", { body: request });
+  }
+  /**
+   * Add the buyer of each listed case's payment to the buyer blocklist: the
+   * payment's email and customer id, and the device ids and IP address of the
+   * browser that paid, when DeloPay can tie them to it. Identifiers already
+   * blocked are not added again, and `unattributed` names those it could not
+   * tie to the buyer.
+   *
+   * `POST /disputes/workspace/bulk/block-buyer`. Needs a dashboard JWT.
+   */
+  async bulkBlockBuyer(request) {
+    return this.request("POST", "/disputes/workspace/bulk/block-buyer", { body: request });
+  }
   /**
    * Retrieve a dispute by its ID.
    *
@@ -3619,15 +3659,21 @@ var Projects = class {
     this.request = request;
   }
   /**
-   * Create a new project under a merchant account.
+   * Create a new project under a merchant account. Pass `parent_id` to create
+   * it as a sub-project; past the merchant's maximum depth it is refused with
+   * `400` and code `PR_01` (`project_depth_exceeded`).
    *
-   * @param params - Project creation parameters (name, description, etc.).
+   * @param params - Project creation parameters (name, description, parent).
    * @param merchantId - The merchant account ID that owns this project.
    * @returns The created project.
    *
    * @example
    * ```typescript
-   * const project = await delopay.projects.create({ name: 'EU Stores' }, 'merch_123');
+   * const eu = await delopay.projects.create({ project_name: 'EU Stores' }, 'merch_123');
+   * const de = await delopay.projects.create(
+   *   { project_name: 'Germany', parent_id: eu.id },
+   *   'merch_123',
+   * );
    * ```
    */
   async create(params, merchantId) {
@@ -3652,7 +3698,14 @@ var Projects = class {
     return this.request("GET", path, { query: { merchant_id: merchantId } });
   }
   /**
-   * Update a project's details.
+   * Update a project's details, or move it with `parent_id` (omitted keeps the
+   * parent, `null` makes it a top-level project, an id moves it under that
+   * project). A move is refused with `PR_01` when the moved subtree would
+   * exceed the maximum depth and with `PR_02` (`project_cycle`) when the target
+   * is the project itself or one of its sub-projects. When the merchant's
+   * project tree changed while the move was being checked, it is refused with
+   * `409` and code `PR_05` (`project_tree_changed`): read the tree again and
+   * retry.
    *
    * @param projectId - The project ID to update.
    * @param params - Fields to update.
@@ -3668,6 +3721,9 @@ var Projects = class {
    * Delete a project.
    *
    * @param projectId - The project ID to delete.
+   * Refused with `409` and code `PR_03` (`project_not_empty`) while the
+   * project still has sub-projects or shops; move or delete those first.
+   *
    * @param merchantId - Optional merchant scope. See {@link Projects.retrieve}.
    * @returns The deleted project object.
    */
@@ -3677,7 +3733,9 @@ var Projects = class {
     return this.request("DELETE", path, { query: { merchant_id: merchantId } });
   }
   /**
-   * List all projects for a merchant.
+   * List all projects for a merchant, at every level, as a flat array. Rebuild
+   * the tree from each project's `parent_id`; `level`, `path`,
+   * `child_project_count` and `direct_shop_count` are filled in for each one.
    *
    * @param merchantId - The merchant account ID.
    * @returns Array of projects.
@@ -3690,6 +3748,11 @@ var Projects = class {
   /**
    * Get aggregate payment statistics across all projects for a merchant.
    *
+   * Each project's figures cover its whole subtree (its own shops and the
+   * shops of its sub-projects); `projects[].direct` holds the figures for the
+   * project's own shops only, and `projects[].shops[]` lists only those. The
+   * merchant totals count each shop once.
+   *
    * The response's flat `shops[]` array holds every shop, including shops that
    * belong to no project — those are absent from `projects[].shops[]`, so look
    * a single shop up in `shops[]`. Requires `MerchantAccountRead`; a
@@ -3711,6 +3774,26 @@ var Projects = class {
     if (period !== void 0) query["period"] = String(period);
     return this.request("GET", "/projects/stats", { query });
   }
+  /**
+   * Get the project-depth limit that applies to a merchant: the maximum number
+   * of project levels, where that limit comes from, and how deep the
+   * merchant's tree currently is. Use it to tell whether a project can take a
+   * sub-project (`project.level < max_depth`) before offering the action.
+   *
+   * @param merchantId - The merchant account ID.
+   * @returns The merchant's project limits.
+   *
+   * @example
+   * ```typescript
+   * const { max_depth } = await delopay.projects.limits('merch_123');
+   * const canNest = project.level < max_depth;
+   * ```
+   */
+  async limits(merchantId) {
+    return this.request("GET", "/projects/limits", {
+      query: { merchant_id: merchantId }
+    });
+  }
   /**
    * Get a high-level overview (volume, counts, top connectors) for a merchant.
    *
@@ -9744,6 +9827,132 @@ var Live = class {
   }
 };
 
+// src/resources/processorImports.ts
+function toPspImportStreamEvent(event) {
+  switch (event.type) {
+    case "progress": {
+      let run;
+      try {
+        run = JSON.parse(event.data);
+      } catch {
+        return null;
+      }
+      if (run === null || typeof run !== "object" || Array.isArray(run)) return null;
+      return { type: "progress", run };
+    }
+    case "done":
+      return { type: "done" };
+    default:
+      return null;
+  }
+}
+var PspImportEventStream = class {
+  constructor(connection) {
+    this.connection = connection;
+  }
+  /** Close the stream; the iteration ends without an error. */
+  close() {
+    this.connection.close();
+  }
+  [Symbol.asyncIterator]() {
+    this.iterator ?? (this.iterator = this.events());
+    return this.iterator;
+  }
+  async *events() {
+    for await (const dispatch of this.connection.dispatches) {
+      if (!dispatch.event) continue;
+      const event = toPspImportStreamEvent(dispatch.event);
+      if (event) yield event;
+    }
+  }
+};
+var ProcessorImports = class {
+  constructor(request, openStream) {
+    this.request = request;
+    this.openStream = openStream;
+  }
+  /**
+   * Every connected processor account the caller may see, with what each can
+   * provide in the environment: listed, read payment by payment, or
+   * unavailable with a reason.
+   *
+   * `GET /refunds-disputes/imports/sources`
+   */
+  async sources(params) {
+    return this.request("GET", "/refunds-disputes/imports/sources", {
+      query: { test_mode: params.test_mode }
+    });
+  }
+  /**
+   * Start an import. A source a processor cannot provide is stored as
+   * `unavailable` with its reason. Refused while another import of the
+   * merchant runs in the same environment.
+   *
+   * `POST /refunds-disputes/imports`
+   */
+  async create(request) {
+    return this.request("POST", "/refunds-disputes/imports", { body: request });
+  }
+  /**
+   * The newest import in the environment, running or finished.
+   *
+   * `GET /refunds-disputes/imports/latest`
+   */
+  async latest(params) {
+    return this.request("GET", "/refunds-disputes/imports/latest", {
+      query: { test_mode: params.test_mode }
+    });
+  }
+  /** `GET /refunds-disputes/imports/{id}` */
+  async retrieve(id) {
+    return this.request("GET", `/refunds-disputes/imports/${encodeURIComponent(id)}`);
+  }
+  /**
+   * The records an import left out or could not record, each with its reason.
+   *
+   * `GET /refunds-disputes/imports/{id}/issues`
+   */
+  async issues(id, params) {
+    return this.request("GET", `/refunds-disputes/imports/${encodeURIComponent(id)}/issues`, {
+      query: { limit: params?.limit, offset: params?.offset }
+    });
+  }
+  /**
+   * Ask a running import to stop. It stops after the page it is reading;
+   * what it recorded stays recorded.
+   *
+   * `POST /refunds-disputes/imports/{id}/cancel`
+   */
+  async cancel(id) {
+    return this.request("POST", `/refunds-disputes/imports/${encodeURIComponent(id)}/cancel`);
+  }
+  /**
+   * Open the progress stream of an import. Resolves once the server answered;
+   * a `401` rejects with `DelopayAuthenticationError`.
+   *
+   * `GET /refunds-disputes/imports/{id}/stream`
+   *
+   * @example
+   * ```typescript
+   * const stream = await delopay.processorImports.stream(run.id, { signal });
+   * for await (const event of stream) {
+   *   if (event.type === 'progress') render(event.run);
+   * }
+   * ```
+   */
+  async stream(id, options = {}) {
+    const connection = await this.openStream(
+      `/refunds-disputes/imports/${encodeURIComponent(id)}/stream`,
+      {
+        ...options.signal ? { signal: options.signal } : {},
+        ...options.idleTimeoutMs !== void 0 ? { idleTimeoutMs: options.idleTimeoutMs } : {},
+        ...options.headers ? { headers: options.headers } : {}
+      }
+    );
+    return new PspImportEventStream(connection);
+  }
+};
+
 // src/resources/deploymentBranding.ts
 function brandingAssetPath(asset, version) {
   const path = `/branding/assets/${encodeURIComponent(asset)}`;
@@ -10058,6 +10267,7 @@ var Delopay = class {
     this.messageTemplates = new MessageTemplates(request);
     this.risk = new Risk(request);
     this.live = new Live(request, openStream);
+    this.processorImports = new ProcessorImports(request, openStream);
     this.branding = new Branding(request, this.baseUrl);
     this.subscriptions = new Subscriptions(request);
     this.buyerPortal = new BuyerPortal(request);
@@ -17189,7 +17399,9 @@ var DelopayInternal = class extends Delopay {
   PlatformSettings,
   PresentationCache,
   ProcessorCosts,
+  ProcessorImports,
   Products,
+  PspImportEventStream,
   RTL_CHECKOUT_LOCALES,
   Regions,
   Risk,