@viu/emporix-sdk 4.6.3 → 4.6.4

package/dist/index.d.cts

@@ -9920,21 +9920,61 @@ type ImportRun$1 = {
      */
     origin?: string;
     /**
-     * The run status. `ABORTED` means the service refused to start the run because of the import configuration, for example mappings that have never been published or a changed target schema. Nothing was read or written.
-     */
-    status?: 'QUEUED' | 'RUNNING' | 'SUCCEEDED' | 'PARTIAL' | 'FAILED' | 'CANCELLED' | 'ABORTED';
+     * The run status. Possible values:
+     *
+     * * `QUEUED` – the run waits to start. Nothing has been read yet, and the run has no per-stream
+     * progress. `queueWaitingFor` says what the run waits for.
+     * * `RUNNING` – the run is executing.
+     * * `RESUMABLE` – the run was interrupted, for example by a service restart, and resumes automatically
+     * from its last checkpoint. It is not a final status.
+     * * `SUCCEEDED` – the run finished, and every record was processed.
+     * * `PARTIAL` – the run finished, but not completely: some records failed, a limit skipped records,
+     * or a stream was not run. The `message` field and the per-stream progress give the details.
+     * * `FAILED` – the run stopped because of an error.
+     * * `CANCELLED` – the run was cancelled.
+     * * `ABORTED` – the service refused to start the run because of the import configuration, for example
+     * mappings that have never been published or a changed target schema. Nothing was read or written.
+     */
+    status?: 'QUEUED' | 'RUNNING' | 'RESUMABLE' | 'SUCCEEDED' | 'PARTIAL' | 'FAILED' | 'CANCELLED' | 'ABORTED';
     /**
      * The run mode.
      */
     mode?: 'FULL' | 'DELTA';
     /**
-     * When the run started.
+     * When the run was requested. If the run was queued first, it began executing later, at `executionStartedAt`.
      */
     startedAt?: string;
+    /**
+     * When the run began executing. Equal to `startedAt`, or later by the time the run spent in the queue. `null` while the run is `QUEUED`, and on runs recorded before the field existed.
+     */
+    executionStartedAt?: string | null;
     /**
      * When the run finished.
      */
     finishedAt?: string;
+    /**
+     * `QUEUED` runs only. The run's position among the queued runs that can start, where `1` starts next. Runs of all tenants share the queue, and a tenant with fewer runs executing goes first. The value is approximate, because the queue changes while you read it. The field is absent when the run is not queued, when it waits for something other than a worker, or when the service has not yet calculated it.
+     */
+    queuePosition?: number;
+    /**
+     * `QUEUED` runs only. What the run waits for. Possible values:
+     *
+     * * `WORKER` – the run waits for a free worker. `queuePosition` gives its place in the queue.
+     * * `PREVIOUS_RUN` – the run waits for the configuration's current run to finish.
+     * * `TENANT_LIMIT` – the run waits for one of the tenant's runs to finish, because
+     * `maxConcurrentImports` runs are already executing.
+     *
+     * The field is absent when the run is not queued, or when the service has not yet calculated it.
+     */
+    queueWaitingFor?: 'WORKER' | 'PREVIOUS_RUN' | 'TENANT_LIMIT';
+    /**
+     * The number of later scheduled run requests that were added to this run while it was queued. A configuration has at most one queued run, so a scheduled request that arrives while a real run of the whole configuration is queued does not queue a second run.
+     */
+    supersededRequests?: number;
+    /**
+     * When the latest scheduled run request counted in `supersededRequests` was made. Absent when `supersededRequests` is `0`.
+     */
+    lastRequestedAt?: string;
     /**
      * Records read (created + updated + skipped + deleted + failed).
      */
@@ -9996,7 +10036,7 @@ type ImportRun$1 = {
      */
     dryRunPublished?: boolean;
     /**
-     * The published mapping version each stream uses in this run, fixed when the run starts. Version `0` means that the stream has no published mappings. The field is absent on a dry run of the draft mappings and on runs recorded before it existed.
+     * The published mapping version each stream uses in this run, fixed when the run starts executing. Version `0` means that the stream has no published mappings. The field is absent while the run is `QUEUED`, on a dry run of the draft mappings, and on runs recorded before it existed.
      */
     mappingVersions?: Array<{
         /**
@@ -10343,7 +10383,7 @@ type ImportLicense$1 = {
      */
     maxRecordsPerEntity?: number;
     /**
-     * The maximum number of runs that may be active at once for the tenant. A run requested beyond this limit is rejected with `429`.
+     * The maximum number of runs that can execute at once for the tenant. A run requested beyond this limit is not rejected. It waits in the `QUEUED` status until one of the tenant's runs finishes.
      */
     maxConcurrentImports?: number;
     /**
@@ -10422,7 +10462,7 @@ type ImportStatsSummary = {
      */
     skipRate?: number;
     /**
-     * The mean duration of a finished run, in seconds.
+     * The mean duration of a finished run, in seconds, measured from when the run began executing (`executionStartedAt`). Time spent in the queue is not counted.
      */
     avgRunDurationSec?: number;
     /**
@@ -10438,7 +10478,7 @@ type ImportStatsSummary = {
      */
     distinctEntities?: number;
     /**
-     * The number of runs currently in progress.
+     * The number of runs currently in the `QUEUED`, `RUNNING`, or `RESUMABLE` status. When you filter by `streamId`, queued runs are not counted, because they have not started any stream yet.
      */
     activeRuns?: number;
 };
@@ -10804,9 +10844,19 @@ type ImportSchedule = Schedule;
  * normal one. `origin` echoes what asked for the run, and is absent on runs
  * recorded before that field existed.
  *
+ * **Runs queue first** (since 2026-10-14). A requested run is `QUEUED` until a
+ * worker is free, then `RUNNING`; `RESUMABLE` means it was interrupted and
+ * resumes by itself — not a final status. `startedAt` is when the run was
+ * requested, `executionStartedAt` when it began executing (`null` while queued).
+ * A queued run carries `queueWaitingFor` (`WORKER`, `PREVIOUS_RUN` or
+ * `TENANT_LIMIT`) and, while it waits for a worker, an approximate
+ * `queuePosition`. `supersededRequests` counts later scheduled requests folded
+ * into it, `lastRequestedAt` the latest of them.
+ *
  * `mappingVersions` lists the published mapping version each stream runs with,
- * fixed when the run starts — version `0` means the stream has no published
- * mappings. It is absent on a dry run of the draft mappings and on runs recorded
+ * fixed when the run starts executing — version `0` means the stream has no
+ * published mappings. It is absent while the run is `QUEUED` (so on the run
+ * `triggerRun` returns), on a dry run of the draft mappings and on runs recorded
  * before 2026-09-28. `dryRunPublished` says which mappings a dry run used.
  */
 type ImportRun = ImportRun$1;
@@ -11050,6 +11100,12 @@ declare class ImportService {
      * Trigger a run. `mode` defaults to `DELTA` server-side; `dryRun: true` maps
      * and validates without writing to the target.
      *
+     * **The run comes back `QUEUED`, not `RUNNING`.** It starts when a worker is
+     * free, usually within moments, or after one of the tenant's runs finishes when
+     * `maxConcurrentImports` are already executing — no `429` any more. A
+     * configuration holds at most one executing and one queued run: while it has a
+     * run `QUEUED`, `RUNNING` or `RESUMABLE`, this call answers `409`.
+     *
      * A dry run can also hand back what it *would* have written: pass
      * `sampleSize` (1–100, default 25) and read the run's `dryRunSample`. Set
      * `origin` to name what asked for the run — `trigger` only distinguishes
@@ -11113,6 +11169,9 @@ declare class ImportService {
      * with `accepted: false` when the run is unknown or already finished — that is
      * a result, not an error. A state conflict may instead come back as a `409`,
      * which does throw.
+     *
+     * A `QUEUED` run is cancelled at once, with or without `force`. A `RESUMABLE`
+     * run stops only with `force: true`; without it the call answers `409`.
      */
     cancelRun(runId: string, opts?: {
         force?: boolean;
@@ -11183,7 +11242,9 @@ declare class ImportService {
      */
     getHealthThresholds(auth?: AuthContext): Promise<ImportHealthThresholds>;
     /**
-     * The tenant's import limits and current consumption.
+     * The tenant's import limits and current consumption. `maxConcurrentImports`
+     * caps executing runs only: a run beyond it waits `QUEUED` instead of being
+     * rejected.
      *
      * **Preview upstream**: the contract may change without a major bump.
      */
@@ -11193,8 +11254,10 @@ declare class ImportService {
      *
      * Returns a **new** run — the retry is its own run with `retry: true`, not a
      * mutation of the original. Poll it with {@link getRun} or follow it with
-     * {@link streamRun} exactly as you would a triggered run. Like one, it runs the
-     * published mappings and can finish `ABORTED`.
+     * {@link streamRun} exactly as you would a triggered run. Like one, it comes
+     * back `QUEUED`, answers `409` while the configuration has a run `QUEUED`,
+     * `RUNNING` or `RESUMABLE`, runs the published mappings and can finish
+     * `ABORTED`.
      *
      * Not retried on a 5xx, for the same reason {@link triggerRun} is not: a POST
      * that timed out may already have queued the retry.

package/dist/index.d.ts

@@ -9920,21 +9920,61 @@ type ImportRun$1 = {
      */
     origin?: string;
     /**
-     * The run status. `ABORTED` means the service refused to start the run because of the import configuration, for example mappings that have never been published or a changed target schema. Nothing was read or written.
-     */
-    status?: 'QUEUED' | 'RUNNING' | 'SUCCEEDED' | 'PARTIAL' | 'FAILED' | 'CANCELLED' | 'ABORTED';
+     * The run status. Possible values:
+     *
+     * * `QUEUED` – the run waits to start. Nothing has been read yet, and the run has no per-stream
+     * progress. `queueWaitingFor` says what the run waits for.
+     * * `RUNNING` – the run is executing.
+     * * `RESUMABLE` – the run was interrupted, for example by a service restart, and resumes automatically
+     * from its last checkpoint. It is not a final status.
+     * * `SUCCEEDED` – the run finished, and every record was processed.
+     * * `PARTIAL` – the run finished, but not completely: some records failed, a limit skipped records,
+     * or a stream was not run. The `message` field and the per-stream progress give the details.
+     * * `FAILED` – the run stopped because of an error.
+     * * `CANCELLED` – the run was cancelled.
+     * * `ABORTED` – the service refused to start the run because of the import configuration, for example
+     * mappings that have never been published or a changed target schema. Nothing was read or written.
+     */
+    status?: 'QUEUED' | 'RUNNING' | 'RESUMABLE' | 'SUCCEEDED' | 'PARTIAL' | 'FAILED' | 'CANCELLED' | 'ABORTED';
     /**
      * The run mode.
      */
     mode?: 'FULL' | 'DELTA';
     /**
-     * When the run started.
+     * When the run was requested. If the run was queued first, it began executing later, at `executionStartedAt`.
      */
     startedAt?: string;
+    /**
+     * When the run began executing. Equal to `startedAt`, or later by the time the run spent in the queue. `null` while the run is `QUEUED`, and on runs recorded before the field existed.
+     */
+    executionStartedAt?: string | null;
     /**
      * When the run finished.
      */
     finishedAt?: string;
+    /**
+     * `QUEUED` runs only. The run's position among the queued runs that can start, where `1` starts next. Runs of all tenants share the queue, and a tenant with fewer runs executing goes first. The value is approximate, because the queue changes while you read it. The field is absent when the run is not queued, when it waits for something other than a worker, or when the service has not yet calculated it.
+     */
+    queuePosition?: number;
+    /**
+     * `QUEUED` runs only. What the run waits for. Possible values:
+     *
+     * * `WORKER` – the run waits for a free worker. `queuePosition` gives its place in the queue.
+     * * `PREVIOUS_RUN` – the run waits for the configuration's current run to finish.
+     * * `TENANT_LIMIT` – the run waits for one of the tenant's runs to finish, because
+     * `maxConcurrentImports` runs are already executing.
+     *
+     * The field is absent when the run is not queued, or when the service has not yet calculated it.
+     */
+    queueWaitingFor?: 'WORKER' | 'PREVIOUS_RUN' | 'TENANT_LIMIT';
+    /**
+     * The number of later scheduled run requests that were added to this run while it was queued. A configuration has at most one queued run, so a scheduled request that arrives while a real run of the whole configuration is queued does not queue a second run.
+     */
+    supersededRequests?: number;
+    /**
+     * When the latest scheduled run request counted in `supersededRequests` was made. Absent when `supersededRequests` is `0`.
+     */
+    lastRequestedAt?: string;
     /**
      * Records read (created + updated + skipped + deleted + failed).
      */
@@ -9996,7 +10036,7 @@ type ImportRun$1 = {
      */
     dryRunPublished?: boolean;
     /**
-     * The published mapping version each stream uses in this run, fixed when the run starts. Version `0` means that the stream has no published mappings. The field is absent on a dry run of the draft mappings and on runs recorded before it existed.
+     * The published mapping version each stream uses in this run, fixed when the run starts executing. Version `0` means that the stream has no published mappings. The field is absent while the run is `QUEUED`, on a dry run of the draft mappings, and on runs recorded before it existed.
      */
     mappingVersions?: Array<{
         /**
@@ -10343,7 +10383,7 @@ type ImportLicense$1 = {
      */
     maxRecordsPerEntity?: number;
     /**
-     * The maximum number of runs that may be active at once for the tenant. A run requested beyond this limit is rejected with `429`.
+     * The maximum number of runs that can execute at once for the tenant. A run requested beyond this limit is not rejected. It waits in the `QUEUED` status until one of the tenant's runs finishes.
      */
     maxConcurrentImports?: number;
     /**
@@ -10422,7 +10462,7 @@ type ImportStatsSummary = {
      */
     skipRate?: number;
     /**
-     * The mean duration of a finished run, in seconds.
+     * The mean duration of a finished run, in seconds, measured from when the run began executing (`executionStartedAt`). Time spent in the queue is not counted.
      */
     avgRunDurationSec?: number;
     /**
@@ -10438,7 +10478,7 @@ type ImportStatsSummary = {
      */
     distinctEntities?: number;
     /**
-     * The number of runs currently in progress.
+     * The number of runs currently in the `QUEUED`, `RUNNING`, or `RESUMABLE` status. When you filter by `streamId`, queued runs are not counted, because they have not started any stream yet.
      */
     activeRuns?: number;
 };
@@ -10804,9 +10844,19 @@ type ImportSchedule = Schedule;
  * normal one. `origin` echoes what asked for the run, and is absent on runs
  * recorded before that field existed.
  *
+ * **Runs queue first** (since 2026-10-14). A requested run is `QUEUED` until a
+ * worker is free, then `RUNNING`; `RESUMABLE` means it was interrupted and
+ * resumes by itself — not a final status. `startedAt` is when the run was
+ * requested, `executionStartedAt` when it began executing (`null` while queued).
+ * A queued run carries `queueWaitingFor` (`WORKER`, `PREVIOUS_RUN` or
+ * `TENANT_LIMIT`) and, while it waits for a worker, an approximate
+ * `queuePosition`. `supersededRequests` counts later scheduled requests folded
+ * into it, `lastRequestedAt` the latest of them.
+ *
  * `mappingVersions` lists the published mapping version each stream runs with,
- * fixed when the run starts — version `0` means the stream has no published
- * mappings. It is absent on a dry run of the draft mappings and on runs recorded
+ * fixed when the run starts executing — version `0` means the stream has no
+ * published mappings. It is absent while the run is `QUEUED` (so on the run
+ * `triggerRun` returns), on a dry run of the draft mappings and on runs recorded
  * before 2026-09-28. `dryRunPublished` says which mappings a dry run used.
  */
 type ImportRun = ImportRun$1;
@@ -11050,6 +11100,12 @@ declare class ImportService {
      * Trigger a run. `mode` defaults to `DELTA` server-side; `dryRun: true` maps
      * and validates without writing to the target.
      *
+     * **The run comes back `QUEUED`, not `RUNNING`.** It starts when a worker is
+     * free, usually within moments, or after one of the tenant's runs finishes when
+     * `maxConcurrentImports` are already executing — no `429` any more. A
+     * configuration holds at most one executing and one queued run: while it has a
+     * run `QUEUED`, `RUNNING` or `RESUMABLE`, this call answers `409`.
+     *
      * A dry run can also hand back what it *would* have written: pass
      * `sampleSize` (1–100, default 25) and read the run's `dryRunSample`. Set
      * `origin` to name what asked for the run — `trigger` only distinguishes
@@ -11113,6 +11169,9 @@ declare class ImportService {
      * with `accepted: false` when the run is unknown or already finished — that is
      * a result, not an error. A state conflict may instead come back as a `409`,
      * which does throw.
+     *
+     * A `QUEUED` run is cancelled at once, with or without `force`. A `RESUMABLE`
+     * run stops only with `force: true`; without it the call answers `409`.
      */
     cancelRun(runId: string, opts?: {
         force?: boolean;
@@ -11183,7 +11242,9 @@ declare class ImportService {
      */
     getHealthThresholds(auth?: AuthContext): Promise<ImportHealthThresholds>;
     /**
-     * The tenant's import limits and current consumption.
+     * The tenant's import limits and current consumption. `maxConcurrentImports`
+     * caps executing runs only: a run beyond it waits `QUEUED` instead of being
+     * rejected.
      *
      * **Preview upstream**: the contract may change without a major bump.
      */
@@ -11193,8 +11254,10 @@ declare class ImportService {
      *
      * Returns a **new** run — the retry is its own run with `retry: true`, not a
      * mutation of the original. Poll it with {@link getRun} or follow it with
-     * {@link streamRun} exactly as you would a triggered run. Like one, it runs the
-     * published mappings and can finish `ABORTED`.
+     * {@link streamRun} exactly as you would a triggered run. Like one, it comes
+     * back `QUEUED`, answers `409` while the configuration has a run `QUEUED`,
+     * `RUNNING` or `RESUMABLE`, runs the published mappings and can finish
+     * `ABORTED`.
      *
      * Not retried on a 5xx, for the same reason {@link triggerRun} is not: a POST
      * that timed out may already have queued the retry.

package/dist/index.js

@@ -948,7 +948,7 @@ var HttpClient = class {
 };
 
 // package.json
-var version = "4.6.3";
+var version = "4.6.4";
 
 // src/version.ts
 var SDK_VERSION = version;
@@ -4694,6 +4694,12 @@ var ImportService = class {
    * Trigger a run. `mode` defaults to `DELTA` server-side; `dryRun: true` maps
    * and validates without writing to the target.
    *
+   * **The run comes back `QUEUED`, not `RUNNING`.** It starts when a worker is
+   * free, usually within moments, or after one of the tenant's runs finishes when
+   * `maxConcurrentImports` are already executing — no `429` any more. A
+   * configuration holds at most one executing and one queued run: while it has a
+   * run `QUEUED`, `RUNNING` or `RESUMABLE`, this call answers `409`.
+   *
    * A dry run can also hand back what it *would* have written: pass
    * `sampleSize` (1–100, default 25) and read the run's `dryRunSample`. Set
    * `origin` to name what asked for the run — `trigger` only distinguishes
@@ -4786,6 +4792,9 @@ var ImportService = class {
    * with `accepted: false` when the run is unknown or already finished — that is
    * a result, not an error. A state conflict may instead come back as a `409`,
    * which does throw.
+   *
+   * A `QUEUED` run is cancelled at once, with or without `force`. A `RESUMABLE`
+   * run stops only with `force: true`; without it the call answers `409`.
    */
   async cancelRun(runId, opts = {}, auth2 = SERVICE23) {
     const query = {};
@@ -4943,7 +4952,9 @@ var ImportService = class {
     });
   }
   /**
-   * The tenant's import limits and current consumption.
+   * The tenant's import limits and current consumption. `maxConcurrentImports`
+   * caps executing runs only: a run beyond it waits `QUEUED` instead of being
+   * rejected.
    *
    * **Preview upstream**: the contract may change without a major bump.
    */
@@ -4959,8 +4970,10 @@ var ImportService = class {
    *
    * Returns a **new** run — the retry is its own run with `retry: true`, not a
    * mutation of the original. Poll it with {@link getRun} or follow it with
-   * {@link streamRun} exactly as you would a triggered run. Like one, it runs the
-   * published mappings and can finish `ABORTED`.
+   * {@link streamRun} exactly as you would a triggered run. Like one, it comes
+   * back `QUEUED`, answers `409` while the configuration has a run `QUEUED`,
+   * `RUNNING` or `RESUMABLE`, runs the published mappings and can finish
+   * `ABORTED`.
    *
    * Not retried on a 5xx, for the same reason {@link triggerRun} is not: a POST
    * that timed out may already have queued the retry.