@synopackageland/cli 0.3.1 → 0.3.2

package/dist/host/broker-upgrade-preflight.d.ts

@@ -0,0 +1,61 @@
+export declare const BROKER_UPGRADE_TARGET_HOST = "10.17.83.200";
+export type DsmUpgradeResponseKind = "error-4552" | "success" | "consent" | "unknown";
+export interface ConsentDialogEvidence {
+    consentDialog: {
+        dependers: string[];
+    };
+}
+export interface BrokerUpgradeDependerBaseline {
+    packageIdentity: string;
+    version: string;
+    status: string;
+    running: boolean;
+}
+export interface BrokerUpgradeDepender extends BrokerUpgradeDependerBaseline {
+    healthCheckOk: boolean;
+    a23Classified: boolean;
+    dataSnapshotOk: boolean;
+}
+export interface BrokerUpgradePreflightInput {
+    targetHost: string;
+    broker: {
+        version: string;
+        status: string;
+        running: boolean;
+    };
+    dependers: BrokerUpgradeDepender[];
+    previousSpk: {
+        available: boolean;
+        sha256?: string;
+    };
+    canonicalizeGateSatisfied: boolean;
+    catalogEntry: {
+        version: string;
+    };
+}
+export type PreflightDecision = {
+    ok: true;
+} | {
+    ok: false;
+    codes: string[];
+};
+export interface Evaluate4552BranchInput {
+    response: unknown;
+    dependers: BrokerUpgradeDependerBaseline[];
+}
+/**
+ * Classify only already-parsed DSM evidence. Strings are deliberately never
+ * parsed or searched: a textual mention of 4552 is not a DSM error response.
+ */
+export declare function classifyDsmUpgradeResponse(raw: unknown): DsmUpgradeResponseKind;
+/**
+ * Evaluate every local prerequisite without performing an upgrade or
+ * proposing a stop/start action. A missing or malformed prerequisite is a
+ * failure, even when another part of the input looks healthy.
+ */
+export declare function evaluateBrokerUpgradePreflight(input: BrokerUpgradePreflightInput): PreflightDecision;
+/**
+ * The 4552 path is entered only for a numeric DSM error and a non-empty,
+ * fully identified running baseline inventory.
+ */
+export declare function evaluate4552Branch(input: Evaluate4552BranchInput): PreflightDecision;

package/dist/host/broker-upgrade-preflight.js

