@delopay/sdk 0.289.0 → 0.290.0

package/dist/index.cjs

@@ -114,7 +114,9 @@ __export(index_exports, {
   PaypalDisputes: () => PaypalDisputes,
   PresentationCache: () => PresentationCache,
   ProcessorCosts: () => ProcessorCosts,
+  ProcessorImports: () => ProcessorImports,
   Products: () => Products,
+  PspImportEventStream: () => PspImportEventStream,
   RTL_CHECKOUT_LOCALES: () => RTL_CHECKOUT_LOCALES,
   Regions: () => Regions,
   Risk: () => Risk,
@@ -2002,6 +2004,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.
    *
@@ -9726,6 +9766,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)}`;
@@ -10040,6 +10206,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);
@@ -15303,7 +15470,9 @@ var encodeNativePanes = encodePanes;
   PaypalDisputes,
   PresentationCache,
   ProcessorCosts,
+  ProcessorImports,
   Products,
+  PspImportEventStream,
   RTL_CHECKOUT_LOCALES,
   Regions,
   Risk,