dataiku-sdk 0.10.1 → 0.12.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 clssck
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/packages/types/src/index.d.ts

@@ -147,6 +147,10 @@ export declare const RecipeCreateOptionsSchema: import("@sinclair/typebox").TObj
     outputConnection: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     joinOn: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>]>>;
     joinType: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    fuzzyOn: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>]>>;
+    fuzzyDistance: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    fuzzyThreshold: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    fuzzyNormalize: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
     projectKey: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     outputFolder: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
 }>;
@@ -160,6 +164,7 @@ export declare const RecipeCreateResultSchema: import("@sinclair/typebox").TObje
     outputFolder: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     temporaryOutputDataset: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     temporaryOutputDatasetDeleted: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    syncOutputSchemaPropagated: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
 }>;
 export type RecipeCreateResult = Static<typeof RecipeCreateResultSchema>;
 export declare const JobSummarySchema: import("@sinclair/typebox").TObject<{
@@ -264,6 +269,12 @@ export declare const ScenarioStatusSchema: import("@sinclair/typebox").TObject<{
     }>>;
 }>;
 export type ScenarioStatus = Static<typeof ScenarioStatusSchema>;
+export declare const ScenarioStepRunSchema: import("@sinclair/typebox").TObject<{
+    name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    type: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    outcome: import("@sinclair/typebox").TString;
+}>;
+export type ScenarioStepRun = Static<typeof ScenarioStepRunSchema>;
 export declare const ScenarioWaitResultSchema: import("@sinclair/typebox").TObject<{
     scenarioId: import("@sinclair/typebox").TString;
     runId: import("@sinclair/typebox").TString;
@@ -272,6 +283,12 @@ export declare const ScenarioWaitResultSchema: import("@sinclair/typebox").TObje
     elapsedMs: import("@sinclair/typebox").TNumber;
     pollCount: import("@sinclair/typebox").TNumber;
     timedOut: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    triggerRunId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    steps: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        type: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        outcome: import("@sinclair/typebox").TString;
+    }>>>;
 }>;
 export type ScenarioWaitResult = Static<typeof ScenarioWaitResultSchema>;
 export declare const FlowZoneObjectTypeSchema: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"DATASET">, import("@sinclair/typebox").TLiteral<"MANAGED_FOLDER">, import("@sinclair/typebox").TLiteral<"SAVED_MODEL">, import("@sinclair/typebox").TLiteral<"RECIPE">, import("@sinclair/typebox").TLiteral<"MODEL_EVALUATION_STORE">, import("@sinclair/typebox").TLiteral<"STREAMING_ENDPOINT">, import("@sinclair/typebox").TLiteral<"LABELING_TASK">, import("@sinclair/typebox").TLiteral<"RETRIEVABLE_KNOWLEDGE">]>;
@@ -552,7 +569,7 @@ export declare const JupyterCellSchema: import("@sinclair/typebox").TObject<{
     source: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
     metadata: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TUnknown>>;
     outputs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnknown>>;
-    execution_count: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TNull]>>;
+    execution_count: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNull, import("@sinclair/typebox").TNumber]>>;
 }>;
 export type JupyterCell = Static<typeof JupyterCellSchema>;
 export declare const JupyterNotebookSummarySchema: import("@sinclair/typebox").TObject<{
@@ -575,7 +592,7 @@ export declare const JupyterNotebookContentSchema: import("@sinclair/typebox").T
         source: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
         metadata: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TUnknown>>;
         outputs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnknown>>;
-        execution_count: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TNull]>>;
+        execution_count: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNull, import("@sinclair/typebox").TNumber]>>;
     }>>;
 }>;
 export type JupyterNotebookContent = Static<typeof JupyterNotebookContentSchema>;

package/dist/packages/types/src/index.js

@@ -195,6 +195,10 @@ export const RecipeCreateOptionsSchema = Type.Object({
     outputConnection: Type.Optional(Type.String()),
     joinOn: Type.Optional(Type.Union([Type.String(), Type.Array(Type.String()),])),
     joinType: Type.Optional(Type.String()),
+    fuzzyOn: Type.Optional(Type.Union([Type.String(), Type.Array(Type.String()),])),
+    fuzzyDistance: Type.Optional(Type.String()),
+    fuzzyThreshold: Type.Optional(Type.Number()),
+    fuzzyNormalize: Type.Optional(Type.Boolean()),
     projectKey: Type.Optional(Type.String()),
     outputFolder: Type.Optional(Type.String()),
 });