@@ -0,0 +1,156 @@
+import { comparePackageVersions } from "@synopackageland/package-source/index-manifest";
+export const BROKER_UPGRADE_TARGET_HOST = "10.17.83.200";
+/**
+ * Classify only already-parsed DSM evidence. Strings are deliberately never
+ * parsed or searched: a textual mention of 4552 is not a DSM error response.
+ */
+export function classifyDsmUpgradeResponse(raw) {
+    if (!isRecord(raw)) {
+        return "unknown";
+    }
+    if (isRecord(raw.error) && raw.error.code === 4552) {
+        return "error-4552";
+    }
+    const hasError = Object.prototype.hasOwnProperty.call(raw, "error") &&
+        raw.error !== null &&
+        raw.error !== undefined;
+    if (raw.success === true && !hasError) {
+        return "success";
+    }
+    if (isConsentDialogEvidence(raw)) {
+        return "consent";
+    }
+    return "unknown";
+}
+/**
+ * Evaluate every local prerequisite without performing an upgrade or
+ * proposing a stop/start action. A missing or malformed prerequisite is a
+ * failure, even when another part of the input looks healthy.
+ */
+export function evaluateBrokerUpgradePreflight(input) {
+    const candidate = isRecord(input) ? input : {};
+    const codes = [];
+    const addCode = (code) => {
+        if (!codes.includes(code)) {
+            codes.push(code);
+        }
+    };
+    if (candidate.targetHost !== BROKER_UPGRADE_TARGET_HOST) {
+        addCode("PREFLIGHT_WRONG_TARGET");
+    }
+    const broker = candidate.broker;
+    if (!isRecord(broker)) {
+        addCode("PREFLIGHT_BROKER_NOT_RUNNING");
+        addCode("PREFLIGHT_BROKER_VERSION_INVALID");
+    }
+    else {
+        if (broker.running !== true || broker.status !== "running") {
+            addCode("PREFLIGHT_BROKER_NOT_RUNNING");
+        }
+        if (!isNonEmptyString(broker.version)) {
+            addCode("PREFLIGHT_BROKER_VERSION_INVALID");
+        }
+    }
+    const dependers = candidate.dependers;
+    if (!Array.isArray(dependers)) {
+        addCode("PREFLIGHT_DEPENDER_INVENTORY_INVALID");
+    }
+    else {
+        for (const depender of dependers) {
+            if (!isRecord(depender)) {
+                addCode("PREFLIGHT_DEPENDER_INVENTORY_INVALID");
+                continue;
+            }
+            if (!isNonEmptyString(depender.packageIdentity) || !isNonEmptyString(depender.version)) {
+                addCode("PREFLIGHT_DEPENDER_INVENTORY_INVALID");
+            }
+            if (depender.running !== true) {
+                addCode("PREFLIGHT_DEPENDER_NOT_RUNNING");
+            }
+            if (depender.status !== "running") {
+                addCode("PREFLIGHT_DEPENDER_UNSAFE_STATUS");
+            }
+            if (depender.healthCheckOk !== true) {
+                addCode("PREFLIGHT_DEPENDER_HEALTHCHECK_FAILED");
+            }
+            if (depender.a23Classified !== true) {
+                addCode("PREFLIGHT_DEPENDER_A23_UNCLASSIFIED");
+            }
+            if (depender.dataSnapshotOk !== true) {
+                addCode("PREFLIGHT_DEPENDER_DATA_SNAPSHOT_MISSING");
+            }
+        }
+    }
+    const previousSpk = candidate.previousSpk;
+    if (!isRecord(previousSpk) || previousSpk.available !== true) {
+        addCode("PREFLIGHT_PREVIOUS_SPK_UNAVAILABLE");
+    }
+    else if (!isSha256(previousSpk.sha256)) {
+        addCode("PREFLIGHT_PREVIOUS_SPK_DIGEST_INVALID");
+    }
+    if (candidate.canonicalizeGateSatisfied !== true) {
+        addCode("PREFLIGHT_CANONICALIZE_GATE_UNSATISFIED");
+    }
+    const catalogEntry = candidate.catalogEntry;
+    if (!isRecord(catalogEntry) || !isNonEmptyString(catalogEntry.version)) {
+        addCode("PREFLIGHT_CATALOG_VERSION_INVALID");
+    }
+    else if (!isRecord(broker) || !isNonEmptyString(broker.version)) {
+        // The broker version gate is already reported above; without both version
+        // strings there is no safe comparison to perform.
+        addCode("PREFLIGHT_VERSION_COMPARISON_INVALID");
+    }
+    else {
+        const comparison = comparePackageVersions(catalogEntry.version, broker.version);
+        if (!Number.isFinite(comparison)) {
+            addCode("PREFLIGHT_VERSION_COMPARISON_INVALID");
+        }
+        else if (comparison <= 0) {
+            addCode("PREFLIGHT_CATALOG_VERSION_NOT_NEWER");
+        }
+    }
+    return decisionFromCodes(codes);
+}
+/**
+ * The 4552 path is entered only for a numeric DSM error and a non-empty,
+ * fully identified running baseline inventory.
+ */
+export function evaluate4552Branch(input) {
+    const candidate = isRecord(input) ? input : {};
+    const codes = [];
+    if (classifyDsmUpgradeResponse(candidate.response) !== "error-4552") {
+        codes.push("PREFLIGHT_RESPONSE_NOT_4552");
+    }
+    const dependers = candidate.dependers;
+    if (!Array.isArray(dependers) ||
+        dependers.length === 0 ||
+        dependers.some((depender) => !isRunningBaseline(depender))) {
+        codes.push("PREFLIGHT_DEPENDER_INVENTORY_INCOMPLETE");
+    }
+    return decisionFromCodes(codes);
+}
+function decisionFromCodes(codes) {
+    return codes.length === 0 ? { ok: true } : { ok: false, codes };
+}
+function isRunningBaseline(value) {
+    return (isRecord(value) &&
+        isNonEmptyString(value.packageIdentity) &&
+        isNonEmptyString(value.version) &&
+        value.status === "running" &&
+        value.running === true);
+}
+function isConsentDialogEvidence(value) {
+    const dialog = value.consentDialog;
+    return (isRecord(dialog) &&
+        Array.isArray(dialog.dependers) &&
+        dialog.dependers.every((depender) => typeof depender === "string"));
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.length > 0;
+}
+function isSha256(value) {
+    return typeof value === "string" && /^[0-9a-fA-F]{64}$/.test(value);
+}

