@truenas/api-client 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,2627 @@
+import * as rxjs from 'rxjs';
+import { BehaviorSubject, Subject, Observable } from 'rxjs';
+import * as rxjs_webSocket from 'rxjs/webSocket';
+import { WebSocketSubjectConfig } from 'rxjs/webSocket';
+
+interface TrueNasMessage {
+    id?: string;
+    /** JSON-RPC 2.0 protocol version, e.g. '2.0' (present on versioned-API messages). */
+    jsonrpc?: string;
+    msg?: string;
+    version?: string;
+    support?: string[];
+    method?: string;
+    result?: unknown;
+    params?: unknown;
+    name?: string;
+    collection?: string;
+    fields?: unknown;
+    subs?: string[];
+    error?: {
+        error: number;
+        errname: string;
+        extra: (string | number)[];
+        reason: string;
+    };
+}
+
+declare enum TrueNasAuthMechanism {
+    ApiKey = "API_KEY_PLAIN",
+    Password = "PASSWORD_PLAIN",
+    Otp = "OTP_TOKEN",
+    Token = "TOKEN_PLAIN"
+}
+
+declare enum ProductType {
+    Community = "COMMUNITY_EDITION",
+    Enterprise = "ENTERPRISE"
+}
+
+declare enum TrueNasEndpoint {
+    UpdateStatus = "update.status",
+    AppQuery = "app.query",
+    AppStart = "app.start",
+    AppStop = "app.stop",
+    AppRedeploy = "app.redeploy",
+    AppUpgrade = "app.upgrade",
+    CoreSubscribe = "core.subscribe",
+    ReplicationQuery = "replication.query",
+    ReplicationRun = "replication.run",
+    InterfaceQuery = "interface.query",
+    CloudBackupQuery = "cloud_backup.query",
+    CloudSyncQuery = "cloudsync.query",
+    VirtualInstanceQuery = "virt.instance.query",
+    VirtualInstanceStop = "virt.instance.stop",
+    VirtualInstanceStart = "virt.instance.start",
+    VirtualInstanceRestart = "virt.instance.restart",
+    ContainerQuery = "container.query",
+    ContainerStart = "container.start",
+    ContainerStop = "container.stop",
+    VmQuery = "vm.query",
+    VmStart = "vm.start",
+    VmStop = "vm.stop",
+    VmRestart = "vm.restart",
+    CoreDownload = "core.download",
+    CoreGetJobs = "core.get_jobs",
+    SystemInfo = "system.info",
+    SystemProductType = "system.product_type",
+    ExtendedSystemInfo = "webui.main.dashboard.sys_info",
+    DiskQuery = "disk.query",
+    DeviceGetInfo = "device.get_info",
+    CorePing = "core.ping",
+    GenerateToken = "auth.generate_token",
+    AlertList = "alert.list",
+    AuthLogin = "auth.login_ex",
+    AuthLogout = "auth.logout",
+    ApiKeyQuery = "api_key.query",
+    ApiKeyCreate = "api_key.create",
+    ApiKeyDelete = "api_key.delete",
+    FailOverStatus = "failover.status",
+    FailOverNode = "failover.node",
+    FailOverDisabledReasons = "failover.disabled.reasons",
+    PoolQuery = "pool.query",
+    DatasetQuery = "pool.dataset.query",
+    DatasetCreate = "pool.dataset.create",
+    DatasetDelete = "pool.dataset.delete",
+    SnapshotTaskCreate = "pool.snapshottask.create",
+    SnapshotTaskQuery = "pool.snapshottask.query",
+    SnapshotTaskDelete = "pool.snapshottask.delete",
+    SnapshotCreate = "pool.snapshot.create",
+    SnapshotDelete = "pool.snapshot.delete",
+    ReplicationCountEligibleSnapshots = "replication.count_eligible_manual_snapshots",
+    BootGetState = "boot.get_state",
+    TnConnectUpdate = "tn_connect.update",
+    HardwareVirtualizationVariant = "hardware.virtualization.variant",
+    KeychainCredentialGenerateSshKeyPair = "keychaincredential.generate_ssh_key_pair",
+    KeychainCredentialCreate = "keychaincredential.create",
+    KeychainCredentialRemoteSshHostKeyScan = "keychaincredential.remote_ssh_host_key_scan",
+    KeychainCredentialDelete = "keychaincredential.delete",
+    ReplicationCreate = "replication.create",
+    UserQuery = "user.query",
+    UserUpdate = "user.update",
+    NetworkConfiguration = "network.configuration.config",
+    ServiceQuery = "service.query",
+    ServiceUpdate = "service.update",
+    ServiceControl = "service.control"
+}
+
+declare enum VirtVariant {
+    Amazon = "amazon",
+    Bhyve = "bhyve",
+    Docker = "docker",
+    Kvm = "kvm",
+    Lxc = "lxc",
+    Microsoft = "microsoft",
+    None = "none",
+    Oracle = "oracle",
+    Parallels = "parallels",
+    Qemu = "qemu",
+    Rkt = "rkt",
+    SystemdNspawn = "systemd-nspawn",
+    Uml = "uml",
+    Vmware = "vmware",
+    Xen = "xen"
+}
+
+declare enum FailoverStatus {
+    Master = "MASTER",
+    Backup = "BACKUP",
+    Electing = "ELECTING",
+    Importing = "IMPORTING",
+    Error = "ERROR",
+    Single = "SINGLE"
+}
+type FailoverNode = 'A' | 'B' | 'MANUAL';
+
+interface VirtualizationStopParams {
+    timeout?: number;
+    force: boolean;
+    force_after_timeout?: boolean;
+}
+
+type TrueNasDate = {
+    $date: number;
+};
+
+/**
+ * alert level corresponds directly with IETF RFC 5424 minus the debug level.
+ * see https://datatracker.ietf.org/doc/html/rfc5424#section-6.2.1
+ * for levels and their descriptions.
+ *
+ * `AlertLevel` values are always CAPITALIZED.
+ */
+declare enum AlertLevel {
+    Emergency = "EMERGENCY",
+    Alert = "ALERT",
+    Critical = "CRITICAL",
+    Error = "ERROR",
+    Warning = "WARNING",
+    Notice = "NOTICE",
+    Info = "INFO"
+}
+interface Alert {
+    uuid: string;
+    source: string;
+    args: string;
+    node: string;
+    datetime: TrueNasDate;
+    last_occurrence: TrueNasDate;
+    dismissed: boolean;
+    text: string;
+    id: string;
+    level: AlertLevel;
+    formatted: string;
+    one_shot: boolean;
+}
+
+interface ApiKeyCreate {
+    id: number;
+    key: string;
+    name: string;
+    username: string;
+}
+
+interface AppQuery {
+    id: string;
+    name: string;
+    state: AppState;
+    version: string;
+    upgrade_available: boolean;
+    metadata: {
+        version: string;
+        app_version: string;
+        train: string;
+        home: string;
+        icon: string;
+    };
+    portals: Record<string, string>;
+}
+declare enum AppState {
+    Running = "RUNNING",
+    Stopped = "STOPPED",
+    Stopping = "STOPPING",
+    Deploying = "DEPLOYING"
+}
+
+interface AppUpgradeParams {
+    app_version: string;
+}
+
+declare enum UserRole {
+    FullAdmin = "FULL_ADMIN"
+}
+
+interface UserPreferences {
+    language: string;
+    lifetime: number;
+}
+declare enum AuthResponseType {
+    Success = "SUCCESS",
+    OtpRequired = "OTP_REQUIRED",
+    AuthErr = "AUTH_ERR",
+    Expired = "EXPIRED",
+    Redirect = "REDIRECT"
+}
+interface AuthResponse {
+    response_type: AuthResponseType;
+    username?: string;
+    authenticator?: 'LEVEL_1' | 'LEVEL_2' | 'LEVEL_3';
+    max_session_age?: number;
+    max_inactivity?: number;
+    urls?: string[];
+    user_info?: {
+        username: string;
+        fullname: string;
+        builtin: boolean;
+        email: string | null;
+        groups: number[];
+        privilege: {
+            roles: {
+                $set: UserRole[];
+            };
+        };
+        two_factor_auth_configured: boolean;
+        immutable: boolean;
+        sid: string;
+        id: number;
+        uid: number;
+        gid: number;
+        shell: string;
+        home: string;
+        locked: boolean;
+        sudo: boolean;
+        sudo_nopasswd: boolean;
+        sudo_commands: string[];
+        smb: boolean;
+        group: {
+            id: number;
+            bsdgrp_builtin: boolean;
+            bsdgrp_gid: number;
+            bsdgrp_group: string;
+            bsdgrp_sudo: boolean;
+            bsdgrp_sudo_nopasswd: boolean;
+            bsdgrp_sudo_commands: string[];
+            bsdgrp_smb: boolean;
+            bsdgrp_users: number[];
+        };
+        sshpubkey: string | null;
+        attributes: {
+            [key: string]: unknown;
+            preferences: UserPreferences;
+        };
+    };
+}
+
+interface Job {
+    id: number;
+    method: string;
+    arguments: string[];
+    description: string | null;
+    abortable: boolean;
+    logs_path: string | null;
+    logs_excerpt: string | null;
+    progress: JobProgress;
+    error: string | null;
+    time_started: TrueNasDate;
+    time_finished: TrueNasDate | null;
+    state: JobState;
+    /**
+     * Array of JSON-RPC request IDs that triggered this job.
+     * Used in v26+ to correlate API calls with their jobs.
+     */
+    message_ids?: string[];
+}
+interface JobProgress {
+    percent: number;
+    description: string;
+}
+declare enum JobState {
+    Pending = "PENDING",
+    Running = "RUNNING",
+    Hold = "HOLD",
+    Error = "ERROR",
+    Failed = "FAILED",
+    Aborted = "ABORTED",
+    Success = "SUCCESS",
+    Finished = "FINISHED",
+    Locked = "LOCKED",
+    Waiting = "WAITING"
+}
+
+interface Schedule {
+    minute?: string;
+    hour?: string;
+    dom?: string;
+    month?: string;
+    dow?: string;
+    begin?: string;
+    end?: string;
+}
+
+interface CloudBackupQuery {
+    id: number;
+    description: string;
+    enabled: boolean;
+    schedule: Schedule;
+    job?: Job;
+    name?: string;
+}
+
+interface CloudSyncQuery {
+    id: number;
+    description: string;
+    path: string;
+    attributes: {
+        folder: string;
+        fast_list: boolean;
+        acknowledge_abuse: boolean;
+    };
+    snapshot: boolean;
+    include: string[];
+    exclude: string[];
+    transfers: number;
+    enabled: boolean;
+    job?: Job;
+    direction: 'PUSH' | 'PULL';
+    transfer_mode: 'COPY' | 'SYNC' | 'MOVE';
+    encryption: boolean;
+    filename_encryption: boolean;
+    follow_symlinks: boolean;
+    schedule: {
+        minute: string;
+        hour: string;
+        dom: string;
+        month: string;
+        dow: string;
+    };
+    locked: boolean;
+    name?: string;
+}
+
+/**
+ * Unified Container type
+ *
+ * This interface provides a version-agnostic representation of a container.
+ * It normalizes the response from different API versions:
+ * - v25.10: virt.instance.query (filtered by type=CONTAINER)
+ * - v26+: container.query
+ *
+ * Components should use this type instead of version-specific response types.
+ */
+interface Container {
+    id: string;
+    name: string;
+    status: AppState;
+    autostart: boolean;
+    description?: string;
+    cpu?: string;
+    memory?: number;
+    image?: {
+        description: string;
+    };
+}
+/**
+ * Options for stopping a container (unified interface)
+ */
+interface ContainerStopOptions {
+    timeout?: number;
+    force: boolean;
+}
+/**
+ * Options for restarting a container (unified interface)
+ */
+interface ContainerRestartOptions {
+    timeout?: number;
+    force: boolean;
+}
+/**
+ * v26+ container.stop options format
+ */
+interface ContainerStopOptionsV26 {
+    force: boolean;
+    force_after_timeout: boolean;
+}
+/**
+ * v26+ container.query response structure
+ * Used internally for transformation to unified Container type
+ */
+interface ContainerQueryV26 {
+    id: number;
+    uuid: string;
+    name: string;
+    description: string;
+    autostart: boolean;
+    status: {
+        state: string;
+        pid: number | null;
+        domain_state: string | null;
+    };
+    cpuset: string | null;
+    dataset: string;
+    devices: ContainerDeviceV26[];
+    time: string;
+    shutdown_timeout: number;
+    init: string;
+    initdir: string | null;
+    initenv: Record<string, string>;
+    inituser: string | null;
+    initgroup: string | null;
+    idmap: {
+        type: string;
+    };
+    capabilities_policy: string;
+    capabilities_state: Record<string, unknown>;
+}
+interface ContainerDeviceV26 {
+    id: number;
+    attributes: {
+        dtype: string;
+        usb?: {
+            vendor_id: string;
+            product_id: string;
+        };
+        device: string | null;
+    };
+    container: number;
+}
+
+type CoreDownload = [jobId: number, url: string];
+
+/**
+ * Dataset type values for ZFS filesystem and volume datasets.
+ * Matches TrueNAS middleware API dataset types.
+ */
+declare enum DatasetType {
+    Filesystem = "FILESYSTEM",
+    Volume = "VOLUME"
+}
+
+interface DatasetProperty {
+    parsed: string | number | boolean;
+    rawvalue: string;
+    source: string;
+    source_info: string;
+    value: string;
+}
+interface Dataset {
+    aclmode: DatasetProperty;
+    acltype: DatasetProperty;
+    atime: DatasetProperty;
+    available: DatasetProperty;
+    casesensitivity: DatasetProperty;
+    children: Dataset[];
+    compression: DatasetProperty;
+    compressratio: DatasetProperty;
+    copies: DatasetProperty;
+    creation: DatasetProperty;
+    deduplication: DatasetProperty;
+    encryption_algorithm: DatasetProperty;
+    exec: DatasetProperty;
+    key_format: DatasetProperty;
+    origin: DatasetProperty;
+    pbkdf2iters: DatasetProperty;
+    quota: DatasetProperty;
+    readonly: DatasetProperty;
+    checksum: DatasetProperty;
+    recordsize: DatasetProperty;
+    refquota: DatasetProperty;
+    refreservation: DatasetProperty;
+    reservation: DatasetProperty;
+    snapdev: DatasetProperty;
+    snapdir: DatasetProperty;
+    special_small_block_size: DatasetProperty;
+    sync: DatasetProperty;
+    used: DatasetProperty;
+    usedbychildren: DatasetProperty;
+    usedbydataset: DatasetProperty;
+    usedbyrefreservation: DatasetProperty;
+    usedbysnapshots: DatasetProperty;
+    xattr: DatasetProperty;
+    encrypted: boolean;
+    key_loaded: boolean;
+    locked: boolean;
+    mountpoint: string;
+    name: string;
+    pool: string;
+    type: DatasetType;
+    id: string;
+}
+
+declare enum DeviceType {
+    Gpu = "GPU",
+    Disk = "DISK",
+    Serial = "SERIAL"
+}
+interface GpuDevice {
+    addr: {
+        pci_slot: string;
+        domain: string;
+        bus: string;
+        slot: string;
+    };
+    description: string;
+    devices: {
+        pci_id: string;
+        pci_slot: string;
+        vm_pci_slot: string;
+    }[];
+    vendor: string | null;
+    uses_system_critical_devices: boolean;
+    critical_reason: string;
+    available_to_host: boolean;
+}
+
+interface DiskQuery {
+    identifier: string;
+    name: string;
+    subsystem: string;
+    number: number;
+    serial: string;
+    lunid: string | null;
+    size: number;
+    description: string;
+    transfermode: string;
+    hddstandby: string;
+    advpowermgmt: string;
+    togglesmart: boolean;
+    model: string;
+    rotationrate: number | null;
+    type: 'SSD' | 'HDD';
+    devname: string;
+    pool: string | null;
+    enclosure: string | null;
+}
+
+/**
+ * Address family types for network interface aliases.
+ * Corresponds to middleware's AddressFamily enum.
+ *
+ * These values indicate the type of address contained in an interface alias.
+ */
+declare enum InterfaceAddressFamily {
+    /**
+     * Unix domain socket address (rarely used in network interfaces)
+     */
+    Unix = "UNIX",
+    /**
+     * IPv4 address (Internet Protocol version 4)
+     */
+    Inet = "INET",
+    /**
+     * IPv6 address (Internet Protocol version 6)
+     */
+    Inet6 = "INET6",
+    /**
+     * Link layer address (MAC address)
+     */
+    Link = "LINK"
+}
+
+/**
+ * LACP data unit transmission rate.
+ * Corresponds to middleware's lacpdu_rate field values.
+ *
+ * Controls how frequently LACP packets are exchanged between bonded interfaces
+ * for monitoring link health and detecting failures.
+ */
+declare enum InterfaceLacpRate {
+    /**
+     * Send LACP packets every 30 seconds
+     * Standard link monitoring interval, suitable for most deployments
+     */
+    Slow = "SLOW",
+    /**
+     * Send LACP packets every 1 second
+     * Rapid link failure detection for mission-critical applications
+     */
+    Fast = "FAST"
+}
+
+/**
+ * Link aggregation protocols for bonding network interfaces.
+ * Corresponds to middleware's lag_protocol field values.
+ *
+ * These protocols determine how multiple physical interfaces are combined
+ * into a single logical interface for redundancy and/or increased bandwidth.
+ */
+declare enum InterfaceLagProtocol {
+    /**
+     * LACP (Link Aggregation Control Protocol) - IEEE 802.3ad
+     * Dynamic link aggregation with automatic failover and load balancing
+     */
+    Lacp = "LACP",
+    /**
+     * Active-backup failover
+     * One interface active, others standby. Provides redundancy but not load balancing.
+     */
+    Failover = "FAILOVER",
+    /**
+     * Load balancing across all bonded interfaces
+     * Distributes traffic based on configured hash policy
+     */
+    LoadBalance = "LOADBALANCE",
+    /**
+     * Round-robin distribution
+     * Distributes packets across interfaces in sequential order
+     */
+    RoundRobin = "ROUNDROBIN",
+    /**
+     * No aggregation protocol configured
+     */
+    None = "NONE"
+}
+
+/**
+ * Interface link state values.
+ * Corresponds to middleware's InterfaceLinkState enum.
+ *
+ * These values indicate the operational state of a network interface's link.
+ */
+declare enum InterfaceLinkState {
+    /**
+     * Link state is unknown or not applicable
+     */
+    Unknown = "LINK_STATE_UNKNOWN",
+    /**
+     * Link is down - no carrier signal detected
+     */
+    Down = "LINK_STATE_DOWN",
+    /**
+     * Link is up - carrier signal is active and operational
+     */
+    Up = "LINK_STATE_UP"
+}
+
+/**
+ * Network interface types.
+ * Corresponds to middleware's InterfaceType enum.
+ *
+ * These values classify the type/role of a network interface.
+ */
+declare enum InterfaceType {
+    /**
+     * Bridge interface - software bridge connecting multiple network segments
+     */
+    Bridge = "BRIDGE",
+    /**
+     * Link aggregation (bonding) interface - combines multiple physical interfaces
+     */
+    LinkAggregation = "LINK_AGGREGATION",
+    /**
+     * Physical network interface - actual hardware NIC
+     */
+    Physical = "PHYSICAL",
+    /**
+     * Unknown interface type
+     */
+    Unknown = "UNKNOWN",
+    /**
+     * VLAN (Virtual LAN) interface - 802.1Q tagged virtual interface
+     */
+    Vlan = "VLAN"
+}
+
+/**
+ * Transmit hash policy for link aggregation load balancing.
+ * Corresponds to middleware's xmit_hash_policy field values.
+ *
+ * Determines which packet header fields are used to calculate the hash
+ * for distributing traffic across bonded interfaces.
+ */
+declare enum InterfaceXmitHashPolicy {
+    /**
+     * Layer 2 hashing - uses source and destination MAC addresses
+     * Best for simple scenarios where traffic patterns are consistent
+     */
+    Layer2 = "LAYER2",
+    /**
+     * Layer 2+3 hashing - uses MAC addresses and IP addresses
+     * Better distribution for multi-subnet environments
+     */
+    Layer2Plus3 = "LAYER2+3",
+    /**
+     * Layer 3+4 hashing - uses MAC, IP, and TCP/UDP port information
+     * Optimal distribution for diverse traffic patterns and multiple connections
+     */
+    Layer3Plus4 = "LAYER3+4"
+}
+
+/**
+ * VRRP (Virtual Router Redundancy Protocol) state values.
+ * Used in High Availability configurations to indicate controller state.
+ */
+declare enum VrrpState {
+    Master = "MASTER",
+    Backup = "BACKUP",
+    Fault = "FAULT"
+}
+
+interface InterfaceEntryAlias {
+    type: InterfaceAddressFamily;
+    /** The type of IP address (INET for IPv4, INET6 for IPv6). */
+    address: string;
+    /** The IP address value. */
+    netmask: string | number;
+}
+interface InterfaceEntryStateAlias extends Omit<InterfaceEntryAlias, 'netmask'> {
+    netmask?: string | number;
+    broadcast?: string;
+}
+interface InterfaceVrrpConfig {
+    address: string;
+    /** Virtual IP address managed by VRRP. */
+    state: VrrpState;
+}
+interface InterfaceEntryStatePort {
+    name: string;
+    /** The name of the port interface. */
+    flags: string[];
+}
+interface InterfaceEntryState {
+    name: string;
+    /** Current name of the network interface. */
+    orig_name: string;
+    /** Original name of the network interface before any renaming. */
+    description: string;
+    /** Human-readable description of the network interface. */
+    mtu: number;
+    /** Maximum transmission unit size for the interface. */
+    cloned: boolean;
+    /** Whether the interface is a cloned/virtual interface. */
+    flags: string[];
+    /** List of interface flags indicating various states and capabilities. */
+    nd6_flags: unknown[];
+    /** IPv6 neighbor discovery flags. */
+    capabilities: string[];
+    /** List of hardware capabilities supported by the interface. */
+    link_state: InterfaceLinkState;
+    /** Current link state of the interface (up, down, etc.). */
+    media_type: string;
+    /** Type of media/connection for the interface. */
+    media_subtype: string;
+    /** Subtype of media/connection for the interface. */
+    active_media_type: string;
+    /** Currently active media type. */
+    active_media_subtype: string;
+    /** Currently active media subtype. */
+    supported_media: string[];
+    /** List of supported media types for the interface. */
+    media_options?: string[] | null;
+    /** Available media options for the interface. */
+    link_address: string;
+    /** MAC address of the interface. */
+    permanent_link_address?: string | null;
+    /** Permanent MAC address of the interface if different from current. */
+    hardware_link_address: string;
+    /** Hardware MAC address of the interface. */
+    rx_queues?: number;
+    /** Number of receive queues configured for the interface. */
+    tx_queues?: number;
+    /** Number of transmit queues configured for the interface. */
+    aliases: InterfaceEntryStateAlias[];
+    /** List of IP address aliases configured on the interface. */
+    vrrp_config?: InterfaceVrrpConfig[] | null;
+    /** VRRP (Virtual Router Redundancy Protocol) configuration for the interface. */
+    protocol?: InterfaceLagProtocol | null;
+    /** Link aggregation protocol used (LACP, FAILOVER, etc.). */
+    ports?: InterfaceEntryStatePort[];
+    /** List of ports that are members of this link aggregation group. */
+    xmit_hash_policy?: InterfaceXmitHashPolicy | null;
+    /** Transmit hash policy for load balancing in link aggregation. */
+    lacpdu_rate?: InterfaceLacpRate | null;
+    /** LACP data unit transmission rate. */
+    parent?: string | null;
+    /** Parent interface for VLAN configuration. */
+    tag?: number | null;
+    /** VLAN tag number. */
+    pcp?: number | null;
+}
+interface InterfaceEntry {
+    id: string;
+    /** Unique identifier for the network interface. */
+    name: string;
+    /** Name of the network interface. */
+    fake: boolean;
+    /** Whether this is a fake/simulated interface for testing purposes. */
+    type: InterfaceType;
+    /** Type of interface (PHYSICAL, BRIDGE, LINK_AGGREGATION, VLAN, etc.). */
+    state: InterfaceEntryState;
+    /** Current runtime state information for the interface. */
+    aliases: InterfaceEntryAlias[];
+    /** List of IP address aliases configured on the interface. */
+    ipv4_dhcp: boolean;
+    /** Whether IPv4 DHCP is enabled for automatic IP address assignment. */
+    ipv6_auto: boolean;
+    /** Whether IPv6 autoconfiguration is enabled. */
+    description: string;
+    /** Human-readable description of the interface. */
+    mtu?: number | null;
+    /** Maximum transmission unit size for the interface. */
+    vlan_parent_interface?: string | null;
+    /** Parent interface for VLAN configuration. */
+    vlan_tag?: number | null;
+    /** VLAN tag number for VLAN interfaces. */
+    vlan_pcp?: number | null;
+    /** Priority Code Point for VLAN traffic prioritization. */
+    lag_protocol?: InterfaceLagProtocol;
+    /** Link aggregation protocol. */
+    lag_ports?: string[];
+    /** List of ports in the link aggregation group. */
+    xmit_hash_policy?: InterfaceXmitHashPolicy | null;
+    /** Transmit hash policy for link aggregation. */
+    lacpdu_rate?: InterfaceLacpRate | null;
+    /** LACP data unit transmission rate. */
+    disable_offload_capabilities?: boolean;
+    /** Whether to disable hardware offload capabilities. */
+    mtu_configured?: number | null;
+    /** Configured MTU size (may differ from actual). */
+    enabled: boolean;
+    /** Whether the interface is enabled. */
+    failover_critical?: boolean;
+    /** Whether this interface is critical for High Availability failover. */
+    failover_vhid?: number | null;
+    /** Virtual Host ID for CARP-based failover (FreeBSD). */
+    failover_group?: number;
+    /** Failover group number for organizing interfaces in HA configurations. */
+    failover_aliases?: InterfaceEntryAlias[];
+    /** List of IP aliases for the standby/backup controller in HA configurations. */
+    failover_virtual_aliases?: InterfaceEntryAlias[];
+}
+
+interface SSHKeyPair {
+    /** SSH private key in OpenSSH format. `null` if only public key is provided. */
+    private_key: string | null;
+    /** Can be omitted and automatically derived from the private key. */
+    public_key: string | null;
+}
+interface SSHCredentials {
+    /** SSH server hostname or IP address. */
+    host: string;
+    /** SSH server port number. */
+    port: number;
+    /** SSH username for authentication. */
+    username: string;
+    /** Keychain Credential ID. */
+    private_key: number;
+    /** Can be discovered with keychaincredential.remote_ssh_host_key_scan. */
+    remote_host_key: string;
+    /** Connection timeout in seconds for SSH connections. */
+    connect_timeout: number;
+}
+/** Minimal SSH credentials containing only the host information needed for target system identification */
+interface MinimalSshCredentials {
+    /** SSH server hostname or IP address. */
+    host: string;
+}
+interface KeychainCredentialEntry {
+    /** Unique identifier for this keychain credential. */
+    id: number;
+    /** Distinguishes this Keychain Credential from others. */
+    name: string;
+    /** Type of credential stored in the keychain. */
+    type: 'SSH_KEY_PAIR' | 'SSH_CREDENTIALS';
+    /** Credential-specific configuration and authentication data. */
+    attributes: SSHKeyPair | SSHCredentials;
+}
+interface SSHKeyPairEntry extends KeychainCredentialEntry {
+    /** Keychain credential type identifier for SSH key pairs. */
+    type: 'SSH_KEY_PAIR';
+    /** SSH key pair attributes including public and private keys. */
+    attributes: SSHKeyPair;
+}
+interface SSHCredentialsEntry extends KeychainCredentialEntry {
+    /** Keychain credential type identifier for SSH connection credentials. */
+    type: 'SSH_CREDENTIALS';
+    /** SSH connection attributes including host, authentication, and connection settings. */
+    attributes: SSHCredentials;
+}
+/** Minimal keychain credential entry containing only host information for target system identification */
+interface MinimalKeychainCredentialEntry {
+    /** Unique identifier for this keychain credential. */
+    id: number;
+    /** Type of credential stored in the keychain. */
+    type: 'SSH_KEY_PAIR' | 'SSH_CREDENTIALS';
+    /** Minimal credential attributes containing only the host information. */
+    attributes: MinimalSshCredentials;
+}
+/** Parameters for scanning remote SSH host key */
+interface RemoteSshHostKeyScanParams {
+    /** SSH server hostname or IP address */
+    host: string;
+    /** SSH server port number (default: 22) */
+    port?: number;
+    /** Connection timeout in seconds (default: 10) */
+    connect_timeout?: number;
+}
+/** Parameters for creating a keychain credential */
+interface KeychainCredentialCreate {
+    /** Credential name */
+    name: string;
+    /** Credential type */
+    type: 'SSH_KEY_PAIR' | 'SSH_CREDENTIALS';
+    /** Credential attributes (varies by type) */
+    attributes: SSHKeyPair | SSHCredentials;
+}
+
+/**
+ * TrueNAS Network Configuration
+ * Response from network.configuration.config middleware endpoint
+ */
+interface NetworkConfiguration {
+    /** Unique identifier for the network configuration */
+    id: number;
+    /** System hostname (short name without domain) */
+    hostname: string;
+    /** DNS domain name */
+    domain: string;
+    /** IPv4 default gateway address */
+    ipv4gateway: string;
+    /** IPv6 default gateway address */
+    ipv6gateway: string;
+    /** Primary DNS nameserver */
+    nameserver1: string;
+    /** Secondary DNS nameserver */
+    nameserver2: string;
+    /** Tertiary DNS nameserver */
+    nameserver3: string;
+    /** HTTP proxy server URL */
+    httpproxy: string;
+    /** Custom hostname to IP mappings (hosts file entries) */
+    hosts: string;
+    /** Additional domain search paths */
+    domains: string[];
+    /** Service announcement configuration */
+    service_announcement: {
+        /** Enable NetBIOS name service */
+        netbios: boolean;
+        /** Enable multicast DNS (Bonjour) */
+        mdns: boolean;
+        /** Enable Web Services Discovery */
+        wsd: boolean;
+    };
+    /** Network activity restrictions */
+    activity: {
+        /** Activity restriction type (ALLOW or DENY) */
+        type: string;
+        /** List of restricted network activities */
+        activities: string[];
+    };
+    /** Hostname with .local suffix for mDNS */
+    hostname_local: string;
+    /** Runtime network state (may differ from configured values) */
+    state: {
+        /** Active IPv4 gateway */
+        ipv4gateway: string;
+        /** Active IPv6 gateway */
+        ipv6gateway: string;
+        /** Active primary nameserver */
+        nameserver1: string;
+        /** Active secondary nameserver */
+        nameserver2: string;
+        /** Active tertiary nameserver */
+        nameserver3: string;
+        /** Active custom host mappings */
+        hosts: string;
+    };
+}
+
+interface PeriodicSnapshotTask {
+    id: number;
+    dataset: string;
+    recursive: boolean;
+    lifetime_value: number;
+    lifetime_unit: string;
+    enabled: boolean;
+    exclude: string[];
+    naming_schema: string;
+    allow_empty: boolean;
+    schedule: {
+        minute: string;
+        hour: string;
+        dom: string;
+        month: string;
+        dow: string;
+        begin: string;
+        end: string;
+    };
+    state: string;
+}
+interface PeriodicSnapshotTaskCreate {
+    dataset: string;
+    recursive: boolean;
+    lifetime_value: number;
+    lifetime_unit: string;
+    naming_schema: string;
+    schedule: {
+        minute: string;
+        hour: string;
+        dom: string;
+        month: string;
+        dow: string;
+    };
+    enabled: boolean;
+    exclude?: string[];
+    allow_empty?: boolean;
+}
+
+interface PoolQuery {
+    id: number;
+    guid: string;
+    name: string;
+    healthy: boolean;
+    path: string;
+    status: PoolStatus;
+    size: number;
+    allocated: number;
+    free: number;
+    used: PoolProperty;
+    encryption_algorithm: PoolProperty;
+    compression: PoolProperty;
+    compressratio: PoolProperty;
+    recordsize: PoolProperty;
+    topology: {
+        [T in PoolVdevCategory]: PoolVdev[];
+    } | null;
+}
+declare enum PoolVdevCategory {
+    Data = "data",
+    Log = "log",
+    Cache = "cache",
+    Spare = "spare",
+    Special = "special",
+    Dedup = "dedup"
+}
+interface PoolProperty {
+    value: string;
+}
+declare enum PoolStatus {
+    Offline = "OFFLINE",
+    Online = "ONLINE",
+    Degraded = "DEGRADED",
+    Unknown = "UNKNOWN",
+    Faulted = "FAULTED",
+    Unavailable = "UNAVAILABLE",
+    Removed = "REMOVED",
+    Split = "SPLIT"
+}
+declare enum PoolVdevType {
+    Stripe = "STRIPE",
+    Mirror = "MIRROR",
+    RaidZ1 = "RAIDZ1",
+    RaidZ2 = "RAIDZ2",
+    RaidZ3 = "RAIDZ3",
+    Disk = "DISK"
+}
+interface PoolVdev {
+    name: string;
+    type: PoolVdevType;
+    path: string | null;
+    guid: string;
+    status: PoolStatus;
+    stats: {
+        size: number;
+        allocated: number;
+        checksum_errors: number;
+        read_errors: number;
+        write_errors: number;
+    };
+    unavail_disk: DiskQuery | null;
+    children: PoolVdev[];
+    disk?: string;
+}
+
+declare enum ReplicationDirection {
+    Push = "PUSH",
+    Pull = "PULL"
+}
+declare enum ReplicationTransport$1 {
+    Ssh = "SSH",
+    SshNetcat = "SSH+NETCAT",
+    Local = "LOCAL"
+}
+type ReplicationReadonly = 'SET' | 'REQUIRE' | 'IGNORE';
+type ReplicationRetentionPolicy$1 = 'SOURCE' | 'CUSTOM' | 'NONE';
+type ReplicationCompression = 'LZ4' | 'PIGZ' | 'PLZIP';
+type ReplicationEncryptionKeyFormat = 'HEX' | 'PASSPHRASE';
+type ReplicationLifetimeUnit$1 = 'HOUR' | 'DAY' | 'WEEK' | 'MONTH' | 'YEAR';
+type ReplicationLogLevel = 'DEBUG' | 'INFO' | 'WARNING' | 'ERROR';
+type ReplicationNetcatActiveSide = 'LOCAL' | 'REMOTE';
+interface ReplicationSchedule {
+    minute: string;
+    hour: string;
+    dom: string;
+    month: string;
+    dow: string;
+}
+interface ReplicationLifetime {
+    schedule: {
+        minute: string;
+        hour: string;
+        dom: string;
+        month: string;
+        dow: string;
+    };
+    lifetime_value: number;
+    lifetime_unit: ReplicationLifetimeUnit$1;
+}
+/**
+ * Complete ReplicationQuery interface matching backend API response.
+ * Represents all fields that the backend CAN return from replication.query endpoint.
+ *
+ * Note: Frontend typically uses a subset via `select` parameter - see SystemReplicationQuery.
+ */
+interface ReplicationQuery {
+    id: number;
+    name: string;
+    direction: ReplicationDirection;
+    transport: ReplicationTransport$1;
+    enabled: boolean;
+    ssh_credentials: MinimalKeychainCredentialEntry | null;
+    netcat_active_side: ReplicationNetcatActiveSide | null;
+    netcat_active_side_listen_address: string | null;
+    netcat_active_side_port_min: number | null;
+    netcat_active_side_port_max: number | null;
+    netcat_passive_side_connect_address: string | null;
+    sudo: boolean;
+    source_datasets: string[];
+    target_dataset: string;
+    recursive: boolean;
+    exclude: string[];
+    properties: boolean;
+    properties_exclude: string[];
+    properties_override: Record<string, string>;
+    replicate: boolean;
+    encryption: boolean;
+    encryption_inherit: boolean | null;
+    encryption_key: string | null;
+    encryption_key_format: ReplicationEncryptionKeyFormat | null;
+    encryption_key_location: string | null;
+    has_encrypted_dataset_keys: boolean;
+    periodic_snapshot_tasks: PeriodicSnapshotTask[];
+    naming_schema: string[];
+    also_include_naming_schema: string[];
+    name_regex: string | null;
+    auto: boolean;
+    schedule: ReplicationSchedule | null;
+    restrict_schedule: ReplicationSchedule | null;
+    only_matching_schedule: boolean;
+    allow_from_scratch: boolean;
+    readonly: ReplicationReadonly;
+    hold_pending_snapshots: boolean;
+    retention_policy: ReplicationRetentionPolicy$1;
+    lifetime_value: number | null;
+    lifetime_unit: ReplicationLifetimeUnit$1 | null;
+    lifetimes: ReplicationLifetime[];
+    compression: ReplicationCompression | null;
+    speed_limit: number | null;
+    large_block: boolean;
+    embed: boolean;
+    compressed: boolean;
+    retries: number;
+    logging_level: ReplicationLogLevel | null;
+    state: {
+        state: string;
+        datetime: TrueNasDate;
+    };
+    job: Job | null;
+    description?: string;
+}
+
+/** Replication transport type */
+declare enum ReplicationTransport {
+    Ssh = "SSH",
+    Local = "LOCAL",
+    Legacy = "LEGACY"
+}
+/** Replication retention policy */
+declare enum ReplicationRetentionPolicy {
+    Source = "SOURCE",
+    Custom = "CUSTOM",
+    None = "NONE"
+}
+/** Replication lifetime unit */
+declare enum ReplicationLifetimeUnit {
+    Hour = "HOUR",
+    Day = "DAY",
+    Week = "WEEK",
+    Month = "MONTH",
+    Year = "YEAR"
+}
+/** Configuration for creating a replication task */
+interface ReplicationCreateConfig {
+    /** Name of the replication task */
+    name: string;
+    /** Direction of replication (PUSH or PULL) */
+    direction: string;
+    /** Transport method */
+    transport: ReplicationTransport;
+    /** SSH credentials ID for SSH transport */
+    ssh_credentials: number;
+    /** IDs of periodic snapshot tasks to bind (PUSH direction only) */
+    periodic_snapshot_tasks?: number[];
+    /** Source datasets to replicate */
+    source_datasets: string[];
+    /** Target dataset path */
+    target_dataset: string;
+    /** Whether to replicate child datasets recursively */
+    recursive: boolean;
+    /** Whether to automatically create snapshots */
+    auto: boolean;
+    /** Snapshot retention policy */
+    retention_policy: ReplicationRetentionPolicy;
+    /** Retention lifetime value */
+    lifetime_value: number;
+    /** Retention lifetime unit */
+    lifetime_unit: ReplicationLifetimeUnit;
+    /** Cron schedule for the replication task */
+    schedule: {
+        /** Minute (0-59 or *) */
+        minute: string;
+        /** Hour (0-23 or *) */
+        hour: string;
+        /** Day of month (1-31 or *) */
+        dom: string;
+        /** Month (1-12 or *) */
+        month: string;
+        /** Day of week (0-6 or *) */
+        dow: string;
+    };
+    /** Whether to allow replication from scratch */
+    allow_from_scratch: boolean;
+    /** Naming schema for snapshots */
+    naming_schema: string[];
+    /** Additional naming schemas to include */
+    also_include_naming_schema: string[];
+    /** Whether the task is enabled */
+    enabled: boolean;
+}
+
+/**
+ * Service management types for TrueNAS service control API
+ */
+/**
+ * Service state enumeration
+ */
+declare enum ServiceState {
+    Running = "RUNNING",
+    Stopped = "STOPPED",
+    Unknown = "UNKNOWN"
+}
+/**
+ * Service control action enumeration
+ */
+declare enum ServiceControlAction {
+    Start = "START",
+    Stop = "STOP",
+    Restart = "RESTART",
+    Reload = "RELOAD"
+}
+/**
+ * Service entry returned by service.query
+ */
+interface ServiceEntry {
+    /** Unique identifier for the service */
+    id: number;
+    /** Name of the system service */
+    service: string;
+    /** Whether the service is enabled to start on boot */
+    enable: boolean;
+    /** Current state of the service */
+    state: ServiceState;
+    /** Array of process IDs associated with this service */
+    pids: number[];
+}
+/**
+ * Options for service control operations
+ */
+interface ServiceOptions {
+    /** Whether to propagate the service operation to the HA peer in a high-availability setup */
+    ha_propagate?: boolean;
+    /** Return false instead of an error if the operation fails */
+    silent?: boolean;
+    /** Maximum time in seconds to wait for the service operation to complete. null for no timeout */
+    timeout?: number | null;
+}
+/**
+ * Service update configuration
+ */
+interface ServiceUpdate {
+    /** Whether the service should start on boot */
+    enable: boolean;
+}
+
+interface SystemInfo {
+    version: string;
+    buildtime: TrueNasDate;
+    hostname: string;
+    physmem: number;
+    model: string;
+    cores: number;
+    physical_cores: number;
+    loadavg: number[];
+    uptime: string;
+    uptime_seconds: number;
+    system_serial: string;
+    system_product: string;
+    system_product_version: string;
+    license: string;
+    boottime: TrueNasDate;
+    datetime: TrueNasDate;
+    birthday: TrueNasDate;
+    timezone: string;
+    system_manufacturer: string;
+    ecc_memory: boolean;
+    remote_info?: SystemInfo;
+}
+
+declare enum UpdateStatusCode {
+    Normal = "NORMAL",
+    Error = "ERROR"
+}
+interface UpdateManifest {
+    filename: string;
+    version: string;
+    date: string;
+    changelog: string;
+    checksum: string;
+    filesize: number;
+    profile: string;
+    train: string;
+}
+interface CurrentVersion {
+    train: string;
+    profile: string;
+    matches_profile: boolean;
+}
+interface NewVersion {
+    version: string;
+    manifest: UpdateManifest;
+    release_notes: string | null;
+    release_notes_url: string;
+}
+interface UpdateStatusResult {
+    current_version?: CurrentVersion;
+    new_version?: NewVersion;
+}
+interface UpdateStatusResponse {
+    code: UpdateStatusCode;
+    status: UpdateStatusResult | null;
+    error: string | null;
+    update_download_progress: unknown;
+}
+
+/**
+ * TrueNAS System User Account (from TrueNAS middleware)
+ */
+interface TrueNasUser {
+    /** User ID */
+    id: number;
+    /** User ID number */
+    uid: number;
+    /** Username */
+    username: string;
+    /** User's full name */
+    full_name: string;
+    /** Home directory path */
+    home: string;
+    /** Login shell */
+    shell: string;
+    /** Primary group ID */
+    group: {
+        id: number;
+        bsdgrp_gid: number;
+        bsdgrp_group: string;
+    };
+    /** Additional group memberships */
+    groups: number[];
+    /** Email address */
+    email: string | null;
+    /** Password disabled flag */
+    password_disabled: boolean;
+    /** Locked account flag */
+    locked: boolean;
+    /** Microsoft account flag */
+    microsoft_account: boolean;
+    /** Sudo access without password */
+    sudo_nopasswd: boolean;
+    /** Sudo commands allowed */
+    sudo_commands: string[];
+    /** SSH public key for authorized_keys */
+    sshpubkey: string | null;
+    /** Account attributes */
+    attributes: Record<string, unknown>;
+    /** Immutable account (cannot be modified) */
+    immutable: boolean;
+    /** Built-in system user */
+    builtin: boolean;
+    /** SMB hash */
+    smb: boolean;
+}
+/**
+ * TrueNAS System User update parameters
+ */
+interface TrueNasUserUpdate {
+    /** User ID number (cannot be changed for existing users) */
+    uid?: number;
+    /** Username (cannot be changed for built-in users) */
+    username?: string;
+    /** User's full name */
+    full_name?: string;
+    /** Home directory path */
+    home?: string;
+    /** Login shell */
+    shell?: string;
+    /** Primary group ID */
+    group?: number;
+    /** Additional group memberships */
+    groups?: number[];
+    /** Email address */
+    email?: string | null;
+    /** Password (plain text, will be hashed) */
+    password?: string;
+    /** Password disabled flag */
+    password_disabled?: boolean;
+    /** Locked account flag */
+    locked?: boolean;
+    /** Microsoft account flag */
+    microsoft_account?: boolean;
+    /** Sudo access without password */
+    sudo_nopasswd?: boolean;
+    /** Sudo commands allowed */
+    sudo_commands?: string[];
+    /** SSH public key for authorized_keys */
+    sshpubkey?: string | null;
+    /** SMB hash */
+    smb?: boolean;
+}
+
+interface VirtualInstanceQuery {
+    id: string;
+    name: string;
+    type: VirtualInstanceType;
+    status: AppState;
+    autostart: boolean;
+    cpu: string;
+    memory: number;
+    image: {
+        description: string;
+    };
+}
+declare enum VirtualInstanceType {
+    Container = "CONTAINER",
+    Vm = "VM"
+}
+
+declare enum VmState {
+    Running = "RUNNING",
+    Stopped = "STOPPED",
+    Suspended = "SUSPENDED",
+    Error = "ERROR"
+}
+declare enum VmDomainState {
+    NoState = "NOSTATE",
+    Running = "RUNNING",
+    Blocked = "BLOCKED",
+    Paused = "PAUSED",
+    Shutdown = "SHUTDOWN",
+    Shutoff = "SHUTOFF",
+    Crashed = "CRASHED",
+    PmSuspended = "PMSUSPENDED"
+}
+interface VMStatus {
+    state: VmState;
+    pid: number | null;
+    domain_state: VmDomainState;
+}
+interface VMQuery {
+    id: number;
+    name: string;
+    description: string;
+    vcpus: number;
+    cores: number;
+    threads: number;
+    /** memory usage in mebibytes (MiB) */
+    memory: number;
+    min_memory: number | null;
+    autostart: boolean;
+    cpu_mode: 'CUSTOM' | 'HOST-MODEL' | 'HOST-PASSTHROUGH';
+    cpu_model: string | null;
+    cpuset: string | null;
+    nodeset: string | null;
+    enable_cpu_topology_extension: boolean;
+    pin_vcpus: boolean;
+    suspend_on_snapshot: boolean;
+    trusted_platform_module: boolean;
+    hyperv_enlightenments: boolean;
+    bootloader: 'UEFI_CSM' | 'UEFI';
+    bootloader_ovmf: string;
+    hide_from_msr: boolean;
+    ensure_display_device: boolean;
+    time: 'LOCAL' | 'UTC';
+    shutdown_timeout: number;
+    arch_type: string | null;
+    machine_type: string | null;
+    uuid: string | null;
+    command_line_args: string;
+    enable_secure_boot: boolean;
+    devices: unknown[];
+    display_available: boolean;
+    status: VMStatus;
+}
+
+interface ZfsSnapshot {
+    /** Full snapshot name including dataset (e.g., pool/dataset@snapshot) */
+    name: string;
+    /** Dataset name */
+    dataset: string;
+    /** Snapshot name without dataset prefix */
+    snapshot_name: string;
+}
+interface CreateZfsSnapshot {
+    /** Dataset to snapshot */
+    dataset: string;
+    /** Optional: Pattern to generate snapshot name (e.g., auto-%Y%m%d.%H%M%S) */
+    naming_schema?: string;
+    /** Optional: Explicit snapshot name */
+    name?: string;
+    /** Optional: Snapshot children recursively */
+    recursive?: boolean;
+    /** Optional: Sync VMware VMs before snapshot */
+    vmware_sync?: boolean;
+    /** Optional: ZFS properties to set on snapshot */
+    properties?: Record<string, unknown>;
+}
+interface EligibleSnapshotsCount {
+    /** Total number of snapshots */
+    total: number;
+    /** Number of snapshots matching the naming schema/regex */
+    eligible: number;
+}
+interface CountEligibleSnapshotsParams {
+    /** Source datasets to check */
+    datasets: string[];
+    /** Transport method */
+    transport: string;
+    /** SSH credentials ID (for SSH transport) */
+    ssh_credentials?: number;
+    /** Naming schema pattern to match */
+    naming_schema?: string[];
+    /** Name regex pattern to match */
+    name_regex?: string;
+}
+
+interface ApiCallDirectory {
+    [TrueNasEndpoint.CoreDownload]: {
+        params: [
+            method: 'config.save' | 'debug.save' | 'system.debug',
+            params: {
+                secretseed?: boolean;
+            }[] | [],
+            filename: string,
+            buffered: boolean
+        ];
+        response: CoreDownload;
+    };
+    [TrueNasEndpoint.CoreGetJobs]: {
+        params: [[[string, string, number]]];
+        response: Job[];
+    };
+    [TrueNasEndpoint.CorePing]: {
+        params: undefined;
+        response: undefined;
+    };
+    [TrueNasEndpoint.UpdateStatus]: {
+        params: undefined;
+        response: UpdateStatusResponse;
+    };
+    [TrueNasEndpoint.AppQuery]: {
+        params: undefined;
+        response: AppQuery[];
+    };
+    [TrueNasEndpoint.AppStart]: {
+        params: string[];
+        response: number;
+    };
+    [TrueNasEndpoint.AppStop]: {
+        params: string[];
+        response: number;
+    };
+    [TrueNasEndpoint.AppRedeploy]: {
+        params: string[];
+        response: number;
+    };
+    [TrueNasEndpoint.AppUpgrade]: {
+        params: [string, AppUpgradeParams];
+        response: number;
+    };
+    [TrueNasEndpoint.ReplicationQuery]: {
+        params: [[], {
+            select: string[];
+        }];
+        response: ReplicationQuery[];
+    };
+    [TrueNasEndpoint.ReplicationRun]: {
+        params: [number];
+        response: number;
+    };
+    [TrueNasEndpoint.ReplicationCreate]: {
+        params: [ReplicationCreateConfig];
+        response: ReplicationQuery;
+    };
+    [TrueNasEndpoint.InterfaceQuery]: {
+        params: undefined;
+        response: InterfaceEntry[];
+    };
+    [TrueNasEndpoint.NetworkConfiguration]: {
+        params: undefined;
+        response: NetworkConfiguration;
+    };
+    [TrueNasEndpoint.CloudBackupQuery]: {
+        params: [[], {
+            select: string[];
+        }];
+        response: CloudBackupQuery[];
+    };
+    [TrueNasEndpoint.CloudSyncQuery]: {
+        params: [[], {
+            select: string[];
+        }];
+        response: CloudSyncQuery[];
+    };
+    [TrueNasEndpoint.SystemInfo]: {
+        params: undefined;
+        response: SystemInfo;
+    };
+    [TrueNasEndpoint.SystemProductType]: {
+        params: undefined;
+        response: ProductType;
+    };
+    [TrueNasEndpoint.ExtendedSystemInfo]: {
+        params: undefined;
+        response: SystemInfo;
+    };
+    [TrueNasEndpoint.DiskQuery]: {
+        params: [[], {
+            extra: {
+                pools: boolean;
+                passwords: boolean;
+            };
+        }];
+        response: DiskQuery[];
+    };
+    [TrueNasEndpoint.DeviceGetInfo]: {
+        params: [{
+            type: DeviceType;
+        }];
+        response: GpuDevice[];
+    };
+    [TrueNasEndpoint.GenerateToken]: {
+        params: [number, Record<string, unknown>, boolean, boolean];
+        response: string;
+    };
+    [TrueNasEndpoint.AlertList]: {
+        params: string[];
+        response: Alert[];
+    };
+    [TrueNasEndpoint.UserQuery]: {
+        params: [ApiQueryFilter[]];
+        response: TrueNasUser[];
+    };
+    [TrueNasEndpoint.UserUpdate]: {
+        params: [number, TrueNasUserUpdate];
+        response: TrueNasUser;
+    };
+    [TrueNasEndpoint.ServiceQuery]: {
+        params: [ApiQueryFilter[]];
+        response: ServiceEntry[];
+    };
+    [TrueNasEndpoint.ServiceUpdate]: {
+        params: [string | number, ServiceUpdate];
+        response: number;
+    };
+    [TrueNasEndpoint.ServiceControl]: {
+        params: [ServiceControlAction, string, ServiceOptions?];
+        response: boolean;
+    };
+    [TrueNasEndpoint.AuthLogin]: {
+        params: {
+            mechanism: TrueNasAuthMechanism;
+            username: string;
+            api_key: string;
+        };
+        response: AuthResponse;
+    };
+    [TrueNasEndpoint.AuthLogout]: {
+        params: undefined;
+        response: boolean;
+    };
+    [TrueNasEndpoint.ApiKeyCreate]: {
+        params: [{
+            name: string;
+            username: string;
+        }];
+        response: ApiKeyCreate;
+    };
+    [TrueNasEndpoint.ApiKeyDelete]: {
+        params: [number];
+        response: boolean;
+    };
+    [TrueNasEndpoint.KeychainCredentialGenerateSshKeyPair]: {
+        params: [];
+        response: SSHKeyPair;
+    };
+    [TrueNasEndpoint.KeychainCredentialCreate]: {
+        params: [KeychainCredentialCreate];
+        response: SSHKeyPairEntry | SSHCredentialsEntry;
+    };
+    [TrueNasEndpoint.KeychainCredentialRemoteSshHostKeyScan]: {
+        params: [RemoteSshHostKeyScanParams];
+        response: string;
+    };
+    [TrueNasEndpoint.KeychainCredentialDelete]: {
+        params: [number];
+        response: null;
+    };
+    [TrueNasEndpoint.FailOverStatus]: {
+        params: undefined;
+        response: FailoverStatus;
+    };
+    [TrueNasEndpoint.FailOverNode]: {
+        params: undefined;
+        response: FailoverNode;
+    };
+    [TrueNasEndpoint.FailOverDisabledReasons]: {
+        params: undefined;
+        response: string[];
+    };
+    [TrueNasEndpoint.PoolQuery]: {
+        params: undefined;
+        response: PoolQuery[];
+    };
+    [TrueNasEndpoint.BootGetState]: {
+        params: undefined;
+        response: PoolQuery;
+    };
+    [TrueNasEndpoint.DatasetQuery]: {
+        params: [
+            ApiQueryFilter[],
+            {
+                extra: {
+                    retrieve_children: boolean;
+                    properties?: string[];
+                };
+            }
+        ];
+        response: Dataset[];
+    };
+    [TrueNasEndpoint.DatasetCreate]: {
+        params: [{
+            name: string;
+            type: string;
+        }];
+        response: Dataset;
+    };
+    [TrueNasEndpoint.DatasetDelete]: {
+        params: [string, {
+            recursive: boolean;
+        }];
+        response: boolean | null;
+    };
+    [TrueNasEndpoint.SnapshotTaskCreate]: {
+        params: [PeriodicSnapshotTaskCreate];
+        response: PeriodicSnapshotTask;
+    };
+    [TrueNasEndpoint.SnapshotTaskQuery]: {
+        params: [ApiQueryFilter[]];
+        response: PeriodicSnapshotTask[];
+    };
+    [TrueNasEndpoint.SnapshotTaskDelete]: {
+        params: [number];
+        response: boolean;
+    };
+    [TrueNasEndpoint.SnapshotCreate]: {
+        params: [CreateZfsSnapshot];
+        response: ZfsSnapshot;
+    };
+    [TrueNasEndpoint.SnapshotDelete]: {
+        params: [string];
+        response: boolean;
+    };
+    [TrueNasEndpoint.ReplicationCountEligibleSnapshots]: {
+        params: [CountEligibleSnapshotsParams];
+        response: EligibleSnapshotsCount;
+    };
+    [TrueNasEndpoint.VirtualInstanceQuery]: {
+        params: [ApiQueryFilter[]];
+        response: VirtualInstanceQuery[];
+    };
+    [TrueNasEndpoint.VirtualInstanceStart]: {
+        params: string[];
+        response: number;
+    };
+    [TrueNasEndpoint.VirtualInstanceStop]: {
+        params: [string, Omit<VirtualizationStopParams, 'force_after_timeout'>];
+        response: number;
+    };
+    [TrueNasEndpoint.VirtualInstanceRestart]: {
+        params: [string, Omit<VirtualizationStopParams, 'force_after_timeout'>];
+        response: number;
+    };
+    [TrueNasEndpoint.ContainerQuery]: {
+        params: [ApiQueryFilter[]];
+        response: ContainerQueryV26[];
+    };
+    [TrueNasEndpoint.ContainerStart]: {
+        params: [number];
+        response: number;
+    };
+    [TrueNasEndpoint.ContainerStop]: {
+        params: [number, ContainerStopOptionsV26];
+        response: number;
+    };
+    [TrueNasEndpoint.VmQuery]: {
+        params: [ApiQueryFilter[]];
+        response: VMQuery[];
+    };
+    [TrueNasEndpoint.VmStart]: {
+        params: [number, {
+            overcommit?: boolean;
+        }];
+        response: number;
+    };
+    [TrueNasEndpoint.VmStop]: {
+        params: [number, {
+            force?: boolean;
+            force_after_timeout?: boolean;
+        }];
+        response: number;
+    };
+    [TrueNasEndpoint.VmRestart]: {
+        params: [number];
+        response: number;
+    };
+    [TrueNasEndpoint.CoreSubscribe]: {
+        params: string[];
+        response: unknown;
+    };
+    [TrueNasEndpoint.HardwareVirtualizationVariant]: {
+        params: undefined;
+        response: VirtVariant;
+    };
+}
+type ApiQueryFilter = [string, string, string | number | boolean];
+type ApiCallMethod = keyof ApiCallDirectory;
+type ApiCallParams<T extends ApiCallMethod> = ApiCallDirectory[T]['params'];
+type ApiCallResponse<T extends ApiCallMethod> = ApiCallDirectory[T]['response'];
+
+/**
+ * Minimal logging surface the client writes to. Consumers inject their own
+ * implementation; the package never depends on a concrete logging library.
+ * Method signatures mirror the TrueNAS Connect UI `Log` service so call sites
+ * port unchanged.
+ */
+interface Logger {
+    trace(message: string, ...args: unknown[]): void;
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+}
+/** Logger that forwards to the global `console`. */
+declare const consoleLogger: Logger;
+/** Logger that discards everything. The default when no logger is provided. */
+declare const noopLogger: Logger;
+
+declare class TrueNasSocket {
+    config: WebSocketSubjectConfig<TrueNasMessage>;
+    socket: rxjs_webSocket.WebSocketSubject<TrueNasMessage>;
+    constructor(config: WebSocketSubjectConfig<TrueNasMessage>);
+    messages(): rxjs_webSocket.WebSocketSubject<TrueNasMessage>;
+    next(msg: TrueNasMessage): void;
+    complete(): void;
+}
+
+interface ActiveConnection {
+    ws: TrueNasSocket;
+    hostname: string;
+}
+interface ConnectionError extends Error {
+    hostname?: string;
+}
+type Connection = ActiveConnection & {
+    state: 'active';
+} | ConnectionError & {
+    state: 'error';
+} | {
+    state: 'closed';
+};
+declare class TrueNasConnection {
+    private readonly hostnames;
+    readonly systemUuid: string;
+    readonly websocketPath: string;
+    readonly systemName?: string | undefined;
+    readonly retryDelay: number;
+    readonly maxRetry: number;
+    readonly logger: Logger;
+    opened: BehaviorSubject<boolean>;
+    closed: Subject<void>;
+    hostname: BehaviorSubject<string>;
+    ws: TrueNasSocket;
+    connectionAttempts: BehaviorSubject<number>;
+    lastErrorMessage: BehaviorSubject<string | null>;
+    /**
+     * emits when the connection is manually closed.
+     */
+    closeConnection: Subject<void>;
+    /**
+     * the connection only establishes a socket while this gate is `true`. consumers
+     * flip it via `setEnabled()` (the app maps `SystemState.Active -> true`).
+     */
+    private enabled$;
+    /**
+     * observable which emits the current gate value and only emits again when it changes.
+     */
+    enabledChange$: Observable<boolean>;
+    /**
+     * observable that handles the entire connection lifecycle.
+     */
+    connection$: Observable<Connection>;
+    /**
+     * observable which is either an instance of the current `TrueNasSocket` used for the connection
+     * or `null` if the connection is closed or errored for any reason.
+     */
+    ws$: Observable<TrueNasSocket | null>;
+    /**
+     * current hostname we used to build the URL for this connection.
+     */
+    hostname$: Observable<string | null>;
+    /**
+     * emits error messages from the connection pipeline. this is used to derive the
+     * corresponding compatibility property.
+     */
+    lastErrorMessage$: Observable<string | null>;
+    /**
+     * emits when the connection state *changes*, so it'll never emit `true` twice
+     * in a row nor `false` twice in a row.
+     */
+    opened$: Observable<boolean>;
+    /**
+     * emits when the connection state goes from open to closed.
+     */
+    closed$: Observable<void>;
+    /**
+     * whether to display a connection error to the user — the **live** signal.
+     *
+     * `true` only while `connection$` is currently a `ConnectionError`, meaning the entire race +
+     * retry cycle has been exhausted for all hostnames right now; it flips back to `false` once a
+     * connection is re-established. individual socket losses during a race are expected and not surfaced.
+     *
+     * NOTE: this is NOT the same as the `hasExhaustedRetries()` method, which is a **cumulative**
+     * snapshot (see there). The two can disagree — prefer this observable for "is the connection
+     * errored right now?".
+     */
+    hasConnectionError$: Observable<boolean>;
+    /**
+     * observable which always emits messages from the current socket.
+     */
+    messages$: Observable<TrueNasMessage>;
+    constructor(initialEnabled: boolean, hostnames: string[], systemUuid: string, websocketPath: string, systemName?: string | undefined, retryDelay?: number, maxRetry?: number, logger?: Logger);
+    /**
+     * whether the connection has exhausted its retries — the **cumulative** snapshot, read
+     * synchronously. (Formerly `hasConnectionError()`; renamed to disambiguate it from the
+     * live `hasConnectionError$` observable, with which it can disagree.)
+     *
+     * `true` when the lifetime `connectionAttempts` count exceeds `hostnames.length * maxRetry`,
+     * OR when an error message is currently set. Ported from the source (tncui) behavior.
+     *
+     * CAVEAT (pre-existing tncui behavior, preserved here): `connectionAttempts` only ever grows —
+     * it is never reset on a successful (re)connection — so over a long-lived connection with
+     * reconnect churn this can latch to `true` even while the connection is currently healthy. For
+     * "is it errored right now?" use the live `hasConnectionError$` observable instead.
+     */
+    hasExhaustedRetries(): boolean;
+    /**
+     * enables or disables the connection gate. the app calls this when its `SystemState`
+     * changes (mapping `SystemState.Active -> true`, everything else -> `false`).
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * compatibility method which just returns the public `messages$` observable.
+     * this is used in a few places in the codebase that relied upon the old implementation.
+     */
+    messages(): Observable<TrueNasMessage>;
+    /**
+     * sends a message over the current websocket OR queues it to send once
+     * the next websocket is opened. messages sent via `send` will not be lost until after
+     * the next `closed$` emission.
+     */
+    send(message: TrueNasMessage): rxjs.Subscription;
+    /**
+     * manually closes this connection and prevents it from retrying/opening any more.
+     */
+    close(): void;
+    /**
+     * helper method which creates an `Observable` which emits an `ActiveConnection`
+     * after it establishes a connection to the given hostname. the observable will emit an
+     * error if the connection is never established and will not complete until unsubscribed from or closed.
+     */
+    private createSocket;
+    /**
+     * helper function which actually performs the parallel connection `race`.
+     */
+    private connect;
+}
+
+/**
+ * TrueNAS API handler using the JSON-RPC 2.0 protocol.
+ *
+ * It handles:
+ * - JSON-RPC 2.0 request formatting
+ * - JSON-RPC 2.0 response parsing (result/error)
+ * - Event subscriptions
+ * - Job tracking
+ */
+declare class TrueNasApi {
+    authenticated: BehaviorSubject<boolean>;
+    connection: TrueNasConnection;
+    /**
+     * Stream of job events from websocket.
+     * JSON-RPC 2.0 events have structure: { method: 'collection_update', params: { collection, fields, ... } }
+     */
+    private jobEvents;
+    constructor(authenticated: BehaviorSubject<boolean>, connection: TrueNasConnection);
+    call<M extends ApiCallMethod>(method: M, params?: ApiCallParams<M>): Observable<ApiCallResponse<M>>;
+    /**
+     * 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.
+     *
+     * The job ID is extracted from the first job event where message_ids contains
+     * the original request ID.
+     *
+     * @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<M extends ApiCallMethod>(method: M, params?: ApiCallParams<M>): Observable<number>;
+    events(eventName: string): Observable<TrueNasMessage>;
+    /**
+     * Convenience wrapper for auth.generate_token API call.
+     */
+    generateToken(ttl?: number, matchOrigin?: boolean, singleUse?: boolean): Observable<string>;
+    trackJob(jobId: number): Observable<Job>;
+    private initializeJobEventsSubscription;
+}
+
+/**
+ * TrueNAS authenticator using the JSON-RPC 2.0 protocol.
+ *
+ * It handles authentication using the JSON-RPC 2.0 message format.
+ */
+declare class TrueNasAuthenticator {
+    private connection;
+    static readonly DefaultSessionLifetime = 300;
+    /**
+     * whether or not the system is currently authenticated and accessible.
+     * this is a `BehaviorSubject` instead of a signal, since we use its `getValue` method
+     * throughout a lot of the codebase.
+     */
+    authenticated$: BehaviorSubject<boolean>;
+    /**
+     * `true` when the system is currently being authenticated to, and `false` otherwise.
+     * does not indicate whatsoever if authentication is successful or not, just whether the process
+     * is ongoing.
+     */
+    authenticating$: BehaviorSubject<boolean>;
+    credentials: {
+        username: string;
+        password: string;
+        key: string;
+    };
+    sessionLifetime: number;
+    constructor(connection: TrueNasConnection);
+    loginWithUserPass(username: string, password: string): rxjs.Observable<AuthResponse>;
+    loginWithOtp(code: string): rxjs.Observable<AuthResponse>;
+    loginWithApiKey(credentials: {
+        username: string;
+        key: string;
+    }): rxjs.Observable<AuthResponse>;
+    newApiKey(username: string): rxjs.Observable<ApiKeyCreate>;
+    logout(): rxjs.Observable<boolean>;
+}
+
+/**
+ * Response from the /api/versions endpoint
+ * Returns an array of version strings directly
+ * Example: ["v25.10.0", "v25.10.1", "v26.0.0"]
+ */
+type ApiVersionResponse = string[];
+/**
+ * Parsed API version information
+ *
+ * Version format:
+ * - Legacy (v25.x): vYY.MM.PATCH (e.g., v25.10.0 = October 2025, patch 0)
+ * - New (v26+): vYY.MINOR.PATCH (e.g., v26.0.0 = 2026, minor 0, patch 0)
+ *
+ * Note: The second segment has different semantics based on the year:
+ * - Year 25: month (1-12)
+ * - Year 26+: minor version (0-99)
+ */
+interface ApiVersion {
+    /** Full version string (e.g., "v26.0.0") */
+    version: string;
+    /** Two-digit year (e.g., 26 = 2026) */
+    year: number;
+    /**
+     * Second version segment (semantics depend on year):
+     * - For v25.x: month (1-12, e.g., 10 = October)
+     * - For v26+: minor version (0-99)
+     */
+    minor: number;
+    /** Patch version number (e.g., 0, 1, 2) */
+    patch: number;
+    /** WebSocket path for this version (e.g., "/api/v26.0.0") */
+    websocketPath: string;
+}
+/**
+ * Version compatibility status
+ */
+declare enum VersionCompatibility {
+    Compatible = "compatible",
+    TooOld = "too-old",
+    TooNew = "too-new",
+    Invalid = "invalid"
+}
+
+/**
+ * OperationMappings Interface
+ *
+ * Defines version-agnostic operations that abstract away API differences
+ * between TrueNAS versions. Each API client version implements this interface
+ * with its specific endpoint calls and response transformations.
+ *
+ * Operations return Observable<Job | null> that:
+ * - For async operations: emits Job updates until complete, then completes
+ * - For sync operations: emits null once, then completes
+ *
+ * Usage in components:
+ * ```typescript
+ * const truenas = this.truenasService.get(systemId);
+ * truenas.ops.containerQuery().subscribe(containers => ...);
+ *
+ * // With progress dialog (recommended)
+ * this.truenasService.trackWithDialog(
+ *   truenas.ops.containerStart(id),
+ *   'Starting container'
+ * ).subscribe(() => console.log('Started'));
+ *
+ * // Without progress dialog
+ * truenas.ops.containerStart(id).subscribe({
+ *   next: (job) => job && console.log(job.progress),
+ *   complete: () => console.log('Started')
+ * });
+ * ```
+ *
+ * Version mappings:
+ * - v25.10: Uses virt.instance.* APIs (emits Job updates)
+ * - v26+: Uses container.* APIs (some emit Job, some emit null)
+ *
+ * To add new operations:
+ * 1. Add the method signature here
+ * 2. Implement in TrueNasApiClientV2510.createOperations()
+ * 3. Implement in TrueNasApiClientV26.createOperations()
+ */
+interface OperationMappings {
+    /**
+     * Query all containers
+     * - v25.10: virt.instance.query with type=CONTAINER filter
+     * - v26+: container.query
+     */
+    containerQuery: () => Observable<Container[]>;
+    /**
+     * Start a container
+     * - v25.10: Emits Job updates until started
+     * - v26+: Emits null (synchronous operation)
+     */
+    containerStart: (id: string) => Observable<Job | null>;
+    /**
+     * Stop a container
+     * - v25.10: Emits Job updates until stopped
+     * - v26+: Emits Job updates until stopped
+     */
+    containerStop: (id: string, options: ContainerStopOptions) => Observable<Job | null>;
+    /**
+     * Restart a container
+     * - v25.10: Emits Job updates until restarted
+     * - v26+: Emits Job updates (stop phase), then null (sync start)
+     */
+    containerRestart: (id: string, options: ContainerRestartOptions) => Observable<Job | null>;
+}
+
+/**
+ * Abstract base class for TrueNAS API clients
+ *
+ * Provides common implementation for all API versions. Version-specific clients
+ * extend this class and override factory methods to provide custom implementations
+ * when needed.
+ *
+ * This class manages the lifecycle of all TrueNAS connection components:
+ * - TrueNasConnection (WebSocket connection management)
+ * - TrueNasApi (API call handling)
+ * - TrueNasAuthenticator (authentication)
+ */
+
+declare abstract class TrueNasApiClient {
+    /** API version information for this client */
+    readonly version: ApiVersion;
+    /** WebSocket connection manager */
+    readonly connection: TrueNasConnection;
+    /** Authentication manager */
+    readonly authenticator: TrueNasAuthenticator;
+    /** API call handler */
+    readonly api: TrueNasApi;
+    /**
+     * Version-agnostic operation mappings
+     *
+     * Provides a unified interface for operations that differ between API versions.
+     * Each version-specific client implements these operations using its own endpoints.
+     *
+     * Usage:
+     * ```typescript
+     * truenas.ops.containerQuery().subscribe(containers => ...);
+     * truenas.ops.containerStart(id).subscribe(jobId => ...);
+     * ```
+     */
+    readonly ops: OperationMappings;
+    /** System UUID */
+    protected readonly uuid: string;
+    /** System hostnames (primary and fallback) */
+    protected readonly hostnames: string[];
+    /**
+     * Initial connection gate, forwarded to the connection. The app flips it later
+     * via `connection.setEnabled()` (mapping its `SystemState.Active -> true`).
+     */
+    protected readonly enabled: boolean;
+    /** System name (optional) */
+    protected readonly systemName: string | undefined;
+    /** Logger forwarded to the connection (defaults to a no-op). */
+    protected readonly logger: Logger;
+    constructor(uuid: string, hostnames: string[], version: ApiVersion, enabled: boolean, systemName?: string, logger?: Logger);
+    /**
+     * Get current connection status.
+     * @returns true if WebSocket is connected
+     */
+    get connected(): boolean;
+    /**
+     * Get current authentication status.
+     * @returns true if authenticated with the system
+     */
+    get authenticated(): boolean;
+    /**
+     * Close the WebSocket connection.
+     * Connection will automatically retry if retry is enabled.
+     */
+    close(): void;
+    /**
+     * Factory method to create the WebSocket connection.
+     * Override in subclasses to provide version-specific connection handling.
+     */
+    protected createConnection(): TrueNasConnection;
+    /**
+     * Factory method to create the API handler.
+     * Override in subclasses to provide version-specific API implementations.
+     */
+    protected createApi(): TrueNasApi;
+    /**
+     * Factory method to create the authenticator.
+     * Override in subclasses to provide version-specific authentication.
+     */
+    protected createAuthenticator(): TrueNasAuthenticator;
+    /**
+     * Factory method to create version-specific operation mappings.
+     * Must be implemented by subclasses to provide version-specific implementations.
+     *
+     * This is the primary extension point for handling API differences between versions.
+     */
+    protected abstract createOperations(): OperationMappings;
+}
+
+/** Options for {@link createTrueNasClient}. */
+interface CreateClientOptions {
+    /** System UUID. */
+    uuid: string;
+    /** Hostnames to connect to — primary first, then fallbacks. */
+    hostnames: string[];
+    /**
+     * Initial connection gate. The client only opens a socket while this is `true`;
+     * flip it later via `client.connection.setEnabled()`. (The app maps its
+     * `SystemState.Active -> true`.)
+     */
+    enabled: boolean;
+    /** Optional system name (used only for log context). */
+    systemName?: string;
+    /**
+     * Optional logger; defaults to a no-op. Forwarded to version discovery and,
+     * through the client, to the connection.
+     */
+    logger?: Logger;
+}
+/**
+ * Creates a version-specific TrueNAS API client.
+ *
+ * 1. Discovers the API version from the primary hostname (`GET /api/versions`).
+ * 2. Selects the matching client implementation (`v25.10.x` -> `TrueNasApiClientV2510`,
+ *    `v26.x.y` -> `TrueNasApiClientV26`).
+ * 3. Instantiates and returns it.
+ *
+ * Resolves exactly once with a single client instance — dispose of it with
+ * `client.close()` when done.
+ *
+ * @returns a Promise that resolves with the created client, or rejects with a
+ *   {@link VersionDiscoveryError} subclass (or a client-selection error).
+ *   Rejects if `hostnames` is empty.
+ */
+declare function createTrueNasClient(opts: CreateClientOptions): Promise<TrueNasApiClient>;
+
+/**
+ * TrueNAS API Client for v25.10.x
+ *
+ * Handles all v25.10 patch versions (v25.10.0, v25.10.1, v25.10.2, etc.).
+ * Patch versions are backward compatible, so one client implementation
+ * handles all patches within the v25.10.x series.
+ *
+ * To add version-specific behavior, override the factory methods:
+ * - createConnection() - for connection-specific changes
+ * - createApi() - for API method changes
+ * - createAuthenticator() - for authentication changes
+ * - createOperations() - for version-specific operation mappings
+ */
+
+/**
+ * API client for TrueNAS API v25.10.x
+ *
+ * Protocol: JSON-RPC 2.0
+ * WebSocket Path: /api/v25.10.{patch}
+ *
+ * Container operations use virt.instance.* APIs:
+ * - containerQuery → virt.instance.query (filtered by type=CONTAINER)
+ * - containerStart → virt.instance.start (emits Job updates)
+ * - containerStop → virt.instance.stop (emits Job updates)
+ * - containerRestart → virt.instance.restart (emits Job updates)
+ */
+declare class TrueNasApiClientV2510 extends TrueNasApiClient {
+    /**
+     * Create v25.10-specific operation mappings
+     *
+     * virt.instance.* APIs return boolean (true) but emit job events via websocket.
+     * We use callAndGetJobId to capture the job ID, then track the job.
+     * All operations emit Job updates until the operation completes.
+     */
+    protected createOperations(): OperationMappings;
+    /**
+     * Transform VirtualInstanceQuery to unified Container type
+     */
+    private toContainer;
+}
+
+/**
+ * TrueNAS API Client for v26.X.Y
+ *
+ * Handles all v26 versions (v26.0.0, v26.0.1, v26.1.2, etc.).
+ * Minor AND patch versions are backward compatible, so one client implementation
+ * handles all patches within the v26 series.
+ *
+ * To add version-specific behavior, override the factory methods:
+ * - createConnection() - for connection-specific changes
+ * - createApi() - for API method changes
+ * - createAuthenticator() - for authentication changes
+ * - createOperations() - for version-specific operation mappings
+ */
+
+/**
+ * API client for TrueNAS API v26
+ *
+ * Protocol: JSON-RPC 2.0
+ * WebSocket Path: /api/v26.{minor}.{patch}
+ *
+ * Container operations use native container.* APIs:
+ * - containerQuery → container.query (with response transformation)
+ * - containerStart → container.start (synchronous, emits null)
+ * - containerStop → container.stop (emits Job updates)
+ * - containerRestart → container.stop + container.start (emits Job, then null)
+ */
+declare class TrueNasApiClientV26 extends TrueNasApiClient {
+    /**
+     * Map v26 status state string to AppState enum
+     */
+    private static mapStatus;
+    /**
+     * Create v26-specific operation mappings
+     *
+     * Operations return Observable<Job | null>:
+     * - Async operations emit Job updates until complete
+     * - Sync operations emit null once
+     */
+    protected createOperations(): OperationMappings;
+    /**
+     * Transform v26 ContainerQueryV26 to unified Container type
+     */
+    private toContainer;
+}
+
+/**
+ * Discovers available API versions from TrueNAS systems.
+ *
+ * Performs a `fetch` GET to the `/api/versions` endpoint and:
+ * - Parses version strings
+ * - Filters to compatible versions (within MIN/MAX range)
+ * - Selects the latest compatible version
+ * - Caches results per hostname
+ * - Classifies failures into typed {@link VersionDiscoveryError} subclasses
+ *
+ * This is the framework-agnostic replacement for the app's Angular `HttpClient`
+ * service. Because `fetch` resolves (rather than rejects) on non-2xx responses and
+ * throws a `TypeError` on network/CORS/unreachable failures, the error contract
+ * differs from the original: a network/CORS/unreachable failure surfaces as a
+ * {@link VersionDiscoveryNetworkError} — the sentinel the client factory keys on for
+ * its CORS fallback (replacing the old `HttpErrorResponse.status === 0` check).
+ */
+declare class VersionDiscovery {
+    private readonly logger;
+    private versionCache;
+    constructor(logger?: Logger);
+    /**
+     * Discovers the API version for a given hostname.
+     *
+     * Makes a GET request to `https://{hostname}/api/versions` and returns the latest
+     * compatible version. Results are cached per hostname; the cache entry is removed
+     * on failure so the next call retries.
+     *
+     * @param hostname - The TrueNAS system hostname (e.g., "truenas.local")
+     * @returns Observable that emits the selected ApiVersion
+     * @throws VersionDiscoveryError subclasses for specific failure scenarios
+     */
+    discoverVersion(hostname: string): Observable<ApiVersion>;
+    /**
+     * Clears the version cache for a specific hostname or all hostnames.
+     *
+     * @param hostname - Optional hostname to clear. If omitted, clears all cached versions.
+     */
+    clearCache(hostname?: string): void;
+    /**
+     * Performs the `fetch` with a 5-second `AbortController` timeout and inspects the
+     * *resolved* Response (fetch does not reject on non-2xx). Throws
+     * `VersionEndpointNotFoundError` on 404 and `InvalidVersionResponseError` on any
+     * other non-2xx or a body that is not an array of strings; lets `TypeError`
+     * (network) and `AbortError` (timeout) bubble to `classify`.
+     *
+     * The element-type check matters: a reachable server returning an array of
+     * non-strings (e.g. `[1, 2, 3]`) would otherwise reach `parseApiVersion`, whose
+     * `.match()` throws a `TypeError` on a non-string — which `classify` would then
+     * misfile as a network error. Validating here keeps it an `InvalidVersionResponseError`.
+     */
+    private fetchVersions;
+    /**
+     * Parses, filters, and selects the latest compatible version from the raw response
+     * array. Throws the appropriate typed error when no valid/compatible version exists.
+     */
+    private selectVersion;
+    /**
+     * Maps a raw failure to a typed {@link VersionDiscoveryError}. Errors thrown by
+     * `fetchVersions`/`selectVersion` are already typed and pass through unchanged; a
+     * `fetch` `TypeError` becomes {@link VersionDiscoveryNetworkError} (the CORS/network
+     * sentinel), an `AbortError` becomes {@link VersionDiscoveryTimeoutError}, and any
+     * other failure (e.g. an unparseable body's `SyntaxError`) becomes
+     * {@link InvalidVersionResponseError}.
+     */
+    private classify;
+}
+
+/**
+ * Base class for all version discovery errors
+ */
+declare abstract class VersionDiscoveryError extends Error {
+    readonly hostname: string;
+    constructor(message: string, hostname: string);
+}
+/**
+ * Thrown when all available API versions are older than minimum supported version
+ */
+declare class VersionTooOldError extends VersionDiscoveryError {
+    readonly availableVersions: string[];
+    readonly minRequired: string;
+    constructor(hostname: string, availableVersions: string[], minRequired?: string);
+}
+/**
+ * Thrown when all available API versions are newer than maximum supported version
+ */
+declare class VersionTooNewError extends VersionDiscoveryError {
+    readonly availableVersions: string[];
+    readonly maxSupported: string;
+    constructor(hostname: string, availableVersions: string[], maxSupported?: string);
+}
+/**
+ * Thrown when the /api/versions endpoint returns 404
+ */
+declare class VersionEndpointNotFoundError extends VersionDiscoveryError {
+    readonly statusCode: number;
+    constructor(hostname: string, statusCode?: number);
+}
+/**
+ * Thrown when version discovery request times out
+ */
+declare class VersionDiscoveryTimeoutError extends VersionDiscoveryError {
+    readonly timeoutMs: number;
+    constructor(hostname: string, timeoutMs?: number);
+}
+/**
+ * Thrown when version discovery fails due to network error
+ */
+declare class VersionDiscoveryNetworkError extends VersionDiscoveryError {
+    readonly originalError: Error;
+    constructor(hostname: string, originalError: Error);
+}
+/**
+ * Thrown when no compatible versions are found in the response
+ */
+declare class NoCompatibleVersionsError extends VersionDiscoveryError {
+    readonly availableVersions: string[];
+    readonly supportedRange: {
+        min: string;
+        max: string;
+    };
+    constructor(hostname: string, availableVersions: string[], supportedRange?: {
+        min: string;
+        max: string;
+    });
+}
+/**
+ * Thrown when the API response is malformed or invalid
+ */
+declare class InvalidVersionResponseError extends VersionDiscoveryError {
+    readonly reason: string;
+    constructor(hostname: string, reason: string);
+}
+
+/**
+ * Stable, framework-agnostic authentication error codes. The authenticator throws
+ * `AuthError` with one of these codes; consumers translate the code to a localized
+ * message (the `message` here is a plain-English default / fallback).
+ */
+declare enum AuthErrorCode {
+    PasswordAuthFailed = "PASSWORD_AUTH_FAILED",
+    OtpAuthFailed = "OTP_AUTH_FAILED",
+    ApiKeyAuthFailed = "API_KEY_AUTH_FAILED",
+    FullAdminRequired = "FULL_ADMIN_REQUIRED"
+}
+declare class AuthError extends Error {
+    readonly code: AuthErrorCode;
+    constructor(code: AuthErrorCode, message: string);
+}
+
+/**
+ * API error types for versioned TrueNAS API
+ *
+ * Handles both JSON-RPC 2.0 standard errors and TrueNAS custom error formats.
+ */
+/**
+ * JSON-RPC 2.0 standard error format
+ * @see https://www.jsonrpc.org/specification#error_object
+ */
+interface JsonRpcError {
+    /** Error code indicating the error type */
+    code: number;
+    /** Human-readable error message */
+    message: string;
+    /** Optional additional error data */
+    data?: unknown;
+}
+/**
+ * TrueNAS custom error format
+ * Used in some API responses alongside JSON-RPC errors
+ */
+interface TrueNasError {
+    /** Additional error properties */
+    [key: string]: unknown;
+    /** Human-readable error reason (TrueNAS-specific field) */
+    reason: string;
+}
+/**
+ * Union type for all possible API error formats
+ */
+type ApiError = JsonRpcError | TrueNasError;
+/**
+ * Extract a human-readable error message from an API error
+ *
+ * Handles multiple error formats:
+ * - JSON-RPC 2.0 with nested TrueNAS data: uses `data.reason` field
+ * - JSON-RPC 2.0 standard: uses `message` field
+ * - TrueNAS custom: uses `reason` field
+ * - Unknown format: returns fallback message
+ *
+ * @param error - The error object from API response
+ * @param fallback - Fallback message if error format is unrecognized
+ * @returns Human-readable error message
+ */
+declare function getApiErrorMessage(error: unknown, fallback?: string): string;
+
+export { type ApiCallDirectory, type ApiCallMethod, type ApiCallParams, type ApiCallResponse, type ApiError, type ApiKeyCreate, type ApiVersion, type ApiVersionResponse, AuthError, AuthErrorCode, type AuthResponse, type Container, type CreateClientOptions, InvalidVersionResponseError, type Job, JobState, type Logger, NoCompatibleVersionsError, type OperationMappings, TrueNasApiClient, TrueNasApiClientV2510, TrueNasApiClientV26, TrueNasAuthMechanism, TrueNasEndpoint, VersionCompatibility, VersionDiscovery, VersionDiscoveryError, VersionDiscoveryNetworkError, VersionDiscoveryTimeoutError, VersionEndpointNotFoundError, VersionTooNewError, VersionTooOldError, consoleLogger, createTrueNasClient, getApiErrorMessage, noopLogger };