dataiku-sdk 0.5.0 → 0.6.0

package/dist/src/errors.js

@@ -71,6 +71,18 @@ export function classifyDataikuError(status, body) {
             retryHint: "Requested object was not found. Verify projectKey and object identifiers before retrying.",
         };
     }
+    const isSqlEngineValidation = status >= 400
+        && (lowerBody.includes("column_not_found")
+            || lowerBody.includes("table_not_found")
+            || lowerBody.includes("no_such_table")
+            || lowerBody.includes("column does not exist"));
+    if (isSqlEngineValidation) {
+        return {
+            category: "validation",
+            retryable: false,
+            retryHint: "Athena/SQL engine rejected the query: check column names, table names, and schema with dss dataset schema or dss connection tables. Do not retry unchanged SQL.",
+        };
+    }
     const isServerValidationLike = status >= 500
         && (lowerBody.includes("invalid")
             || lowerBody.includes("validation")

package/dist/src/index.d.ts

@@ -3,18 +3,18 @@ export { type CredentialValidationOptions, type CredentialValidationResult, vali
 export { deleteCredentials, type DssCredentials, getConfigDir, getCredentialsPath, loadCredentials, maskApiKey, saveCredentials, } from "./config.js";
 export { DataikuError, type DataikuErrorCategory, type DataikuErrorTaxonomy, type DataikuRetryMetadata, } from "./errors.js";
 export { CodeEnvsResource, } from "./resources/code-envs.js";
-export { ConnectionsResource, } from "./resources/connections.js";
+export { type ConnectionSchemaListOptions, ConnectionsResource, type ConnectionTableListOptions, } from "./resources/connections.js";
 export { DashboardsResource, } from "./resources/dashboards.js";
 export { DataQualityResource, } from "./resources/data-quality.js";
-export { DatasetsResource, } from "./resources/datasets.js";
+export { type DatasetBuildValidationResult, type DatasetSchemaColumnInput, DatasetsResource, } from "./resources/datasets.js";
 export { type FlowZoneItemInput, FlowZonesResource, } from "./resources/flow-zones.js";
 export { FoldersResource, } from "./resources/folders.js";
 export { FuturesResource, } from "./resources/futures.js";
 export { InsightsResource, } from "./resources/insights.js";
-export { computeNextPollDelayMs, type JobBuildTargetType, JobsResource, } from "./resources/jobs.js";
+export { computeNextPollDelayMs, type JobBuildAndWaitOptions, type JobBuildOptions, type JobBuildTarget, type JobBuildTargetType, type JobLogFilter, type JobLogSummary, JobsResource, } from "./resources/jobs.js";
 export { NotebooksResource, } from "./resources/notebooks.js";
 export { type FlowMapResult, ProjectsResource, } from "./resources/projects.js";
-export { RecipesResource, } from "./resources/recipes.js";
+export { type RecipeGraphReference, type RecipeGraphValidationResult, type RecipeRunOptions, type RecipeRunOutput, type RecipeRunResult, RecipesResource, } from "./resources/recipes.js";
 export { ScenariosResource, } from "./resources/scenarios.js";
 export { SqlResource, } from "./resources/sql.js";
 export { VariablesResource, } from "./resources/variables.js";

package/dist/src/resources/connections.d.ts

@@ -1,5 +1,13 @@
 import type { ConnectionSummary } from "../schemas.js";
 import { BaseResource } from "./base.js";
+export interface ConnectionSchemaListOptions {
+    connection: string;
+    projectKey?: string;
+}
+export interface ConnectionTableListOptions extends ConnectionSchemaListOptions {
+    catalog?: string;
+    schema?: string;
+}
 export declare class ConnectionsResource extends BaseResource {
     /**
      * Returns sorted list of all connection names visible to the current user.
@@ -19,4 +27,6 @@ export declare class ConnectionsResource extends BaseResource {
         mode?: "fast" | "rich";
         projectKey?: string;
     }): Promise<ConnectionSummary[]>;
+    schemas(opts: ConnectionSchemaListOptions): Promise<string[]>;
+    tables(opts: ConnectionTableListOptions): Promise<Record<string, unknown>>;
 }

package/dist/src/resources/connections.js

@@ -79,4 +79,20 @@ export class ConnectionsResource extends BaseResource {
         }
         return inferRichConnectionsFromDatasets(this.client, projectEnc);
     }
+    async schemas(opts) {
+        const pk = this.resolveProjectKey(opts.projectKey);
+        const params = new URLSearchParams();
+        params.set("connectionName", opts.connection);
+        return this.client.get(`/public/api/projects/${encodeURIComponent(pk)}/datasets/tables-import/actions/list-schemas?${params.toString()}`);
+    }
+    async tables(opts) {
+        const pk = this.resolveProjectKey(opts.projectKey);
+        const params = new URLSearchParams();
+        params.set("connectionName", opts.connection);
+        if (opts.catalog !== undefined)
+            params.set("catalogName", opts.catalog);
+        if (opts.schema !== undefined)
+            params.set("schemaName", opts.schema);
+        return this.client.get(`/public/api/projects/${encodeURIComponent(pk)}/datasets/tables-import/actions/list-tables?${params.toString()}`);
+    }
 }

package/dist/src/resources/datasets.d.ts

@@ -1,5 +1,19 @@
 import { BaseResource } from "./base.js";
 import type { DatasetCreateOptions, DatasetDetails, DatasetSchema, DatasetSummary } from "../schemas.js";
+export interface DatasetBuildValidationResult {
+    valid: boolean;
+    datasetName: string;
+    projectKey: string;
+    type: string | null;
+    path: string | null;
+    formatType: string | null;
+    warnings: string[];
+}
+export interface DatasetSchemaColumnInput {
+    name: string;
+    type: string;
+    comment?: string;
+}
 /**
  * Compare streamed TSV header columns against a known dataset schema.
  * Returns an array of warning strings (empty if all columns match).
@@ -14,6 +28,8 @@ export declare class DatasetsResource extends BaseResource {
     get(datasetName: string, projectKey?: string): Promise<DatasetDetails>;
     /** Get dataset schema (column names and types). */
     schema(datasetName: string, projectKey?: string): Promise<DatasetSchema>;
+    /** Replace dataset schema columns directly through the schema endpoint. */
+    updateSchema(datasetName: string, columns: DatasetSchemaColumnInput[], projectKey?: string): Promise<void>;
     /**
      * Preview dataset data as CSV text.
      * Streams TSV from the API, converts to CSV, and returns up to `maxRows`
@@ -51,6 +67,8 @@ export declare class DatasetsResource extends BaseResource {
      * from existing datasets on the same connection.
      */
     create(opts: DatasetCreateOptions): Promise<Record<string, unknown>>;
+    /** Validate common build blockers before running a dataset build. */
+    validateBuildSettings(datasetName: string, projectKey?: string): Promise<DatasetBuildValidationResult>;
     /** Update a dataset by deep-merging a patch into the current definition. */
     update(datasetName: string, data: Record<string, unknown>, projectKey?: string): Promise<void>;
     /** Delete a dataset. */

package/dist/src/resources/datasets.js

@@ -327,6 +327,11 @@ export class DatasetsResource extends BaseResource {
         const raw = await this.client.get(`/public/api/projects/${this.enc(projectKey)}/datasets/${dsEnc}/schema`);
         return this.client.safeParse(DatasetSchemaSchema, raw, "datasets.schema");
     }
+    /** Replace dataset schema columns directly through the schema endpoint. */
+    async updateSchema(datasetName, columns, projectKey) {
+        const dsEnc = encodeURIComponent(datasetName);
+        await this.client.put(`/public/api/projects/${this.enc(projectKey)}/datasets/${dsEnc}/schema`, { columns, });
+    }
     /**
      * Preview dataset data as CSV text.
      * Streams TSV from the API, converts to CSV, and returns up to `maxRows`
@@ -444,6 +449,42 @@ export class DatasetsResource extends BaseResource {
             return this.client.post(`/public/api/projects/${enc}/datasets/`, body);
         }
     }
+    /** Validate common build blockers before running a dataset build. */
+    async validateBuildSettings(datasetName, projectKey) {
+        const pk = this.resolveProjectKey(projectKey);
+        const details = await this.get(datasetName, pk);
+        const params = details.params ?? {};
+        const type = details.type ?? null;
+        const path = typeof params.path === "string" && params.path.trim().length > 0
+            ? params.path
+            : null;
+        const table = typeof params.table === "string" && params.table.trim().length > 0
+            ? params.table
+            : null;
+        const normalizedType = (type ?? "").toLowerCase();
+        const fileBacked = !table
+            && (normalizedType.includes("filesystem")
+                || normalizedType.includes("uploaded")
+                || normalizedType.includes("s3")
+                || path !== null);
+        const formatType = details.formatType ?? null;
+        const warnings = [];
+        if (fileBacked && !path) {
+            warnings.push("File-backed dataset has no writable storage path configured.");
+        }
+        if (fileBacked && !formatType) {
+            warnings.push("File-backed dataset has no formatType configured.");
+        }
+        return {
+            valid: warnings.length === 0,
+            datasetName,
+            projectKey: pk,
+            type,
+            path,
+            formatType,
+            warnings,
+        };
+    }
     /** Update a dataset by deep-merging a patch into the current definition. */
     async update(datasetName, data, projectKey) {
         const dsEnc = encodeURIComponent(datasetName);

package/dist/src/resources/jobs.d.ts

@@ -1,6 +1,34 @@
 import type { BuildMode, JobSummary, JobWaitResult } from "../schemas.js";
 import { BaseResource } from "./base.js";
 export type JobBuildTargetType = "DATASET" | "MANAGED_FOLDER";
+export type JobLogFilter = "stdout" | "stderr" | "user" | "errors";
+export interface JobLogSummary {
+    state: string;
+    lineCount: number;
+    lines: string[];
+}
+export interface JobBuildTarget {
+    id: string;
+    type?: JobBuildTargetType;
+    projectKey?: string;
+    partition?: string;
+}
+export interface JobBuildOptions {
+    buildMode?: BuildMode;
+    autoUpdateSchema?: boolean;
+    projectKey?: string;
+    targetType?: JobBuildTargetType;
+    partition?: string;
+}
+export interface JobBuildAndWaitOptions extends JobBuildOptions {
+    activity?: string;
+    includeLogs?: boolean;
+    maxLogLines?: number;
+    pollIntervalMs?: number;
+    timeoutMs?: number;
+    logFilter?: JobLogFilter;
+    summary?: boolean;
+}
 interface ComputeNextPollDelayMsOptions {
     pollCount: number;
     baseIntervalMs: number;
@@ -28,32 +56,33 @@ export declare class JobsResource extends BaseResource {
         projectKey?: string;
     }): Promise<string>;
     /**
-     * Start a build job for a dataset or managed folder.
+     * Start a build job for one or more dataset or managed-folder outputs.
      * Returns the new job's ID.
      */
-    build(targetId: string, opts?: {
-        buildMode?: BuildMode;
-        autoUpdateSchema?: boolean;
-        projectKey?: string;
-        targetType?: JobBuildTargetType;
-    }): Promise<{
+    buildOutputs(targets: JobBuildTarget[], opts?: JobBuildOptions): Promise<{
         jobId: string;
     }>;
+    /**
+     * Start a build job for a single dataset or managed folder.
+     * Returns the new job's ID.
+     */
+    build(targetId: string, opts?: JobBuildOptions): Promise<{
+        jobId: string;
+    }>;
+    /**
+     * Build one or more dataset or managed-folder outputs and wait for a terminal state.
+     * Combines {@link buildOutputs} then {@link wait}.
+     */
+    buildAndWaitOutputs(targets: JobBuildTarget[], opts?: JobBuildAndWaitOptions): Promise<JobWaitResult & {
+        logSummary?: JobLogSummary;
+    }>;
     /**
      * Build a dataset or managed folder and wait for the job to reach a terminal state.
      * Combines {@link build} then {@link wait}.
      */
-    buildAndWait(targetId: string, opts?: {
-        buildMode?: BuildMode;
-        autoUpdateSchema?: boolean;
-        activity?: string;
-        includeLogs?: boolean;
-        maxLogLines?: number;
-        pollIntervalMs?: number;
-        timeoutMs?: number;
-        projectKey?: string;
-        targetType?: JobBuildTargetType;
-    }): Promise<JobWaitResult>;
+    buildAndWait(targetId: string, opts?: JobBuildAndWaitOptions): Promise<JobWaitResult & {
+        logSummary?: JobLogSummary;
+    }>;
     /**
      * Poll a job until it reaches a terminal state or times out.
      *
@@ -65,11 +94,15 @@ export declare class JobsResource extends BaseResource {
     wait(jobId: string, opts?: {
         activity?: string;
         includeLogs?: boolean;
+        logFilter?: JobLogFilter;
         maxLogLines?: number;
         pollIntervalMs?: number;
+        summary?: boolean;
         timeoutMs?: number;
         projectKey?: string;
-    }): Promise<JobWaitResult>;
+    }): Promise<JobWaitResult & {
+        logSummary?: JobLogSummary;
+    }>;
     /** Request a job abort. */
     abort(jobId: string, projectKey?: string): Promise<void>;
 }

package/dist/src/resources/jobs.js

@@ -35,6 +35,84 @@ export function computeNextPollDelayMs({ pollCount, baseIntervalMs, adaptiveEnab
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+const DEFAULT_TARGET_PARTITION = "NP";
+function jobBuildOutput(target, defaultProjectKey, defaultPartition, defaultTargetType) {
+    const targetType = target.type ?? defaultTargetType ?? "DATASET";
+    const projectKey = target.projectKey ?? defaultProjectKey;
+    const partition = target.partition ?? defaultPartition;
+    const output = { projectKey, id: target.id, type: targetType, };
+    if (targetType === "DATASET") {
+        if (partition !== undefined)
+            output.partition = partition;
+    }
+    else {
+        output.targetManagedFolderProjectKey = projectKey;
+        output.targetManagedFolder = target.id;
+        output.targetPartition = partition ?? DEFAULT_TARGET_PARTITION;
+    }
+    return output;
+}
+function jobBuildDefinition(targets, defaultProjectKey, opts) {
+    if (targets.length === 0) {
+        throw new Error("At least one build target is required.");
+    }
+    const payload = {
+        outputs: targets.map((target) => jobBuildOutput(target, defaultProjectKey, opts?.partition, opts?.targetType)),
+        type: opts?.buildMode ?? "NON_RECURSIVE_FORCED_BUILD",
+    };
+    if (opts?.autoUpdateSchema
+        && targets.every((target) => (target.type ?? opts?.targetType ?? "DATASET") === "DATASET")) {
+        payload.autoUpdateSchemaBeforeEachRecipeRun = true;
+    }
+    return payload;
+}
+function jobLogLines(log) {
+    return log.split(/\r?\n/).map((line) => line.trimEnd());
+}
+function lineMatchesLogFilter(line, filter) {
+    const normalized = line.toLowerCase();
+    switch (filter) {
+        case "stdout":
+            return normalized.includes("stdout") || line.startsWith(">>> ");
+        case "stderr":
+            return normalized.includes("stderr");
+        case "errors":
+            return /\b(error|failed|failure|exception|traceback)\b/i.test(line);
+        case "user":
+            return !/^\d{4}[-/]\d{2}[-/]\d{2}/.test(line)
+                && !normalized.includes("backend-log")
+                && !normalized.includes("debug");
+    }
+}
+function filterJobLog(log, filter) {
+    if (!filter)
+        return log;
+    return jobLogLines(log).filter((line) => lineMatchesLogFilter(line, filter)).join("\n");
+}
+function limitJobLog(log, maxLines) {
+    if (!log)
+        return "";
+    const limit = maxLines ?? DEFAULT_MAX_LOG_LINES;
+    if (limit === 0 || limit === -1)
+        return log;
+    const lines = log.split(/\r?\n/);
+    const hasTrailingLineBreak = lines.length > 0 && lines[lines.length - 1] === "";
+    if (hasTrailingLineBreak)
+        lines.pop();
+    if (lines.length <= limit)
+        return log;
+    const tail = lines.slice(-Math.max(1, limit)).join("\n");
+    return hasTrailingLineBreak ? `${tail}\n` : tail;
+}
+function summarizeJobLog(state, log, maxLines) {
+    const lines = jobLogLines(log).map((line) => line.trim()).filter((line) => line.length > 0);
+    const summaryLines = lines.slice(-Math.max(1, maxLines));
+    return {
+        state,
+        lineCount: lines.length,
+        lines: summaryLines,
+    };
+}
 export class JobsResource extends BaseResource {
     /** List jobs in a project. */
     async list(projectKey) {
@@ -56,56 +134,58 @@ export class JobsResource extends BaseResource {
         const jobEnc = encodeURIComponent(jobId);
         const query = opts?.activity ? `?activity=${encodeURIComponent(opts.activity)}` : "";
         const log = await this.client.getText(`/public/api/projects/${this.enc(opts?.projectKey)}/jobs/${jobEnc}/log/${query}`);
-        if (!log)
-            return "";
-        const limit = opts?.maxLogLines ?? DEFAULT_MAX_LOG_LINES;
-        if (limit === 0 || limit === -1) {
-            return log;
-        }
-        const lines = log.split("\n");
-        if (lines.length > limit) {
-            return lines.slice(-limit).join("\n");
-        }
-        return log;
+        return limitJobLog(log, opts?.maxLogLines);
     }
     /**
-     * Start a build job for a dataset or managed folder.
+     * Start a build job for one or more dataset or managed-folder outputs.
      * Returns the new job's ID.
      */
-    async build(targetId, opts) {
+    async buildOutputs(targets, opts) {
         const pk = this.resolveProjectKey(opts?.projectKey);
         const enc = encodeURIComponent(pk);
-        const targetType = opts?.targetType ?? "DATASET";
-        const jobDef = {
-            outputs: [{ projectKey: pk, id: targetId, type: targetType, },],
-            type: opts?.buildMode ?? "NON_RECURSIVE_FORCED_BUILD",
-        };
-        if (opts?.autoUpdateSchema && targetType === "DATASET") {
-            jobDef.autoUpdateSchemaBeforeEachRecipeRun = true;
-        }
+        const jobDef = jobBuildDefinition(targets, pk, opts);
         const job = await this.client.post(`/public/api/projects/${enc}/jobs/`, jobDef);
         return { jobId: job.id, };
     }
     /**
-     * Build a dataset or managed folder and wait for the job to reach a terminal state.
-     * Combines {@link build} then {@link wait}.
+     * Start a build job for a single dataset or managed folder.
+     * Returns the new job's ID.
      */
-    async buildAndWait(targetId, opts) {
-        const { jobId, } = await this.build(targetId, {
-            buildMode: opts?.buildMode,
-            autoUpdateSchema: opts?.autoUpdateSchema,
-            projectKey: opts?.projectKey,
-            targetType: opts?.targetType,
-        });
+    async build(targetId, opts) {
+        return this.buildOutputs([{
+                id: targetId,
+                type: opts?.targetType,
+                partition: opts?.partition,
+            },], opts);
+    }
+    /**
+     * Build one or more dataset or managed-folder outputs and wait for a terminal state.
+     * Combines {@link buildOutputs} then {@link wait}.
+     */
+    async buildAndWaitOutputs(targets, opts) {
+        const { jobId, } = await this.buildOutputs(targets, opts);
         return this.wait(jobId, {
             activity: opts?.activity,
             includeLogs: opts?.includeLogs,
+            logFilter: opts?.logFilter,
             maxLogLines: opts?.maxLogLines,
             pollIntervalMs: opts?.pollIntervalMs,
+            summary: opts?.summary,
             timeoutMs: opts?.timeoutMs,
             projectKey: opts?.projectKey,
         });
     }
+    /**
+     * Build a dataset or managed folder and wait for the job to reach a terminal state.
+     * Combines {@link build} then {@link wait}.
+     */
+    async buildAndWait(targetId, opts) {
+        return this.buildAndWaitOutputs([{
+                id: targetId,
+                type: opts?.targetType,
+                partition: opts?.partition,
+            },], opts);
+    }
     /**
      * Poll a job until it reaches a terminal state or times out.
      *
@@ -133,12 +213,19 @@ export class JobsResource extends BaseResource {
             if (isTerminalState(state)) {
                 const success = isSuccessfulTerminalState(state);
                 let log;
-                if (opts?.includeLogs) {
-                    log = await this.log(jobId, {
+                let logSummary;
+                if (opts?.includeLogs || opts?.summary) {
+                    const rawLog = await this.log(jobId, {
                         activity: opts.activity,
-                        maxLogLines: opts.maxLogLines,
+                        maxLogLines: opts.summary ? 0 : opts.maxLogLines,
                         projectKey: opts.projectKey,
                     });
+                    const filteredLog = filterJobLog(rawLog, opts.logFilter);
+                    if (opts.includeLogs)
+                        log = limitJobLog(filteredLog, opts.maxLogLines);
+                    if (opts.summary) {
+                        logSummary = summarizeJobLog(state, filteredLog, opts.maxLogLines ?? 20);
+                    }
                 }
                 return {
                     success,
@@ -154,6 +241,7 @@ export class JobsResource extends BaseResource {
                         total: gs.total ?? null,
                     },
                     ...(log !== undefined ? { log, } : {}),
+                    ...(logSummary !== undefined ? { logSummary, } : {}),
                 };
             }
             // Timeout — return failure result, don't throw

package/dist/src/resources/notebooks.d.ts

@@ -10,8 +10,9 @@ export declare class NotebooksResource extends BaseResource {
     /**
      * Delete a Jupyter notebook.
      *
-     * DSS public APIs can delete notebooks but do not expose notebook creation, so
-     * this can only target notebooks created outside this SDK (for example in the UI).
+     * The SDK intentionally does not expose notebook creation as a first-class
+     * resource method yet; integration tests create disposable notebooks through
+     * the documented project-level create endpoint.
      */
     deleteJupyter(name: string, projectKey?: string): Promise<void>;
     /**
@@ -26,8 +27,9 @@ export declare class NotebooksResource extends BaseResource {
     /**
      * Unload (stop) a running Jupyter notebook session.
      *
-     * DSS public APIs do not expose notebook or session creation, so this only
-     * works for sessions started outside this SDK.
+     * DSS public APIs expose session listing and unloading, but this SDK has no
+     * path to start a disposable kernel session; live unload coverage therefore
+     * requires an externally-started disposable session fixture.
      */
     unloadJupyter(name: string, sessionId: string, projectKey?: string): Promise<void>;
     /** List all SQL notebooks in a project. */

package/dist/src/resources/notebooks.js

@@ -21,8 +21,9 @@ export class NotebooksResource extends BaseResource {
     /**
      * Delete a Jupyter notebook.
      *
-     * DSS public APIs can delete notebooks but do not expose notebook creation, so
-     * this can only target notebooks created outside this SDK (for example in the UI).
+     * The SDK intentionally does not expose notebook creation as a first-class
+     * resource method yet; integration tests create disposable notebooks through
+     * the documented project-level create endpoint.
      */
     async deleteJupyter(name, projectKey) {
         const nameEnc = encodeURIComponent(name);
@@ -52,8 +53,9 @@ export class NotebooksResource extends BaseResource {
     /**
      * Unload (stop) a running Jupyter notebook session.
      *
-     * DSS public APIs do not expose notebook or session creation, so this only
-     * works for sessions started outside this SDK.
+     * DSS public APIs expose session listing and unloading, but this SDK has no
+     * path to start a disposable kernel session; live unload coverage therefore
+     * requires an externally-started disposable session fixture.
      */
     async unloadJupyter(name, sessionId, projectKey) {
         const nameEnc = encodeURIComponent(name);

package/dist/src/resources/recipes.d.ts

@@ -1,5 +1,47 @@
-import type { RecipeCreateOptions, RecipeCreateResult, RecipeSummary } from "../schemas.js";
+import type { BuildMode, JobWaitResult, RecipeCreateOptions, RecipeCreateResult, RecipeSummary } from "../schemas.js";
 import { BaseResource } from "./base.js";
+import type { JobBuildTarget, JobBuildTargetType, JobLogFilter, JobLogSummary } from "./jobs.js";
+export interface RecipeRunOutput extends JobBuildTarget {
+    ref: string;
+    role: string;
+}
+export interface RecipeGraphReference {
+    ref: string;
+    role: string;
+    type?: JobBuildTargetType;
+    exists: boolean;
+    id?: string;
+}
+export interface RecipeGraphValidationResult {
+    valid: boolean;
+    recipeName: string;
+    projectKey: string;
+    inputs: RecipeGraphReference[];
+    outputs: RecipeGraphReference[];
+    missingInputs: RecipeGraphReference[];
+    missingOutputs: RecipeGraphReference[];
+    ambiguousOutputs: string[];
+    warnings: string[];
+}
+export interface RecipeRunOptions {
+    buildMode?: BuildMode;
+    includeLogs?: boolean;
+    maxLogLines?: number;
+    partition?: string;
+    pollIntervalMs?: number;
+    projectKey?: string;
+    wait?: boolean;
+    timeoutMs?: number;
+    logFilter?: JobLogFilter;
+    summary?: boolean;
+}
+export type RecipeRunResult = {
+    logSummary?: JobLogSummary;
+    recipeName: string;
+    outputs: RecipeRunOutput[];
+} & ({
+    jobId: string;
+} | JobWaitResult);
 export declare class RecipesResource extends BaseResource {
     /** List all recipes in a project. */
     list(projectKey?: string): Promise<RecipeSummary[]>;
@@ -15,6 +57,17 @@ export declare class RecipesResource extends BaseResource {
         recipe: Record<string, unknown>;
         payload?: string;
     }>;
+    /** Validate declared recipe graph references before running/building. */
+    validateGraph(recipeName: string, opts?: {
+        projectKey?: string;
+    }): Promise<RecipeGraphValidationResult>;
+    /** Resolve recipe outputs to job-build targets. */
+    resolveRunOutputs(recipeName: string, opts?: {
+        partition?: string;
+        projectKey?: string;
+    }): Promise<RecipeRunOutput[]>;
+    /** Run a recipe by building its resolved outputs. */
+    run(recipeName: string, opts?: RecipeRunOptions): Promise<RecipeRunResult>;
     /** Create a recipe, with optional output dataset provisioning and join configuration. */
     create(opts: RecipeCreateOptions): Promise<RecipeCreateResult>;
     /**