package/dist/host/catalog-install.d.ts

@@ -23,11 +23,23 @@ export interface InstalledPackageState {
     installed: boolean;
     version?: string;
     status?: string;
+    error?: {
+        code?: number;
+        description?: string;
+        workerMsg?: unknown[];
+    };
+    brokenBy?: string;
+    stage?: string;
+    lastStage?: string;
+    statusCode?: number;
+    statusDescription?: string;
+    statusOrigin?: string;
 }
 export interface UploadedCatalogPackage {
     id: string;
     taskId: string;
 }
+export declare function packageStateFromRecord(value: unknown): InstalledPackageState;
 export declare function packageStateFromListPayload(payload: unknown, packageId: string): InstalledPackageState | undefined;
 export declare function fetchInstalledPackageState(dsmOrigin: string, cookieHeader: string, packageId: string): Promise<InstalledPackageState | undefined>;
 export declare function waitForInstalledVersion(readState: () => InstalledPackageState | undefined | Promise<InstalledPackageState | undefined>, options: {

package/dist/host/catalog-install.js

@@ -1,6 +1,7 @@
 import { readFileSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { dsmFetch } from "./dsm-http.js";
+import { assertDsmCompoundResponse } from "./dsm-compound.js";
 function normalizeDeppkgs(deppkgs) {
     if (typeof deppkgs === "string") {
         const match = /^([^><=]+)(>=|>|<=|<|==)(.+)$/.exec(deppkgs.trim());
@@ -27,7 +28,9 @@ async function dsmWebApi(dsmOrigin, cookieHeader, params, options = {}) {
     });
     const body = (await response.json());
     const errorCode = body.error?.code;
-    if (!body.success && !(errorCode && options.allowErrorCodes?.includes(errorCode))) {
+    if (!body.success &&
+        !options.allowFailure &&
+        !(errorCode && options.allowErrorCodes?.includes(errorCode))) {
         throw new Error(`DSM ${params.api}/${params.method} failed: ${JSON.stringify(body.error ?? body)}`);
     }
     return body;
@@ -92,29 +95,90 @@ function readInstalledPackageState(packageId, profileName) {
     }
     try {
         const parsed = JSON.parse(result.stdout);
-        if (!parsed.data?.installed) {
-            return { installed: false, version: parsed.data?.version, status: parsed.data?.status };
-        }
-        return { installed: true, version: parsed.data.version, status: parsed.data.status };
+        return packageStateFromRecord(parsed.data);
     }
     catch {
         return undefined;
     }
 }
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function stringValue(...values) {
+    return values.find((value) => typeof value === "string" && value.length > 0);
+}
+function numberValue(...values) {
+    return values.find((value) => typeof value === "number" && Number.isFinite(value));
+}
+function packageError(value) {
+    const source = record(value);
+    const code = numberValue(source.code);
+    const description = stringValue(source.description);
+    const workerMsg = Array.isArray(source.worker_msg)
+        ? source.worker_msg
+        : Array.isArray(source.workerMsg)
+            ? source.workerMsg
+            : undefined;
+    if (code === undefined && description === undefined && workerMsg === undefined) {
+        return undefined;
+    }
+    const error = {};
+    if (code !== undefined)
+        error.code = code;
+    if (description !== undefined)
+        error.description = description;
+    if (workerMsg !== undefined)
+        error.workerMsg = workerMsg;
+    return error;
+}
+export function packageStateFromRecord(value) {
+    const match = record(value);
+    const additional = record(match.additional);
+    const installedInfo = record(additional.installed_info ?? match.installedInfo);
+    const installedPath = stringValue(installedInfo.path, match.installedPath);
+    const version = stringValue(match.version);
+    const status = stringValue(additional.status, match.rawStatus, match.status);
+    const error = packageError(additional.error ?? match.error);
+    const state = {
+        installed: Boolean(installedPath) || match.installed === true,
+    };
+    if (version !== undefined)
+        state.version = version;
+    if (status !== undefined)
+        state.status = status;
+    if (error !== undefined)
+        state.error = error;
+    const brokenBy = stringValue(additional.broken_by, additional.brokenBy, match.broken_by, match.brokenBy);
+    if (brokenBy !== undefined)
+        state.brokenBy = brokenBy;
+    const stage = stringValue(additional.stage, match.stage);
+    if (stage !== undefined)
+        state.stage = stage;
+    const lastStage = stringValue(additional.last_stage, additional.lastStage, match.last_stage, match.lastStage);
+    if (lastStage !== undefined)
+        state.lastStage = lastStage;
+    const statusCode = numberValue(additional.status_code, additional.statusCode, match.status_code, match.statusCode, match.rawStatusCode);
+    if (statusCode !== undefined)
+        state.statusCode = statusCode;
+    const statusDescription = stringValue(additional.status_description, additional.statusDescription, match.status_description, match.statusDescription, match.rawStatusDescription);
+    if (statusDescription !== undefined)
+        state.statusDescription = statusDescription;
+    const statusOrigin = stringValue(additional.status_origin, additional.statusOrigin, match.status_origin, match.statusOrigin, match.rawStatusOrigin);
+    if (statusOrigin !== undefined)
+        state.statusOrigin = statusOrigin;
+    return state;
+}
 export function packageStateFromListPayload(payload, packageId) {
-    const record = payload && typeof payload === "object" ? payload : undefined;
-    const data = record?.data && typeof record.data === "object" ? record.data : record;
+    const root = payload && typeof payload === "object" ? payload : undefined;
+    const data = root?.data && typeof root.data === "object" ? root.data : root;
     const packages = Array.isArray(data?.packages) ? data.packages : [];
     const match = packages.find((item) => item && typeof item === "object" && item.id === packageId);
     if (!match) {
         return { installed: false };
     }
-    const additional = match.additional;
-    const installedPath = additional?.installed_info?.path;
-    const installed = Boolean(installedPath) || match.installed === true;
-    const status = typeof additional?.status === "string" ? additional.status : undefined;
-    const version = typeof match.version === "string" ? match.version : undefined;
-    return { installed, version, status };
+    return packageStateFromRecord(match);
 }
 export async function fetchInstalledPackageState(dsmOrigin, cookieHeader, packageId) {
     try {
@@ -265,7 +329,7 @@ export async function installPackageFromLocalSpk(options) {
     const installed = dsmState?.installed === true || isPackageInstalled(options.packageId, options.profileName);
     const uploaded = await uploadLocalSpk(options, sid);
     const compound = JSON.stringify(catalogCompoundSteps(uploaded, { version: options.version, size: readFileSync(options.spkPath).byteLength }, { blupgrade: installed, extraValues: options.extraValues }));
-    await dsmWebApi(options.dsmOrigin, options.cookieHeader, {
+    const compoundResponse = await dsmWebApi(options.dsmOrigin, options.cookieHeader, {
         api: "SYNO.Entry.Request",
         version: "1",
         method: "request",
@@ -273,7 +337,8 @@ export async function installPackageFromLocalSpk(options) {
         mode: jsonApiParam("sequential"),
         compound,
         _sid: sid,
-    });
+    }, { allowFailure: true });
+    assertDsmCompoundResponse(compoundResponse);
     await waitForInstalledVersion(async () => (await fetchInstalledPackageState(options.dsmOrigin, options.cookieHeader, options.packageId)) ??
         readInstalledPackageState(options.packageId, options.profileName), { packageId: options.packageId, expectedVersion: options.version });
 }
@@ -303,7 +368,7 @@ async function uploadCatalogSpk(options, entry, sid) {
 async function installCatalogViaUpload(options, entry, sid, installed) {
     const uploaded = await uploadCatalogSpk(options, entry, sid);
     const compound = JSON.stringify(catalogCompoundSteps(uploaded, entry, { blupgrade: installed, extraValues: options.extraValues }));
-    await dsmWebApi(options.dsmOrigin, options.cookieHeader, {
+    const compoundResponse = await dsmWebApi(options.dsmOrigin, options.cookieHeader, {
         api: "SYNO.Entry.Request",
         version: "1",
         method: "request",
@@ -311,7 +376,8 @@ async function installCatalogViaUpload(options, entry, sid, installed) {
         mode: jsonApiParam("sequential"),
         compound,
         _sid: sid,
-    });
+    }, { allowFailure: true });
+    assertDsmCompoundResponse(compoundResponse);
 }
 export async function installPackageFromCatalog(options) {
     const entry = options.expectedVersion

package/dist/host/credentials.js

@@ -1,6 +1,32 @@
 import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+function findProfile(settings, input) {
+    if (!input) {
+        return settings.hosts?.[settings.defaultHost ?? "default"];
+    }
+    // 1. Direct match by profile name
+    if (settings.hosts?.[input]) {
+        return settings.hosts[input];
+    }
+    // 2. Match by URL hostname or exact URL
+    for (const profile of Object.values(settings.hosts ?? {})) {
+        if (profile?.url) {
+            try {
+                const u = new URL(profile.url);
+                if (u.hostname === input ||
+                    profile.url === input ||
+                    profile.url.replace(/\/$/, "") === input.replace(/\/$/, "")) {
+                    return profile;
+                }
+            }
+            catch {
+                // ignore invalid URL
+            }
+        }
+    }
+    return undefined;
+}
 export function resolveHostCredentials(hostName) {
     const settingsPath = join(homedir(), ".synoagentcli", "setting.json");
     let settings;
@@ -8,10 +34,9 @@ export function resolveHostCredentials(hostName) {
         settings = JSON.parse(readFileSync(settingsPath, "utf8"));
     }
     catch {
-        return fromEnv();
+        return fromEnv(hostName);
     }
-    const selected = hostName ?? settings.defaultHost ?? "default";
-    const profile = settings.hosts?.[selected] ?? settings.hosts?.[settings.defaultHost ?? "default"];
+    const profile = findProfile(settings, hostName);
     const username = profile?.username ?? profile?.auth?.username;
     const password = profile?.password ?? profile?.auth?.password;
     if (profile?.url && username && password) {
@@ -24,10 +49,15 @@ export function resolveHostCredentials(hostName) {
     if (profile?.url) {
         return fromEnv(profile.url);
     }
-    return fromEnv();
+    return fromEnv(hostName);
 }
 function fromEnv(urlOverride) {
-    const dsmOrigin = urlOverride ?? process.env.DSM_URL;
+    let dsmOrigin = process.env.DSM_URL;
+    if (urlOverride) {
+        dsmOrigin = urlOverride.startsWith("http://") || urlOverride.startsWith("https://")
+            ? urlOverride
+            : `http://${urlOverride}:5000`;
+    }
     const password = process.env.DSM_PASSWORD;
     const username = process.env.DSM_USERNAME ?? "admin";
     if (!dsmOrigin || !password) {

package/dist/host/dsm-client.d.ts

@@ -4,6 +4,17 @@ export interface CreateNasHostOptions {
     credentials?: HostCredentials;
 }
 export declare function createNasHost(options?: CreateNasHostOptions): NasHost | null;
+declare function synoagentcli(args: string[], profileName?: string): {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+};
+/**
+ * DSM's User Home read reports the selected volume, not the final share path.
+ * Keep the projection strict: an unexpected response must not become a host
+ * bind to an arbitrary path.
+ */
+export declare function homesPathFromDsmUserHomeRead(result: Pick<ReturnType<typeof synoagentcli>, "status" | "stdout">): string | undefined;
 /**
  * DSM reports the CPU vendor, not the ISA. Every x86_64 platform Synology
  * ships is Intel or AMD; every aarch64 one is Realtek, Marvell, Annapurna or
@@ -11,3 +22,4 @@ export declare function createNasHost(options?: CreateNasHostOptions): NasHost |
  * `--arch` rather than guessing wrong and building an unusable SPK.
  */
 export declare function archFamilyForCpuVendor(vendor: string | undefined): "x86_64" | "aarch64" | undefined;
+export {};

package/dist/host/dsm-client.js

@@ -6,7 +6,7 @@ import { IDENTITY_CGI_PATH } from "./broker-paths.js";
 import { packageSourceOrigin } from "../deploy/catalog-publish.js";
 import { lookupSharePathWithSynoagentcli } from "./share-lookup.js";
 import { dsmFetch } from "./dsm-http.js";
-import { installPackageFromCatalog, installPackageFromLocalSpk, fetchInstalledPackageState } from "./catalog-install.js";
+import { installPackageFromCatalog, installPackageFromLocalSpk, fetchInstalledPackageState, packageStateFromRecord, } from "./catalog-install.js";
 import { resolveHostCredentials } from "./credentials.js";
 export function createNasHost(options = {}) {
     const credentials = options.credentials ?? resolveHostCredentials(options.host);
@@ -27,6 +27,34 @@ function synoagentcli(args, profileName) {
         stderr: result.stderr ?? "",
     };
 }
+/**
+ * DSM's User Home read reports the selected volume, not the final share path.
+ * Keep the projection strict: an unexpected response must not become a host
+ * bind to an arbitrary path.
+ */
+export function homesPathFromDsmUserHomeRead(result) {
+    if (result.status !== 0) {
+        return undefined;
+    }
+    let payload;
+    try {
+        payload = JSON.parse(result.stdout);
+    }
+    catch {
+        return undefined;
+    }
+    if (payload.success !== true || payload.data?.enable !== true) {
+        return undefined;
+    }
+    if (typeof payload.data.location !== "string") {
+        return undefined;
+    }
+    const volume = payload.data.location.trim().replace(/\/+$/, "");
+    if (!/^\/volume[1-9][0-9]*$/.test(volume)) {
+        return undefined;
+    }
+    return `${volume}/homes`;
+}
 function createDsmNasHost(credentials, profileName) {
     const dsmOrigin = credentials.dsmOrigin.replace(/\/$/, "");
     const brokerBaseUrl = `${dsmOrigin}${IDENTITY_CGI_PATH}`;
@@ -184,6 +212,15 @@ function createDsmNasHost(credentials, profileName) {
         async resolveSharePath(logicalName) {
             return lookupSharePathWithSynoagentcli(logicalName, profileName);
         },
+        async resolveHomesPath() {
+            try {
+                const result = synoagentcli(["dsm", "control-panel", "user-group", "advanced", "get", "--section", "home"], profileName);
+                return homesPathFromDsmUserHomeRead(result);
+            }
+            catch {
+                return undefined;
+            }
+        },
         async getInstalledProjectEnv(packageIdentity) {
             const cached = projectEnvCache.get(packageIdentity);
             if (cached) {
@@ -222,6 +259,24 @@ function createDsmNasHost(credentials, profileName) {
                 throw error;
             }
         },
+        async getInstalledPackageState(packageIdentity) {
+            await ensureLogin();
+            const viaDsm = await fetchInstalledPackageState(dsmOrigin, cookieHeader ?? "", packageIdentity);
+            if (viaDsm) {
+                return viaDsm;
+            }
+            const result = synoagentcli(["dsm", "package-center", "get", packageIdentity], profileName);
+            if (result.status !== 0) {
+                return undefined;
+            }
+            try {
+                const parsed = JSON.parse(result.stdout);
+                return packageStateFromRecord(parsed.data);
+            }
+            catch {
+                return undefined;
+            }
+        },
         async getInstalledPackageVersion(packageIdentity) {
             await ensureLogin();
             const viaDsm = await fetchInstalledPackageState(dsmOrigin, cookieHeader ?? "", packageIdentity);

package/dist/host/dsm-compound.d.ts

@@ -0,0 +1,37 @@
+export interface DsmCompoundResult {
+    api: string;
+    method: string;
+    success: boolean;
+    errorCode?: number;
+}
+export interface DsmCompoundResponse {
+    hasFail: boolean;
+    results: DsmCompoundResult[];
+}
+export type DsmCompoundErrorCode = "DSM_DEPENDENCY_CONFLICT" | "DSM_COMPOUND_FAILED" | "DSM_REQUEST_FAILED";
+export interface DsmCompoundErrorOptions {
+    api?: string;
+    method?: string;
+    errorCode?: number;
+    dsmErrorCode?: number;
+    detail?: unknown;
+}
+export declare class DsmCompoundError extends Error {
+    readonly code: DsmCompoundErrorCode;
+    constructor(code: DsmCompoundErrorCode, message: string, options?: DsmCompoundErrorOptions);
+    readonly api?: string;
+    readonly method?: string;
+    readonly errorCode?: number;
+    readonly dsmErrorCode?: number;
+    readonly detail?: unknown;
+}
+/**
+ * Parse the response envelope returned by SYNO.Entry.Request compound calls.
+ * A textual DSM error code is intentionally not converted to a number.
+ */
+export declare function parseDsmCompoundResponse(raw: unknown): DsmCompoundResponse;
+/**
+ * Fail closed on every DSM compound failure signal. The returned parsed value
+ * is only reachable when the top-level request and every compound step pass.
+ */
+export declare function assertDsmCompoundResponse(raw: unknown): DsmCompoundResponse;