@@ -207,6 +211,7 @@ export const RecipeCreateResultSchema = Type.Object({
     outputFolder: Type.Optional(Type.String()),
     temporaryOutputDataset: Type.Optional(Type.String()),
     temporaryOutputDatasetDeleted: Type.Optional(Type.Boolean()),
+    syncOutputSchemaPropagated: Type.Optional(Type.Array(Type.String())),
 });
 // ---------------------------------------------------------------------------
 // Jobs
@@ -313,6 +318,11 @@ export const ScenarioStatusSchema = Type.Object({
         }, { additionalProperties: true, })),
     }, { additionalProperties: true, })),
 }, { additionalProperties: true, });
+export const ScenarioStepRunSchema = Type.Object({
+    name: Type.Optional(Type.String()),
+    type: Type.Optional(Type.String()),
+    outcome: Type.String(),
+}, { additionalProperties: false, });
 export const ScenarioWaitResultSchema = Type.Object({
     scenarioId: Type.String(),
     runId: Type.String(),
@@ -321,6 +331,8 @@ export const ScenarioWaitResultSchema = Type.Object({
     elapsedMs: Type.Number(),
     pollCount: Type.Number(),
     timedOut: Type.Optional(Type.Boolean()),
+    triggerRunId: Type.Optional(Type.String()),
+    steps: Type.Optional(Type.Array(ScenarioStepRunSchema)),
 });
 // ---------------------------------------------------------------------------
 // Flow zones
@@ -548,7 +560,7 @@ export const JupyterCellSchema = Type.Object({
     source: Type.Array(Type.String()),
     metadata: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
     outputs: Type.Optional(Type.Array(Type.Unknown())),
-    execution_count: Type.Optional(Type.Union([Type.Number(), Type.Null(),])),
+    execution_count: Type.Optional(Type.Union([Type.Null(), Type.Number(),])),
 }, { additionalProperties: true, });
 export const JupyterNotebookSummarySchema = Type.Object({
     name: Type.String(),

package/dist/src/cli/coerce.d.ts

@@ -0,0 +1,36 @@
+import type { JobBuildTargetType, JobLogFilter } from "../resources/jobs.js";
+export declare function num(v: string | boolean | undefined): number | undefined;
+export declare function jobBuildTargetType(v: string | boolean | undefined): JobBuildTargetType;
+export declare function jobBuildTargetTypeFromFlags(flags: Record<string, string | boolean>): JobBuildTargetType;
+export declare function maxLogLinesFromFlags(flags: Record<string, string | boolean>): number | undefined;
+export declare function jobLogFilterFromFlag(v: string | boolean | undefined): JobLogFilter | undefined;
+export declare function sha256Hex(value: string): string;
+export declare function normalizeLineEndings(value: string): string;
+export declare function stableJson(value: unknown): string;
+export declare function stableHash(value: unknown): string;
+export declare function splitCsvFlag(v: string | boolean | undefined): string[];
+export declare function recipeInputDatasetsFromFlags(flags: Record<string, string | boolean>): string[] | undefined;
+export declare function rewritePairsFromFlags(flags: Record<string, string | boolean>, flagName: string): Record<string, string>;
+export declare function plainRecord(value: unknown): Record<string, unknown> | undefined;
+export declare function requiredStringFlag(flags: Record<string, string | boolean>, name: string, usage: string): string;
+export declare function optionalStringField(record: Record<string, unknown>, keys: string[]): string | undefined;
+export declare function requiredStringArray(value: unknown, source: string): string[];
+export declare function finiteNumberField(record: Record<string, unknown>, key: string, source: string): number;
+export declare function stripUtf8Bom(text: string): string;
+export declare function parseJsonValue(text: string, source: string): unknown;
+export declare function expectJsonObject(value: unknown, source: string): Record<string, unknown>;
+export declare function parseJsonObject(text: string, source: string): Record<string, unknown>;
+export declare function json(v: string | boolean | undefined, source?: string): Record<string, unknown> | undefined;
+export declare function readStdinText(): string;
+export declare function jsonInput(flags: Record<string, string | boolean>): Record<string, unknown> | undefined;
+export declare function unknownJsonInput(flags: Record<string, string | boolean>): unknown;
+export declare function schemaColumnsInput(flags: Record<string, string | boolean>, usage: string): Array<{
+    comment?: string;
+    name: string;
+    type: string;
+}>;
+export declare function textInput(flags: Record<string, string | boolean>): string | undefined;
+export declare function requiredJsonInput(flags: Record<string, string | boolean>, message: string): Record<string, unknown>;
+export declare function parseBooleanOption(value: string | boolean | undefined, flagName: string): boolean | undefined;
+export declare function stringField(record: Record<string, unknown>, fields: string[]): string | undefined;
+export declare function resultRecord(result: unknown): Record<string, unknown>;

package/dist/src/cli/coerce.js

@@ -0,0 +1,239 @@
+import { createHash, } from "node:crypto";
+import { readFileSync, } from "node:fs";
+import { UsageError, } from "./usage.js";
+export function num(v) {
+    if (typeof v !== "string")
+        return undefined;
+    const n = Number(v);
+    return Number.isFinite(n) ? n : undefined;
+}
+export function jobBuildTargetType(v) {
+    if (v === undefined)
+        return "DATASET";
+    if (typeof v !== "string") {
+        throw new UsageError("Invalid job target type. Use dataset or managed-folder.", "invalid_enum");
+    }
+    const normalized = v.trim().toUpperCase().replace(/-/g, "_");
+    if (normalized === "DATASET" || normalized === "MANAGED_FOLDER")
+        return normalized;
+    throw new UsageError("Invalid job target type. Use dataset or managed-folder.", "invalid_enum");
+}
+export function jobBuildTargetTypeFromFlags(flags) {
+    return jobBuildTargetType(flags["target-type"] ?? flags["type"]);
+}
+export function maxLogLinesFromFlags(flags) {
+    return num(flags["max-log-lines"] ?? flags["max-lines"]);
+}
+export function jobLogFilterFromFlag(v) {
+    if (v === undefined)
+        return undefined;
+    if (typeof v !== "string") {
+        throw new UsageError("Invalid --log-filter value. Use stdout, stderr, user, or errors.", "invalid_enum");
+    }
+    const normalized = v.trim().toLowerCase();
+    if (normalized === "stdout" || normalized === "stderr" || normalized === "user"
+        || normalized === "errors") {
+        return normalized;
+    }
+    throw new UsageError("Invalid --log-filter value. Use stdout, stderr, user, or errors.", "invalid_enum");
+}
+export function sha256Hex(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+export function normalizeLineEndings(value) {
+    return value.replace(/\r\n/g, "\n");
+}
+export function stableJson(value) {
+    if (value === undefined)
+        return "undefined";
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map((item) => stableJson(item)).join(",")}]`;
+    const entries = Object.entries(value).sort(([a,], [b,]) => a.localeCompare(b));
+    return `{${entries.map(([key, item,]) => `${JSON.stringify(key)}:${stableJson(item)}`).join(",")}}`;
+}
+export function stableHash(value) {
+    return sha256Hex(stableJson(value));
+}
+export function splitCsvFlag(v) {
+    if (typeof v !== "string")
+        return [];
+    return v.split(",").map((item) => item.trim()).filter((item) => item.length > 0);
+}
+export function recipeInputDatasetsFromFlags(flags) {
+    const inputs = splitCsvFlag(flags["input"]);
+    return inputs.length > 0 ? inputs : undefined;
+}
+export function rewritePairsFromFlags(flags, flagName) {
+    const rewrites = {};
+    for (const spec of splitCsvFlag(flags[flagName])) {
+        const idx = spec.indexOf("=");
+        if (idx <= 0 || idx === spec.length - 1) {
+            throw new UsageError(`--${flagName} values must use FROM=TO.`, "invalid_enum");
+        }
+        const from = spec.slice(0, idx).trim();
+        const to = spec.slice(idx + 1).trim();
+        if (!from || !to)
+            throw new UsageError(`--${flagName} values must use FROM=TO.`, "invalid_enum");
+        rewrites[from] = to;
+    }
+    return rewrites;
+}
+export function plainRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+export function requiredStringFlag(flags, name, usage) {
+    const value = flags[name];
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new UsageError(`--${name} is required. Usage: ${usage}`, "missing_required_flag");
+    }
+    return value.trim();
+}
+export function optionalStringField(record, keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "string" && value.trim().length > 0)
+            return value.trim();
+    }
+    return undefined;
+}
+export function requiredStringArray(value, source) {
+    if (!Array.isArray(value)) {
+        throw new UsageError(`${source} must be an array of strings.`, "validation_failed");
+    }
+    return value.map((item, index) => {
+        if (typeof item !== "string" || item.trim().length === 0) {
+            throw new UsageError(`${source}[${index}] must be a non-empty string.`, "validation_failed");
+        }
+        return item.trim();
+    });
+}
+export function finiteNumberField(record, key, source) {
+    const value = record[key];
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new UsageError(`${source}.${key} must be a finite number.`, "validation_failed");
+    }
+    return value;
+}
+export function stripUtf8Bom(text) {
+    return text.charCodeAt(0) === 0xfeff ? text.slice(1) : text;
+}
+export function parseJsonValue(text, source) {
+    try {
+        return JSON.parse(stripUtf8Bom(text));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new UsageError(`Invalid JSON in ${source}: ${message}`, "validation_failed");
+    }
+}
+export function expectJsonObject(value, source) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    throw new UsageError(`Expected JSON object in ${source}.`, "validation_failed");
+}
+export function parseJsonObject(text, source) {
+    return expectJsonObject(parseJsonValue(text, source), source);
+}
+export function json(v, source = "JSON flag") {
+    if (typeof v !== "string")
+        return undefined;
+    return parseJsonObject(v, source);
+}
+export function readStdinText() {
+    return readFileSync(0, "utf-8");
+}
+export function jsonInput(flags) {
+    if (flags["stdin"] === true)
+        return parseJsonObject(readStdinText(), "stdin");
+    if (typeof flags["data-file"] === "string") {
+        return parseJsonObject(readFileSync(flags["data-file"], "utf-8"), flags["data-file"]);
+    }
+    if (typeof flags["data"] === "string")
+        return parseJsonObject(flags["data"], "--data");
+    return undefined;
+}
+export function unknownJsonInput(flags) {
+    if (flags["stdin"] === true)
+        return parseJsonValue(readStdinText(), "stdin");
+    if (typeof flags["data-file"] === "string") {
+        return parseJsonValue(readFileSync(flags["data-file"], "utf-8"), flags["data-file"]);
+    }
+    if (typeof flags["data"] === "string")
+        return parseJsonValue(flags["data"], "--data");
+    return undefined;
+}
+export function schemaColumnsInput(flags, usage) {
+    const input = unknownJsonInput(flags);
+    if (input === undefined) {
+        throw new UsageError(`--data, --data-file, or --stdin is required. Usage: ${usage}`);
+    }
+    const columns = Array.isArray(input)
+        ? input
+        : input && typeof input === "object" && Array.isArray(input.columns)
+            ? input.columns
+            : undefined;
+    if (!columns) {
+        throw new UsageError("Schema input must be an array of columns or an object with a columns array.");
+    }
+    return columns.map((column, index) => {
+        if (!column || typeof column !== "object" || Array.isArray(column)) {
+            throw new UsageError(`Schema column at index ${index} must be an object.`);
+        }
+        const record = column;
+        if (typeof record.name !== "string" || record.name.length === 0) {
+            throw new UsageError(`Schema column at index ${index} is missing string field "name".`);
+        }
+        if (typeof record.type !== "string" || record.type.length === 0) {
+            throw new UsageError(`Schema column "${record.name}" is missing string field "type".`);
+        }
+        return {
+            ...record,
+            name: record.name,
+            type: record.type,
+            ...(typeof record.comment === "string" ? { comment: record.comment, } : {}),
+        };
+    });
+}
+export function textInput(flags) {
+    if (typeof flags["content"] === "string")
+        return flags["content"];
+    if (typeof flags["file"] === "string")
+        return readFileSync(flags["file"], "utf-8");
+    return undefined;
+}
+export function requiredJsonInput(flags, message) {
+    const data = jsonInput(flags);
+    if (data === undefined)
+        throw new UsageError(message);
+    return data;
+}
+export function parseBooleanOption(value, flagName) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === "boolean")
+        return value;
+    const normalized = value.trim().toLowerCase();
+    if (["1", "true", "yes", "y", "on",].includes(normalized))
+        return true;
+    if (["0", "false", "no", "n", "off",].includes(normalized))
+        return false;
+    throw new UsageError(`${flagName} must be true or false.`, "invalid_enum");
+}
+export function stringField(record, fields) {
+    for (const field of fields) {
+        const value = record[field];
+        if (typeof value === "string" && value.length > 0)
+            return value;
+    }
+    return undefined;
+}
+export function resultRecord(result) {
+    return result !== null && typeof result === "object" && !Array.isArray(result)
+        ? result
+        : {};
+}

package/dist/src/cli/commands/analysis.d.ts

@@ -0,0 +1,2 @@
+import type { CommandMeta } from "../types.js";
+export declare const analysisCommands: Record<string, CommandMeta>;

package/dist/src/cli/commands/analysis.js

@@ -0,0 +1,66 @@
+import { requiredStringFlag, } from "../coerce.js";
+import { readIfExists, skipResult, } from "../output.js";
+import { requireArgs, } from "../usage.js";
+export const analysisCommands = {
+    list: {
+        handler: (c, _a, f) => c.analyses.list(f["project-key"]),
+        usage: "dss analysis list [--project-key KEY]",
+        description: "List Visual ML analyses in a project.",
+        examples: ["dss analysis list --project-key PROJECT",],
+    },
+    get: {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss analysis get <analysisId> [--project-key KEY]");
+            return c.analyses.get(a[0], f["project-key"]);
+        },
+        usage: "dss analysis get <analysisId> [--project-key KEY]",
+        description: "Get a Visual ML analysis.",
+        examples: ["dss analysis get ANALYSIS_ID --project-key PROJECT",],
+    },
+    create: {
+        handler: async (c, _a, f) => {
+            const usage = "dss analysis create --input-dataset DS [--dry-run] [--project-key KEY]";
+            const inputDataset = requiredStringFlag(f, "input-dataset", usage);
+            const projectKey = f["project-key"];
+            const options = { inputDataset, projectKey, };
+            if (f["dry-run"] === true) {
+                return {
+                    dryRun: true,
+                    action: "create",
+                    resource: "analysis",
+                    payload: options,
+                };
+            }
+            const created = await c.analyses.create(options);
+            return { created: created.id, resource: "analysis", ...created, };
+        },
+        usage: "dss analysis create --input-dataset DS [--dry-run] [--project-key KEY]",
+        description: "Create a Visual ML analysis for an input dataset.",
+        examples: [
+            "dss analysis create --input-dataset customers --project-key PROJECT",
+            "dss analysis create --input-dataset customers --dry-run --project-key PROJECT",
+        ],
+    },
+    delete: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss analysis delete <analysisId> [--if-exists] [--dry-run] [--project-key KEY]");
+            const projectKey = f["project-key"];
+            if (f["dry-run"] === true || f["if-exists"] === true) {
+                const current = await readIfExists(() => c.analyses.get(a[0], projectKey));
+                if (!current)
+                    return skipResult("analysis", a[0], "missing");
+                if (f["dry-run"] === true) {
+                    return { dryRun: true, action: "delete", resource: "analysis", id: a[0], current, };
+                }
+            }
+            await c.analyses.delete(a[0], projectKey);
+            return { deleted: a[0], resource: "analysis", };
+        },
+        usage: "dss analysis delete <analysisId> [--if-exists] [--dry-run] [--project-key KEY]",
+        description: "Delete a Visual ML analysis.",
+        examples: [
+            "dss analysis delete ANALYSIS_ID --if-exists --project-key PROJECT",
+            "dss analysis delete ANALYSIS_ID --dry-run --project-key PROJECT",
+        ],
+    },
+};

package/dist/src/cli/commands/api-deployer.d.ts

@@ -0,0 +1,2 @@
+import type { CommandMeta } from "../types.js";
+export declare const apiDeployerCommands: Record<string, CommandMeta>;

package/dist/src/cli/commands/api-deployer.js

@@ -0,0 +1,170 @@
+import { requiredJsonInput, } from "../coerce.js";
+import { requireArgs, } from "../usage.js";
+export const apiDeployerCommands = {
+    "list-infras": {
+        handler: (c) => c.apiDeployer.listInfras(),
+        usage: "dss api-deployer list-infras",
+        description: "List API Deployer infrastructures.",
+        examples: ["dss api-deployer list-infras",],
+    },
+    "create-infra": {
+        handler: (c, _a, f) => {
+            const body = requiredJsonInput(f, "--data, --data-file, or --stdin is required (infra settings).");
+            return c.apiDeployer.createInfra(body);
+        },
+        usage: "dss api-deployer create-infra (--data JSON|--data-file PATH|--stdin)",
+        description: "Create an API Deployer infrastructure.",
+        examples: ["dss api-deployer create-infra --data-file infra.json",],
+    },
+    "get-infra": {
+        handler: (c, a) => {
+            requireArgs(a, 1, "dss api-deployer get-infra <infraId>");
+            return c.apiDeployer.getInfra(a[0]);
+        },
+        usage: "dss api-deployer get-infra <infraId>",
+        description: "Get an API Deployer infrastructure status.",
+        examples: ["dss api-deployer get-infra prod-infra",],
+    },
+    "delete-infra": {
+        handler: async (c, a) => {
+            requireArgs(a, 1, "dss api-deployer delete-infra <infraId>");
+            await c.apiDeployer.deleteInfra(a[0]);
+            return { deleted: true, };
+        },
+        usage: "dss api-deployer delete-infra <infraId>",
+        description: "Delete an API Deployer infrastructure.",
+        examples: ["dss api-deployer delete-infra prod-infra",],
+    },
+    "list-stages": {
+        handler: (c) => c.apiDeployer.listStages(),
+        usage: "dss api-deployer list-stages",
+        description: "List API Deployer lifecycle stages.",
+        examples: ["dss api-deployer list-stages",],
+    },
+    "list-services": {
+        handler: (c) => c.apiDeployer.listServices(),
+        usage: "dss api-deployer list-services",
+        description: "List published API Deployer services.",
+        examples: ["dss api-deployer list-services",],
+    },
+    "create-service": {
+        handler: (c, _a, f) => {
+            const body = requiredJsonInput(f, "--data, --data-file, or --stdin is required (service definition).");
+            return c.apiDeployer.createService(body);
+        },
+        usage: "dss api-deployer create-service (--data JSON|--data-file PATH|--stdin)",
+        description: "Create a published API Deployer service.",
+        examples: ['dss api-deployer create-service --data \'{"id":"my-service"}\'',],
+    },
+    "get-service": {
+        handler: (c, a) => {
+            requireArgs(a, 1, "dss api-deployer get-service <serviceId>");
+            return c.apiDeployer.getService(a[0]);
+        },
+        usage: "dss api-deployer get-service <serviceId>",
+        description: "Get a published service's status (versions + deployments).",
+        examples: ["dss api-deployer get-service my-service",],
+    },
+    "delete-service": {
+        handler: async (c, a) => {
+            requireArgs(a, 1, "dss api-deployer delete-service <serviceId>");
+            await c.apiDeployer.deleteService(a[0]);
+            return { deleted: true, };
+        },
+        usage: "dss api-deployer delete-service <serviceId>",
+        description: "Delete a published API Deployer service.",
+        examples: ["dss api-deployer delete-service my-service",],
+    },
+    "publish-version": {
+        handler: async (c, a) => {
+            requireArgs(a, 2, "dss api-deployer publish-version <serviceId> <archive.zip>");
+            await c.apiDeployer.publishServiceVersion(a[0], a[1]);
+            return { published: true, };
+        },
+        usage: "dss api-deployer publish-version <serviceId> <archive.zip>",
+        description: "Publish (upload) a service version package to the API Deployer.",
+        examples: ["dss api-deployer publish-version my-service ./pkg.zip",],
+    },
+    "delete-version": {
+        handler: async (c, a) => {
+            requireArgs(a, 2, "dss api-deployer delete-version <serviceId> <version>");
+            await c.apiDeployer.deleteServiceVersion(a[0], a[1]);
+            return { deleted: true, };
+        },
+        usage: "dss api-deployer delete-version <serviceId> <version>",
+        description: "Delete a published service version.",
+        examples: ["dss api-deployer delete-version my-service v1",],
+    },
+    "list-deployments": {
+        handler: (c) => c.apiDeployer.listDeployments(),
+        usage: "dss api-deployer list-deployments",
+        description: "List API Deployer deployments.",
+        examples: ["dss api-deployer list-deployments",],
+    },
+    "create-deployment": {
+        handler: (c, _a, f) => {
+            const body = requiredJsonInput(f, "--data, --data-file, or --stdin is required (deployment settings).");
+            return c.apiDeployer.createDeployment(body);
+        },
+        usage: "dss api-deployer create-deployment (--data JSON|--data-file PATH|--stdin)",
+        description: "Create an API Deployer deployment (maps a service version to an infra).",
+        examples: ["dss api-deployer create-deployment --data-file deployment.json",],
+    },
+    "get-deployment": {
+        handler: (c, a) => {
+            requireArgs(a, 1, "dss api-deployer get-deployment <deploymentId>");
+            return c.apiDeployer.getDeployment(a[0]);
+        },
+        usage: "dss api-deployer get-deployment <deploymentId>",
+        description: "Get an API Deployer deployment.",
+        examples: ["dss api-deployer get-deployment my-deployment",],
+    },
+    "deployment-status": {
+        handler: (c, a) => {
+            requireArgs(a, 1, "dss api-deployer deployment-status <deploymentId>");
+            return c.apiDeployer.getDeploymentStatus(a[0]);
+        },
+        usage: "dss api-deployer deployment-status <deploymentId>",
+        description: "Get an API Deployer deployment's full health/status.",
+        examples: ["dss api-deployer deployment-status my-deployment",],
+    },
+    "deployment-settings": {
+        handler: (c, a) => {
+            requireArgs(a, 1, "dss api-deployer deployment-settings <deploymentId>");
+            return c.apiDeployer.getDeploymentSettings(a[0]);
+        },
+        usage: "dss api-deployer deployment-settings <deploymentId>",
+        description: "Get an API Deployer deployment's settings.",
+        examples: ["dss api-deployer deployment-settings my-deployment",],
+    },
+    "save-deployment-settings": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss api-deployer save-deployment-settings <deploymentId> (--data JSON|--data-file PATH|--stdin)");
+            const body = requiredJsonInput(f, "--data, --data-file, or --stdin is required (deployment settings).");
+            await c.apiDeployer.saveDeploymentSettings(a[0], body);
+            return { saved: true, };
+        },
+        usage: "dss api-deployer save-deployment-settings <deploymentId> (--data JSON|--data-file PATH|--stdin)",
+        description: "Save an API Deployer deployment's settings.",
+        examples: ["dss api-deployer save-deployment-settings my-deployment --data-file settings.json",],
+    },
+    deploy: {
+        handler: (c, a) => {
+            requireArgs(a, 1, "dss api-deployer deploy <deploymentId>");
+            return c.apiDeployer.startDeploymentUpdate(a[0]);
+        },
+        usage: "dss api-deployer deploy <deploymentId>",
+        description: "Apply a deployment's settings to its infrastructure (start update).",
+        examples: ["dss api-deployer deploy my-deployment",],
+    },
+    "delete-deployment": {
+        handler: async (c, a) => {
+            requireArgs(a, 1, "dss api-deployer delete-deployment <deploymentId>");
+            await c.apiDeployer.deleteDeployment(a[0]);
+            return { deleted: true, };
+        },
+        usage: "dss api-deployer delete-deployment <deploymentId>",
+        description: "Delete an API Deployer deployment.",
+        examples: ["dss api-deployer delete-deployment my-deployment",],
+    },
+};

package/dist/src/cli/commands/api-service.d.ts

@@ -0,0 +1,2 @@
+import type { CommandMeta } from "../types.js";
+export declare const apiServiceCommands: Record<string, CommandMeta>;