@truenas/api-client 1.0.13 → 2.0.0

package/dist/index.cjs

@@ -10,76 +10,6 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/enums/truenas-endpoint.enum.ts
-var TrueNasEndpoint = /* @__PURE__ */ ((TrueNasEndpoint2) => {
-  TrueNasEndpoint2["UpdateStatus"] = "update.status";
-  TrueNasEndpoint2["AppQuery"] = "app.query";
-  TrueNasEndpoint2["AppStart"] = "app.start";
-  TrueNasEndpoint2["AppStop"] = "app.stop";
-  TrueNasEndpoint2["AppRedeploy"] = "app.redeploy";
-  TrueNasEndpoint2["AppUpgrade"] = "app.upgrade";
-  TrueNasEndpoint2["CoreSubscribe"] = "core.subscribe";
-  TrueNasEndpoint2["ReplicationQuery"] = "replication.query";
-  TrueNasEndpoint2["ReplicationRun"] = "replication.run";
-  TrueNasEndpoint2["InterfaceQuery"] = "interface.query";
-  TrueNasEndpoint2["CloudBackupQuery"] = "cloud_backup.query";
-  TrueNasEndpoint2["CloudSyncQuery"] = "cloudsync.query";
-  TrueNasEndpoint2["VirtualInstanceQuery"] = "virt.instance.query";
-  TrueNasEndpoint2["VirtualInstanceStop"] = "virt.instance.stop";
-  TrueNasEndpoint2["VirtualInstanceStart"] = "virt.instance.start";
-  TrueNasEndpoint2["VirtualInstanceRestart"] = "virt.instance.restart";
-  TrueNasEndpoint2["ContainerQuery"] = "container.query";
-  TrueNasEndpoint2["ContainerStart"] = "container.start";
-  TrueNasEndpoint2["ContainerStop"] = "container.stop";
-  TrueNasEndpoint2["VmQuery"] = "vm.query";
-  TrueNasEndpoint2["VmStart"] = "vm.start";
-  TrueNasEndpoint2["VmStop"] = "vm.stop";
-  TrueNasEndpoint2["VmRestart"] = "vm.restart";
-  TrueNasEndpoint2["CoreDownload"] = "core.download";
-  TrueNasEndpoint2["CoreGetJobs"] = "core.get_jobs";
-  TrueNasEndpoint2["SystemInfo"] = "system.info";
-  TrueNasEndpoint2["SystemProductType"] = "system.product_type";
-  TrueNasEndpoint2["ExtendedSystemInfo"] = "webui.main.dashboard.sys_info";
-  TrueNasEndpoint2["DiskQuery"] = "disk.query";
-  TrueNasEndpoint2["DeviceGetInfo"] = "device.get_info";
-  TrueNasEndpoint2["CorePing"] = "core.ping";
-  TrueNasEndpoint2["GenerateToken"] = "auth.generate_token";
-  TrueNasEndpoint2["AlertList"] = "alert.list";
-  TrueNasEndpoint2["AuthLogin"] = "auth.login_ex";
-  TrueNasEndpoint2["AuthLogout"] = "auth.logout";
-  TrueNasEndpoint2["ApiKeyQuery"] = "api_key.query";
-  TrueNasEndpoint2["ApiKeyCreate"] = "api_key.create";
-  TrueNasEndpoint2["ApiKeyDelete"] = "api_key.delete";
-  TrueNasEndpoint2["FailOverStatus"] = "failover.status";
-  TrueNasEndpoint2["FailOverNode"] = "failover.node";
-  TrueNasEndpoint2["FailOverDisabledReasons"] = "failover.disabled.reasons";
-  TrueNasEndpoint2["PoolQuery"] = "pool.query";
-  TrueNasEndpoint2["DatasetQuery"] = "pool.dataset.query";
-  TrueNasEndpoint2["DatasetCreate"] = "pool.dataset.create";
-  TrueNasEndpoint2["DatasetDelete"] = "pool.dataset.delete";
-  TrueNasEndpoint2["SnapshotTaskCreate"] = "pool.snapshottask.create";
-  TrueNasEndpoint2["SnapshotTaskQuery"] = "pool.snapshottask.query";
-  TrueNasEndpoint2["SnapshotTaskDelete"] = "pool.snapshottask.delete";
-  TrueNasEndpoint2["SnapshotCreate"] = "pool.snapshot.create";
-  TrueNasEndpoint2["SnapshotDelete"] = "pool.snapshot.delete";
-  TrueNasEndpoint2["ReplicationCountEligibleSnapshots"] = "replication.count_eligible_manual_snapshots";
-  TrueNasEndpoint2["BootGetState"] = "boot.get_state";
-  TrueNasEndpoint2["TnConnectUpdate"] = "tn_connect.update";
-  TrueNasEndpoint2["HardwareVirtualizationVariant"] = "hardware.virtualization.variant";
-  TrueNasEndpoint2["KeychainCredentialGenerateSshKeyPair"] = "keychaincredential.generate_ssh_key_pair";
-  TrueNasEndpoint2["KeychainCredentialCreate"] = "keychaincredential.create";
-  TrueNasEndpoint2["KeychainCredentialRemoteSshHostKeyScan"] = "keychaincredential.remote_ssh_host_key_scan";
-  TrueNasEndpoint2["KeychainCredentialDelete"] = "keychaincredential.delete";
-  TrueNasEndpoint2["ReplicationCreate"] = "replication.create";
-  TrueNasEndpoint2["UserQuery"] = "user.query";
-  TrueNasEndpoint2["UserUpdate"] = "user.update";
-  TrueNasEndpoint2["NetworkConfiguration"] = "network.configuration.config";
-  TrueNasEndpoint2["ServiceQuery"] = "service.query";
-  TrueNasEndpoint2["ServiceUpdate"] = "service.update";
-  TrueNasEndpoint2["ServiceControl"] = "service.control";
-  return TrueNasEndpoint2;
-})(TrueNasEndpoint || {});
-
 // src/types/api-error.type.ts
 function isJsonRpcError(error) {
   return typeof error === "object" && error !== null && "message" in error && typeof error.message === "string";
@@ -114,6 +44,16 @@ var JobState = /* @__PURE__ */ ((JobState2) => {
   JobState2["Waiting"] = "WAITING";
   return JobState2;
 })(JobState || {});
+var terminalStates = [
+  "SUCCESS" /* Success */,
+  "FAILED" /* Failed */,
+  "ABORTED" /* Aborted */,
+  "ERROR" /* Error */,
+  "FINISHED" /* Finished */
+];
+function isJobFinished(job) {
+  return terminalStates.includes(job.state);
+}
 var withId = (id) => rxjs.filter((msg) => msg.id === id);
 function randomUUID() {
   if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
@@ -140,6 +80,7 @@ function createJsonRpcMessage(method, params) {
 }
 
 // src/api/truenas-api.ts
+var EVENT_KINDS = ["added", "changed", "removed"];
 var TrueNasApi = class {
   constructor(authenticated, connection) {
     this.authenticated = authenticated;
@@ -156,33 +97,67 @@ var TrueNasApi = class {
       rxjs.filter((job) => !!job?.id),
       rxjs.share()
     );
+    /**
+     * One shared stream per subscribed event name — see {@link events}.
+     * Keyed by name rather than by caller, because the subscription it stands
+     * for lives on the server and is per socket, not per caller.
+     */
+    this.eventStreams = /* @__PURE__ */ new Map();
     this.initializeJobEventsSubscription();
   }
-  call(method, params) {
-    return this.dispatch(method, params);
+  /**
+   * Send a request to a method of the surface this instance is typed against,
+   * and emit its result.
+   *
+   * ```typescript
+   * api.call('system.info')                      // SystemInfo
+   * api.call('pool.dataset.delete', ['tank/ds', { recursive: true }])
+   * ```
+   *
+   * `params` is required exactly when the method takes them — the directory
+   * says which — so a method that needs an id cannot be called without one.
+   *
+   * The polymorphic `.query` methods are reachable here too, but their
+   * `response` is the five-way union the server may return, which is
+   * {@link query} / {@link queryOne} / {@link queryCount}'s job to resolve.
+   * Reach for a verb instead.
+   */
+  call(method, ...params) {
+    return this.dispatch(method, params[0]);
   }
   /**
    * Send a JSON-RPC request and emit its result.
    *
-   * Shared by {@link call} and the query verbs, which type the same wire call
-   * against different directories — `call` against the hand-maintained one,
-   * the verbs against the generated one.
+   * Shared by {@link call} and the query verbs, which read the same directory
+   * but resolve different things from it: `call` takes the entry's `response`
+   * verbatim, the verbs narrow its polymorphic union by the verb chosen.
+   *
+   * Also the way the class reaches methods on its own behalf — `core.get_jobs`,
+   * `auth.generate_token`. Inside the class body `D` is a type parameter, so
+   * the checker cannot know those are among its methods; they are, since both
+   * are in the shared base every surface extends.
    */
   dispatch(method, params) {
-    const message = createJsonRpcMessage(method, params);
-    this.connection.ws.next(message);
-    const messageId = message.id ?? "";
-    return this.connection.messages().pipe(
-      withId(messageId),
-      rxjs.map((msg) => {
-        if (msg.error) {
-          const errorMessage = getApiErrorMessage(msg.error, "API call failed");
-          throw new Error(errorMessage);
-        }
-        return msg.result;
-      }),
-      rxjs.take(1)
-    );
+    return rxjs.defer(() => {
+      const message = createJsonRpcMessage(method, params);
+      const messageId = message.id ?? "";
+      const reply = this.connection.messages().pipe(
+        withId(messageId),
+        rxjs.map((msg) => {
+          if (msg.error) {
+            const errorMessage = getApiErrorMessage(
+              msg.error,
+              "API call failed"
+            );
+            throw new Error(errorMessage);
+          }
+          return msg.result;
+        }),
+        rxjs.take(1)
+      );
+      const sending = this.connection.send(message);
+      return reply.pipe(rxjs.finalize(() => sending.unsubscribe()));
+    });
   }
   /**
    * Query a collection and emit the matching entries.
@@ -237,81 +212,159 @@ var TrueNasApi = class {
     return this.dispatch(method, [filters ?? [], { count: true }]);
   }
   /**
-   * Makes an API call and returns the job ID from the websocket event.
-   * Used for v26 where API calls return null but job events contain the job ID.
+   * Start a job and emit its id.
+   *
+   * Keyed off the surface's *job* directory rather than its call directory —
+   * a disjoint key space, so `callAndGetJobId('app.query')` is rejected and
+   * `call('app.start')` is too. Which one a method belongs to is a fact about
+   * the method, and the generated directories are where that fact lives.
    *
-   * The job ID is extracted from the first job event where message_ids contains
-   * the original request ID.
+   * The id comes from the first job event whose `message_ids` carries this
+   * request's id, not from the response: what a job method returns on the wire
+   * differs by version (v25.10 answers with the id, v26 with `null`), while
+   * the event correlation holds for both.
    *
-   * @param method The API method to call
-   * @param params The parameters for the API call
    * @returns Observable that emits the job ID when received from websocket events
    */
-  callAndGetJobId(method, params) {
-    const message = createJsonRpcMessage(method, params);
-    this.connection.ws.next(message);
-    const requestId = message.id ?? "";
-    return this.jobEvents.pipe(
-      rxjs.filter((job) => job.message_ids?.includes(requestId) ?? false),
-      rxjs.map((job) => job.id),
-      rxjs.take(1)
-    );
-  }
-  events(eventName) {
-    this.authenticated.pipe(rxjs.filter(Boolean), rxjs.take(1)).subscribe(() => {
-      const message = createJsonRpcMessage("core.subscribe", [eventName]);
-      this.connection.ws.next(message);
+  callAndGetJobId(method, ...params) {
+    return rxjs.defer(() => {
+      const message = createJsonRpcMessage(method, params[0]);
+      const seen = this.jobEvents.pipe(
+        rxjs.filter((job) => job.message_ids?.includes(message.id ?? "") ?? false),
+        rxjs.map((job) => job.id),
+        rxjs.take(1)
+      );
+      const sending = this.connection.send(message);
+      return seen.pipe(rxjs.finalize(() => sending.unsubscribe()));
     });
-    return this.connection.messages().pipe(
-      rxjs.filter((res) => {
-        const params = res.params;
-        return res.method === "collection_update" && params?.collection === eventName && ["added", "changed", "removed"].includes(params?.msg || "") && params.fields !== void 0;
-      })
+  }
+  /**
+   * Start a job and follow it to completion.
+   *
+   * Emits the job's state as it progresses and completes when the job reaches
+   * a terminal state, so `last()` gives the finished job and the intermediate
+   * emissions drive a progress indicator.
+   *
+   * ```typescript
+   * api.job('pool.dataset.unlock', ['tank/enc', { … }])
+   *    .subscribe(job => bar.set(job.progress.percent ?? 0));
+   * ```
+   *
+   * The result is typed from the job directory, which is the whole reason to
+   * prefer this over {@link callAndGetJobId} plus {@link trackJob}: those two
+   * lose the connection between the method and its result, and the job comes
+   * back with `result: unknown`. It is `R | null` either way — a job that has
+   * not finished has no result, and neither does one that failed.
+   */
+  job(method, ...params) {
+    return this.callAndGetJobId(method, ...params).pipe(
+      rxjs.switchMap((jobId) => this.trackJob(jobId))
     );
   }
+  /**
+   * Subscribe to a collection and emit its changes.
+   *
+   * Emits the change itself rather than the transport frame, as a union
+   * discriminated on `msg`:
+   *
+   * ```typescript
+   * api.events('app.query').subscribe(event => {
+   *   if (event.msg === 'removed') return drop(event.id);
+   *   render(event.fields);          // only reachable once narrowed
+   * });
+   * ```
+   *
+   * The narrowing is load-bearing, not decoration: a `removed` event carries
+   * an `id` and no `fields` in 55 of the 56 collections that declare one, so
+   * reaching `fields` unconditionally is wrong for almost all of them.
+   *
+   * Event *sources* — the entries taking subscribe-time arguments — are not
+   * reachable here; see {@link EventName}.
+   */
+  events(event) {
+    const existing = this.eventStreams.get(event);
+    if (existing) return existing;
+    const stream = rxjs.defer(() => {
+      const resubscribe = this.authenticated.pipe(rxjs.distinctUntilChanged(), rxjs.filter(Boolean)).subscribe(() => {
+        this.connection.send(createJsonRpcMessage("core.subscribe", [event]));
+      });
+      return this.connection.messages().pipe(
+        rxjs.filter((res) => res.method === "collection_update"),
+        rxjs.map((res) => res.params),
+        rxjs.filter(
+          (params) => params?.collection === event && EVENT_KINDS.includes(params.msg)
+        ),
+        // `collection` is the subscription the caller already named; what is
+        // left is exactly the payload the directory declares, plus its tag.
+        rxjs.map(({ collection, ...change }) => change),
+        rxjs.finalize(() => resubscribe.unsubscribe())
+      );
+    }).pipe(rxjs.share({ resetOnRefCountZero: false, resetOnComplete: false }));
+    this.eventStreams.set(event, stream);
+    return stream;
+  }
   /**
    * Convenience wrapper for auth.generate_token API call.
+   *
+   * Goes through {@link dispatch} rather than {@link call}: inside the class
+   * body `D` is still a type parameter, so TypeScript cannot know that
+   * `auth.generate_token` is one of its methods. It is — the method is in the
+   * shared base, so every surface has it — but proving that to the checker
+   * would mean constraining `D` on the class, which would push the constraint
+   * onto every caller. The signature below is the guarantee instead.
    */
   generateToken(ttl = 600, matchOrigin = false, singleUse = true) {
-    return this.call("auth.generate_token" /* GenerateToken */, [
+    return this.dispatch("auth.generate_token", [
       ttl,
       {},
       matchOrigin,
       singleUse
     ]);
   }
+  /**
+   * Follow an already-started job to completion.
+   *
+   * @typeParam R - what the job resolves to. An id carries no evidence of
+   * which method produced it, so nothing here can infer this and the default
+   * is `unknown`; naming it is the caller's assertion. {@link job} knows the
+   * method and fills it in from the directory, which is the reason to prefer
+   * it whenever you are the one starting the job.
+   */
   trackJob(jobId) {
-    const completedStates = [
-      "SUCCESS" /* Success */,
-      "FAILED" /* Failed */,
-      "ABORTED" /* Aborted */,
-      "ERROR" /* Error */,
-      "FINISHED" /* Finished */
-    ];
-    const currentJobState$ = this.call("core.get_jobs", [
+    const updates$ = this.jobEvents.pipe(
+      rxjs.filter((job) => job.id === jobId),
+      rxjs.map((job) => job)
+    );
+    const read$ = this.dispatch("core.get_jobs", [
       [["id", "=", jobId]]
     ]).pipe(
       rxjs.map((jobs) => jobs[0]),
-      rxjs.filter((job) => job !== void 0)
+      rxjs.share()
     );
-    const jobUpdates$ = this.jobEvents.pipe(
-      rxjs.filter((job) => job.id === jobId),
-      rxjs.takeWhile((job) => !completedStates.includes(job.state), true)
-      // Include the final state
+    const missing$ = read$.pipe(
+      rxjs.filter((job) => job === void 0),
+      rxjs.takeUntil(updates$)
     );
-    return currentJobState$.pipe(
-      rxjs.switchMap((currentJob) => {
-        if (completedStates.includes(currentJob.state)) {
-          return rxjs.of(currentJob);
-        }
-        return rxjs.merge(rxjs.of(currentJob), jobUpdates$);
-      })
+    const snapshot$ = read$.pipe(
+      rxjs.filter((job) => job !== void 0),
+      rxjs.takeUntil(updates$)
+    );
+    return rxjs.merge(snapshot$, updates$).pipe(
+      rxjs.takeWhile((job) => !isJobFinished(job), true),
+      // Include the final state
+      rxjs.takeUntil(missing$)
     );
   }
+  /**
+   * Ask the server for job events, and keep asking after every reconnect —
+   * `authenticated$` returns to `false` when the socket drops, and a `take(1)`
+   * here left job tracking permanently deaf once that happened.
+   */
   initializeJobEventsSubscription() {
-    this.authenticated.pipe(rxjs.filter(Boolean), rxjs.take(1)).subscribe(() => {
-      const message = createJsonRpcMessage("core.subscribe", ["core.get_jobs"]);
-      this.connection.ws.next(message);
+    this.authenticated.pipe(rxjs.distinctUntilChanged(), rxjs.filter(Boolean)).subscribe(() => {
+      this.connection.send(
+        createJsonRpcMessage("core.subscribe", ["core.get_jobs"])
+      );
     });
   }
 };
@@ -3007,6 +3060,36 @@ var TrueNasApiClient = class {
   }
 };
 
+// src/types/app-query.type.ts
+var AppState = /* @__PURE__ */ ((AppState2) => {
+  AppState2["Running"] = "RUNNING";
+  AppState2["Stopped"] = "STOPPED";
+  AppState2["Stopping"] = "STOPPING";
+  AppState2["Deploying"] = "DEPLOYING";
+  return AppState2;
+})(AppState || {});
+
+// src/utils/app-state.utils.ts
+function toAppState(state) {
+  switch (state.toUpperCase()) {
+    case "RUNNING":
+      return "RUNNING" /* Running */;
+    case "STOPPED":
+      return "STOPPED" /* Stopped */;
+    case "STOPPING":
+      return "STOPPING" /* Stopping */;
+    // `STARTING` is v25.10 `virt.instance` only, and folding it into `Stopped`
+    // told callers a container that is coming up is at rest — enough for a UI
+    // to offer a Start button for it, or for a poll loop to give up. `Deploying`
+    // is the only in-progress state `AppState` has.
+    case "STARTING":
+    case "DEPLOYING":
+      return "DEPLOYING" /* Deploying */;
+    default:
+      return "STOPPED" /* Stopped */;
+  }
+}
+
 // src/client/truenas-api-client-v25-10.ts
 var TrueNasApiClientV2510 = class extends TrueNasApiClient {
   /**
@@ -3018,48 +3101,34 @@ var TrueNasApiClientV2510 = class extends TrueNasApiClient {
    */
   createOperations() {
     return {
-      containerQuery: () => this.api.call("virt.instance.query" /* VirtualInstanceQuery */, [
-        [["type", "=", "CONTAINER" /* Container */]]
-      ]).pipe(rxjs.map((instances) => instances.map(this.toContainer))),
-      containerStart: (id) => this.api.callAndGetJobId("virt.instance.start" /* VirtualInstanceStart */, [id]).pipe(rxjs.switchMap((jobId) => this.api.trackJob(jobId))),
-      containerStop: (id, options) => this.api.callAndGetJobId("virt.instance.stop" /* VirtualInstanceStop */, [id, options]).pipe(rxjs.switchMap((jobId) => this.api.trackJob(jobId))),
-      containerRestart: (id, options) => this.api.callAndGetJobId("virt.instance.restart" /* VirtualInstanceRestart */, [
-        id,
-        options
-      ]).pipe(rxjs.switchMap((jobId) => this.api.trackJob(jobId)))
-    };
-  }
-  /**
-   * Transform VirtualInstanceQuery to unified Container type
-   */
-  toContainer(instance) {
-    return {
-      id: instance.id,
-      name: instance.name,
-      status: instance.status,
-      autostart: instance.autostart,
-      cpu: instance.cpu,
-      memory: instance.memory,
-      image: instance.image
+      // A polymorphic `.query`, so it goes through the verb rather than
+      // `call`: the directory types the raw method's response as the five-way
+      // union the server may return, and the verb is what fixes it to a list.
+      containerQuery: () => this.api.query("virt.instance.query", [["type", "=", "CONTAINER"]]).pipe(rxjs.map((instances) => instances.map(toContainer))),
+      containerStart: (id) => this.api.job("virt.instance.start", [id]),
+      containerStop: (id, options) => this.api.job("virt.instance.stop", [id, options]),
+      containerRestart: (id, options) => this.api.job("virt.instance.restart", [id, options])
     };
   }
 };
-var TrueNasApiClientV26 = class _TrueNasApiClientV26 extends TrueNasApiClient {
-  /**
-   * Map v26 status state string to AppState enum
-   */
-  static mapStatus(state) {
-    switch (state.toUpperCase()) {
-      case "RUNNING":
-        return "RUNNING" /* Running */;
-      case "STOPPED":
-        return "STOPPED" /* Stopped */;
-      case "STOPPING":
-        return "STOPPING" /* Stopping */;
-      default:
-        return "STOPPED" /* Stopped */;
-    }
-  }
+function toContainer(instance) {
+  return {
+    id: instance.id,
+    name: instance.name,
+    status: toAppState(instance.status),
+    autostart: instance.autostart,
+    cpu: instance.cpu ?? void 0,
+    memory: instance.memory ?? void 0,
+    // The whole image object, not just its description: `Container.image`
+    // declares only `description`, but the API returns `architecture`, `os`,
+    // `release` and more, and callers were already receiving them. Narrowing
+    // to the declared field would take data away to match a type that was
+    // always an under-declaration — the same call as the v26 `description`
+    // widening, decided the same way.
+    image: instance.image.description === null ? void 0 : { ...instance.image, description: instance.image.description }
+  };
+}
+var TrueNasApiClientV26 = class extends TrueNasApiClient {
   /**
    * Create v26-specific operation mappings
    *
@@ -3069,58 +3138,58 @@ var TrueNasApiClientV26 = class _TrueNasApiClientV26 extends TrueNasApiClient {
    */
   createOperations() {
     return {
-      containerQuery: () => this.api.call("container.query" /* ContainerQuery */, [[]]).pipe(rxjs.map((containers) => containers.map(this.toContainer))),
+      // A polymorphic `.query`, so it goes through the verb rather than
+      // `call`: the directory types the raw method's response as the five-way
+      // union the server may return, and the verb is what fixes it to a list.
+      containerQuery: () => this.api.query("container.query").pipe(
+        rxjs.map((containers) => containers.map(toContainer2))
+      ),
       // container.start is synchronous in v26.0.0 - emit null
-      containerStart: (id) => this.api.call("container.start" /* ContainerStart */, [parseInt(id, 10)]).pipe(rxjs.map(() => null)),
+      containerStart: (id) => this.api.call("container.start", [parseInt(id, 10)]).pipe(rxjs.map(() => null)),
       // container.stop emits job updates
-      containerStop: (id, options) => this.api.callAndGetJobId("container.stop" /* ContainerStop */, [
+      containerStop: (id, options) => this.api.job("container.stop", [
         parseInt(id, 10),
         {
           force: options.force,
           force_after_timeout: options.force
         }
-      ]).pipe(rxjs.switchMap((jobId) => this.api.trackJob(jobId))),
+      ]),
       // v26.0.0 doesn't have container.restart - chain stop + start
       // Emits Job updates during stop, then null when start completes
       containerRestart: (id, options) => {
         const numericId = parseInt(id, 10);
-        return this.api.callAndGetJobId("container.stop" /* ContainerStop */, [
+        return this.api.job("container.stop", [
           numericId,
           {
             force: options.force,
             force_after_timeout: options.force
           }
         ]).pipe(
-          // Track stop job until it completes
-          rxjs.switchMap((stopJobId) => this.api.trackJob(stopJobId)),
           // Collect all job updates to ensure stop fully completes
           rxjs.toArray(),
           // Re-emit job updates, then call start after stop is done
           rxjs.switchMap(
             (jobUpdates) => rxjs.concat(
               rxjs.from(jobUpdates),
-              this.api.call("container.start" /* ContainerStart */, [numericId]).pipe(rxjs.map(() => null))
+              this.api.call("container.start", [numericId]).pipe(rxjs.map(() => null))
             )
           )
         );
       }
     };
   }
-  /**
-   * Transform v26 ContainerQueryV26 to unified Container type
-   */
-  toContainer(container) {
-    return {
-      id: container.id.toString(),
-      name: container.name,
-      status: _TrueNasApiClientV26.mapStatus(container.status.state),
-      autostart: container.autostart,
-      description: container.description
-      // cpu and memory are not available in v26 container.query
-      // image is not available in v26 container.query
-    };
-  }
 };
+function toContainer2(container) {
+  const { description } = container;
+  return {
+    id: container.id.toString(),
+    name: container.name,
+    status: toAppState(container.status.state),
+    // Optional in the generated entry, required by `Container`.
+    autostart: container.autostart ?? false,
+    description
+  };
+}
 
 // src/errors/version-discovery.errors.ts
 var VersionDiscoveryError = class extends Error {
@@ -3510,6 +3579,7 @@ function errorMessageOrDefault(error, fallback) {
   return fallback;
 }
 
+exports.AppState = AppState;
 exports.AuthError = AuthError;
 exports.AuthErrorCode = AuthErrorCode;
 exports.InvalidVersionResponseError = InvalidVersionResponseError;
@@ -3520,7 +3590,6 @@ exports.TrueNasApiClient = TrueNasApiClient;
 exports.TrueNasApiClientV2510 = TrueNasApiClientV2510;
 exports.TrueNasApiClientV26 = TrueNasApiClientV26;
 exports.TrueNasAuthMechanism = TrueNasAuthMechanism;
-exports.TrueNasEndpoint = TrueNasEndpoint;
 exports.VersionCompatibility = VersionCompatibility;
 exports.VersionDiscovery = VersionDiscovery;
 exports.VersionDiscoveryError = VersionDiscoveryError;
@@ -3532,6 +3601,7 @@ exports.VersionTooOldError = VersionTooOldError;
 exports.consoleLogger = consoleLogger;
 exports.createTrueNasClient = createTrueNasClient;
 exports.getApiErrorMessage = getApiErrorMessage;
+exports.isJobFinished = isJobFinished;
 exports.noopLogger = noopLogger;
 exports.v25_10_0 = v25_10_0_exports;
 exports.v25_10_1 = v25_10_1_exports;