dataiku-sdk 3.3.0 → 3.5.0

package/dist/src/resources/ml-tasks.js

@@ -117,20 +117,35 @@ export class MlTasksResource extends BaseResource {
         const adaptiveEnabled = explicitIntervalMs === undefined;
         const startedAt = Date.now();
         let pollCount = 0;
-        // One status observation always happens; the poll precedes the deadline
-        // check, so `timeoutMs: 0` still reports the freshly-started state once.
+        let lastStatus;
         while (true) {
+            const elapsedBeforeMs = Date.now() - startedAt;
+            // The first observation always happens, even when the budget is
+            // already spent. A later poll is never started after the deadline:
+            // the loop reports the structured timeout from the last observed
+            // status instead of issuing a request the budget cannot cover.
+            if (lastStatus !== undefined && elapsedBeforeMs >= deadlineMs) {
+                return {
+                    sessionId: session.sessionId,
+                    trainedModelIds: modelIdsFromStatus(lastStatus),
+                    timedOut: true,
+                    success: false,
+                    state: "RUNNING",
+                    elapsedMs: elapsedBeforeMs,
+                    pollCount,
+                };
+            }
             pollCount += 1;
-            // One status observation always happens, even when the budget is
-            // already spent (the poll precedes the deadline check); only the
-            // requests issued while budget remains are bounded by the remaining
-            // time, so a stalled status endpoint can never defeat the deadline.
-            const remainingMs = deadlineMs - (Date.now() - startedAt);
+            // Requests issued while budget remains are bounded by the remaining
+            // time; a spent budget still issues exactly one transport attempt
+            // (no retries, client requestTimeoutMs cap) so the first observation
+            // reaches the server instead of failing before any attempt.
+            const remainingMs = deadlineMs - elapsedBeforeMs;
             let status;
             try {
                 status = await this.client.get(`${this.taskPath(opts.analysisId, opts.mlTaskId, opts.projectKey)}/status`, remainingMs > 0
                     ? { timeoutMs: remainingMs, }
-                    : undefined);
+                    : { noRetry: true, });
             }
             catch (error) {
                 // The poll budget ran out: report the structured timeout instead
@@ -147,19 +162,13 @@ export class MlTasksResource extends BaseResource {
                     pollCount,
                 };
             }
+            lastStatus = status;
             const elapsedMs = Date.now() - startedAt;
             if (status.training !== false) {
-                if (elapsedMs >= deadlineMs) {
-                    return {
-                        sessionId: session.sessionId,
-                        trainedModelIds: modelIdsFromStatus(status),
-                        timedOut: true,
-                        success: false,
-                        state: "RUNNING",
-                        elapsedMs,
-                        pollCount,
-                    };
-                }
+                // Deadline reached: the guard at the top of the loop reports the
+                // timeout from this status without issuing another request.
+                if (elapsedMs >= deadlineMs)
+                    continue;
                 const nextDelayMs = computeNextPollDelayMs({
                     pollCount,
                     baseIntervalMs,

package/dist/src/resources/notebooks.js

@@ -1,8 +1,7 @@
 import { ClientValidationError, DataikuError, } from "../errors.js";
 import { JupyterNotebookContentSchema, JupyterNotebookSummaryArraySchema, NotebookSessionArraySchema, SqlNotebookContentSchema, SqlNotebookHistorySchema, SqlNotebookSummaryArraySchema, } from "../schemas.js";
-import { stableHash, } from "../utils/stable-hash.js";
+import { SHA256_HEX_PATTERN, stableHash, } from "../utils/stable-hash.js";
 import { BaseResource, } from "./base.js";
-const EXPECT_HASH_PATTERN = /^[0-9a-fA-F]{64}$/;
 export class NotebooksResource extends BaseResource {
     // ── Jupyter Notebooks ──────────────────────────────────────────────
     /**
@@ -260,7 +259,7 @@ export class NotebooksResource extends BaseResource {
     }
     /** Validate the armed `--expect-hash` value into a comparable hex digest. */
     validatedExpectHash(expectHash, pk, resourceLabel, id) {
-        if (!EXPECT_HASH_PATTERN.test(expectHash)) {
+        if (!SHA256_HEX_PATTERN.test(expectHash)) {
             throw new ClientValidationError(`Expected ${resourceLabel} hash must be a 64-character SHA-256 hex digest.`, "validation_failed", "Use the hash value returned by a previous save or read.", { projectKey: pk, id, });
         }
         return expectHash.toLowerCase();

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

@@ -1,5 +1,4 @@
 import { BaseResource } from "./base.js";
-import { validateGitReferencePath } from "./project-git.js";
 /** Summary entry of `/plugins/` as documented (id/version/isDev/meta). */
 export interface PluginSummary {
     id: string;
@@ -262,4 +261,3 @@ export declare function validatedPluginGitUrl(repository: string, field?: string
  * CLI to decide which actions need a plugin id positional.
  */
 export declare function isPluginIdCandidate(value: unknown): boolean;
-export { validateGitReferencePath, };

package/dist/src/resources/plugins.js

@@ -1,6 +1,5 @@
 import { ClientValidationError, DataikuError, } from "../errors.js";
 import { BaseResource, requireNonEmpty, } from "./base.js";
-import { validateGitReferencePath, } from "./project-git.js";
 /* ------------------------------------------------------------------ */
 /*  Path helpers                                                       */
 /* ------------------------------------------------------------------ */
@@ -454,5 +453,3 @@ export function validatedPluginGitUrl(repository, field = "Git repository URL")
 export function isPluginIdCandidate(value) {
     return typeof value === "string" && PLUGIN_ID_PATTERN.test(value);
 }
-// Re-exported for CLI consumers so a single import site covers path rules.
-export { validateGitReferencePath, };

package/dist/src/resources/project-git.d.ts

@@ -68,23 +68,17 @@ export interface ProjectGitFutureStateOptions {
      * loops that must not hang on a stalled endpoint.
      */
     timeoutMs?: number;
+    /**
+     * Issue exactly one transport attempt (no retries). Independent of
+     * `timeoutMs`: when both are supplied the total budget still applies. Used
+     * by the wait loop for the one observation whose wait budget is spent.
+     */
+    noRetry?: boolean;
 }
 export interface ProjectGitFutureWaitOptions {
     pollIntervalMs?: number;
     timeoutMs?: number;
 }
-/**
- * Validate and canonicalize a Git library reference path. This is the single
- * validator used by both SDK dispatch and CLI mutation planning.
- *
- * Strip only the permitted outer '/' separators, then require nonempty
- * ordinary segments: no empty segments and no '.' or '..' segments. A hostile
- * path therefore cannot change which API resource a dispatcher's URL
- * normalization would otherwise select.
- */
-export declare function validateGitReferencePath(path: string): string;
-/** Validate a Git library reference path and URL-encode it per segment. */
-export declare function encodeGitReferencePath(path: string): string;
 export declare class ProjectGitResource extends BaseResource {
     /** Working-copy status: current branch, remotes, tracking counts, changes. */
     status(projectKey: string): Promise<ProjectGitStatus>;

package/dist/src/resources/project-git.js

@@ -1,6 +1,7 @@
-import { ClientValidationError, } from "../errors.js";
+import { ClientValidationError, DataikuError, nonJsonResponseBody, } from "../errors.js";
 import { ProjectGitActionResultSchema, ProjectGitDiffResultSchema, ProjectGitFutureResponseSchema, ProjectGitFutureStateSchema, ProjectGitLibrariesSchema, ProjectGitLogResultSchema, ProjectGitRemoteSchema, ProjectGitStatusSchema, ProjectGitTagsSchema, } from "../schemas.js";
-import { computeNextPollDelayMs, isRequestDeadlineError, } from "../utils/polling.js";
+import { encodeGitReferencePath, validateGitReferencePath, } from "../utils/git-reference.js";
+import { computeNextPollDelayMs, DEFAULT_POLL_INTERVAL_MS, DEFAULT_TIMEOUT_MS, isRequestDeadlineError, } from "../utils/polling.js";
 import { sanitizeErrorSecrets, } from "../utils/secret-sanitize.js";
 import { BaseResource, } from "./base.js";
 /**
@@ -12,50 +13,11 @@ const GIT_API_BASE = "/dip/publicapi";
 const DEFAULT_REMOTE = "origin";
 const DEFAULT_LOG_COUNT = 1_000;
 const DEFAULT_TAG_REFERENCE = "HEAD";
-const DEFAULT_POLL_INTERVAL_MS = 2_000;
-const DEFAULT_TIMEOUT_MS = 120_000;
 function sleep(ms) {
     const { promise, resolve, } = Promise.withResolvers();
     setTimeout(resolve, ms);
     return promise;
 }
-function gitReferencePathError(path, message) {
-    return new ClientValidationError(message, "validation_failed", "Use a Git library reference path relative to the project library root: '/' -separated segment names, with no '.' or '..' segments.", { path, });
-}
-/**
- * Validate and canonicalize a Git library reference path. This is the single
- * validator used by both SDK dispatch and CLI mutation planning.
- *
- * Strip only the permitted outer '/' separators, then require nonempty
- * ordinary segments: no empty segments and no '.' or '..' segments. A hostile
- * path therefore cannot change which API resource a dispatcher's URL
- * normalization would otherwise select.
- */
-export function validateGitReferencePath(path) {
-    if (typeof path !== "string" || path.trim() === "") {
-        throw gitReferencePathError(path, "A Git library reference path is required.");
-    }
-    const normalized = path.replace(/^\/+/, "").replace(/\/+$/, "");
-    if (normalized === "") {
-        throw gitReferencePathError(path, "A Git library reference path is required.");
-    }
-    for (const segment of normalized.split("/")) {
-        if (segment === "") {
-            throw gitReferencePathError(path, "A Git library reference path must not contain empty segments (consecutive or repeated '/').");
-        }
-        if (segment === "." || segment === "..") {
-            throw gitReferencePathError(path, "A Git library reference path must not contain '.' or '..' segments.");
-        }
-    }
-    return normalized;
-}
-/** Validate a Git library reference path and URL-encode it per segment. */
-export function encodeGitReferencePath(path) {
-    return validateGitReferencePath(path)
-        .split("/")
-        .map((segment) => encodeURIComponent(segment))
-        .join("/");
-}
 /**
  * Reject `https://user:token@host/repo` before it reaches DSS: an embedded
  * secret would be stored in the project's Git configuration and echoed back by
@@ -364,7 +326,7 @@ export class ProjectGitResource extends BaseResource {
      * what polling loops want; the default consumes it like the Python client.
      */
     async getFutureState(jobId, options = {}) {
-        const raw = await this.request("GET", `/futures/${encodeURIComponent(jobId)}${this.query({ peek: options.peek === true, })}`, undefined, [], { timeoutMs: options.timeoutMs, });
+        const raw = await this.request("GET", `/futures/${encodeURIComponent(jobId)}${this.query({ peek: options.peek === true, })}`, undefined, [], { timeoutMs: options.timeoutMs, noRetry: options.noRetry, });
         return this.client.safeParse(ProjectGitFutureStateSchema, raw ?? {}, "projectGit.getFutureState");
     }
     /** Abort a running future. */
@@ -389,14 +351,23 @@ export class ProjectGitResource extends BaseResource {
         // interval; an explicit pollIntervalMs is an exact contract.
         const adaptiveEnabled = options.pollIntervalMs === undefined;
         let pollCount = 0;
+        let lastState;
         const startedAt = Date.now();
         while (true) {
+            const elapsedBeforeMs = Date.now() - startedAt;
+            // The first observation always happens, even when the budget is
+            // already spent. A later poll is never started after the deadline:
+            // the loop reports the documented timeout from the last observed
+            // state instead of issuing a request the budget cannot cover.
+            if (lastState !== undefined && elapsedBeforeMs >= timeoutMs) {
+                throw new ClientValidationError(`Timed out after ${String(elapsedBeforeMs)}ms waiting for Dataiku future ${jobId}`, "long_running_failure");
+            }
             // Unlike peek state, the ordinary state includes the completed result.
-            // One state observation always happens, even when the budget is
-            // already spent (the poll precedes the deadline check); only the
-            // requests issued while budget remains are bounded by the remaining
-            // time, so a stalled endpoint can never defeat the caller's deadline.
-            const remainingMs = timeoutMs - (Date.now() - startedAt);
+            // Requests issued while budget remains are bounded by the remaining
+            // time; a spent budget still issues exactly one transport attempt
+            // (no retries, client requestTimeoutMs cap) so the first observation
+            // reaches the server instead of failing before any attempt.
+            const remainingMs = timeoutMs - elapsedBeforeMs;
             pollCount += 1;
             let state;
             try {
@@ -405,7 +376,7 @@ export class ProjectGitResource extends BaseResource {
                         peek: false,
                         timeoutMs: remainingMs,
                     }
-                    : { peek: false, });
+                    : { peek: false, noRetry: true, });
             }
             catch (error) {
                 // The poll budget ran out mid-request: report the documented
@@ -413,27 +384,29 @@ export class ProjectGitResource extends BaseResource {
                 // error escape.
                 if (!isRequestDeadlineError(error, startedAt + timeoutMs))
                     throw error;
-                throw new Error(`Timed out after ${String(Date.now() - startedAt)}ms waiting for Dataiku future ${jobId}`, { cause: error, });
+                throw new ClientValidationError(`Timed out after ${String(Date.now() - startedAt)}ms waiting for Dataiku future ${jobId}`, "long_running_failure", undefined, undefined, { cause: error, });
             }
+            lastState = state;
             const failure = describeFutureFailure(state.error);
             if (failure !== undefined) {
-                throw new Error(`Dataiku future ${jobId} failed: ${failure}`);
+                throw new ClientValidationError(`Dataiku future ${jobId} failed: ${failure}`, "long_running_failure");
             }
             if (state.aborted === true) {
-                throw new Error(`Dataiku future ${jobId} was aborted`);
+                throw new ClientValidationError(`Dataiku future ${jobId} was aborted`, "long_running_failure");
             }
             if (state.hasResult === true)
                 return state.result;
             if (state.unknown === true) {
-                throw new Error(`Dataiku future ${jobId} is unknown to the server`);
+                throw new ClientValidationError(`Dataiku future ${jobId} is unknown to the server`, "long_running_failure");
             }
             if (state.alive === false) {
-                throw new Error(`Dataiku future ${jobId} ended without producing a result`);
+                throw new ClientValidationError(`Dataiku future ${jobId} ended without producing a result`, "long_running_failure");
             }
             const elapsedMs = Date.now() - startedAt;
-            if (elapsedMs >= timeoutMs) {
-                throw new Error(`Timed out after ${String(elapsedMs)}ms waiting for Dataiku future ${jobId}`);
-            }
+            // Deadline reached: the guard at the top of the loop reports the
+            // timeout from this observation without issuing another request.
+            if (elapsedMs >= timeoutMs)
+                continue;
             const nextDelayMs = computeNextPollDelayMs({
                 pollCount,
                 baseIntervalMs: pollIntervalMs,
@@ -466,7 +439,7 @@ export class ProjectGitResource extends BaseResource {
     }
     async request(method, path, body, secrets = [], opts = {}) {
         try {
-            const res = await this.client.requestGit(method, `${GIT_API_BASE}${path}`, body, opts.timeoutMs === undefined ? undefined : Date.now() + opts.timeoutMs);
+            const res = await this.client.requestGit(method, `${GIT_API_BASE}${path}`, body, opts.timeoutMs === undefined ? undefined : Date.now() + opts.timeoutMs, opts.noRetry === true);
             const text = await res.text();
             if (text.trim() === "")
                 return undefined;
@@ -474,7 +447,7 @@ export class ProjectGitResource extends BaseResource {
                 return JSON.parse(text);
             }
             catch {
-                throw new Error(`Dataiku Git API returned a non-JSON response for ${method} ${path}`);
+                throw new DataikuError(res.status, "Invalid JSON response", nonJsonResponseBody(text));
             }
         }
         catch (error) {

package/dist/src/resources/project-library.d.ts

@@ -75,8 +75,6 @@ export interface ProjectLibraryDiffResult {
  * checked; it can never turn the subsequent POST into a conditional write.
  */
 export declare const PROJECT_LIBRARY_CONCURRENCY_CONTROL = "client-side-non-atomic-stale-read-check";
-/** Lowercase or uppercase SHA-256 hex digest. */
-export declare const EXPECT_SHA256_PATTERN: RegExp;
 /**
  * Validate and canonicalize a project library path.
  *

package/dist/src/resources/project-library.js

@@ -1,5 +1,5 @@
-import { createHash, } from "node:crypto";
 import { ClientValidationError, DataikuError, } from "../errors.js";
+import { SHA256_HEX_PATTERN, sha256Hex, } from "../utils/stable-hash.js";
 import { BaseResource, } from "./base.js";
 /**
  * The only concurrency control the public project-library API permits. DSS
@@ -8,11 +8,6 @@ import { BaseResource, } from "./base.js";
  * checked; it can never turn the subsequent POST into a conditional write.
  */
 export const PROJECT_LIBRARY_CONCURRENCY_CONTROL = "client-side-non-atomic-stale-read-check";
-/** Lowercase or uppercase SHA-256 hex digest. */
-export const EXPECT_SHA256_PATTERN = /^[0-9a-fA-F]{64}$/;
-function sha256Hex(value) {
-    return createHash("sha256").update(value).digest("hex");
-}
 const CONTROL_CHARACTER_RE = /[\u0000-\u001f\u007f]/;
 const BACKSLASH_RE = /\\/;
 const TRAILING_AMBIGUOUS_RE = /[\s.]$/;
@@ -376,7 +371,7 @@ export class ProjectLibraryResource extends BaseResource {
         }
         const expectSha256 = options?.expectSha256;
         if (expectSha256 !== undefined
-            && (typeof expectSha256 !== "string" || !EXPECT_SHA256_PATTERN.test(expectSha256))) {
+            && (typeof expectSha256 !== "string" || !SHA256_HEX_PATTERN.test(expectSha256))) {
             throw new ClientValidationError("expectSha256 must be a 64-character SHA-256 hex digest.", "validation_failed", "Use the sha256 value returned by a project library read or diff.", { path: valid, });
         }
         let beforeSha256;

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

@@ -150,8 +150,10 @@ export declare class ProjectsResource extends BaseResource {
      * Build a normalized, optionally truncated flow map for a project.
      *
      * Fetches the flow graph and supplementary metadata (datasets, recipes,
-     * managed folders) in parallel. Folder name resolution uses a timeout
-     * to avoid blocking when the folders endpoint is slow.
+     * managed folders) in parallel. Each metadata fetch runs under a total
+     * `timeoutMs` budget: when the budget expires the in-flight request is
+     * aborted and the map is returned without that metadata, reported as a
+     * warning.
      */
     map(opts?: FlowMapOptions & {
         projectKey?: string;

package/dist/src/resources/projects.js

@@ -1,4 +1,5 @@
-import { ClientValidationError, DataikuError, } from "../errors.js";
+import { ClientValidationError, DataikuError, unexpectedResponseError, } from "../errors.js";
+import { isRequestDeadlineError, } from "../utils/polling.js";
 import { writeResponseToFile, } from "../utils/response-file.js";
 import { ProjectDetailsSchema, ProjectMetadataSchema, ProjectSummaryArraySchema, ProjectTagsSchema, } from "../schemas.js";
 import { analyzeFlowMap, flowTopologyFingerprint, renderFlowMap, } from "../utils/flow-analysis.js";
@@ -6,34 +7,31 @@ import { normalizeFlowGraph, } from "../utils/flow-map.js";
 import { assertImportableProjectArchive, } from "../utils/project-archive.js";
 import { projectIncarnationHash, } from "../utils/project-incarnation.js";
 import { BaseResource, } from "./base.js";
-function fetchWithTimeout(label, timeoutMs, fetcher) {
-    return new Promise((resolve) => {
-        let settled = false;
-        const timer = setTimeout(() => {
-            if (settled)
-                return;
-            settled = true;
-            resolve({
+/**
+ * Runs an optional metadata fetch under a total budget. The fetcher receives
+ * the client GET options and must pass `timeoutMs` through to its request, so
+ * the client owns the deadline: the in-flight request is aborted when the
+ * budget expires and no further retry is started afterwards. Expiry of the
+ * total budget resolves to a warning so the map still returns; an earlier
+ * per-request failure is reported as "unavailable" (classified with the same
+ * deadline check the wait loops use).
+ */
+async function fetchWithTimeout(label, timeoutMs, fetcher) {
+    const deadlineAt = Date.now() + timeoutMs;
+    try {
+        return { value: await fetcher({ timeoutMs, }), };
+    }
+    catch (error) {
+        if (isRequestDeadlineError(error, deadlineAt)) {
+            return {
                 warning: `${label} metadata timed out after ${timeoutMs}ms; continuing without it.`,
-            });
-        }, timeoutMs);
-        fetcher().then((value) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            resolve({ value, });
-        }, (error) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            const detail = error instanceof Error ? error.message : String(error);
-            resolve({
-                warning: `${label} metadata unavailable: ${detail}`,
-            });
-        });
-    });
+            };
+        }
+        const detail = error instanceof Error ? error.message : String(error);
+        return {
+            warning: `${label} metadata unavailable: ${detail}`,
+        };
+    }
 }
 function computeRootsAndLeaves(nodes, edges) {
     const inDegree = new Map();
@@ -142,8 +140,9 @@ export class ProjectsResource extends BaseResource {
     /** Export a project archive to a local file. */
     async exportArchive(projectKey, filePath, options) {
         const res = await this.client.postStream(`/public/api/projects/${encodeURIComponent(projectKey)}/export`, options ?? {});
-        if (!res.body)
-            throw new Error("projects.exportArchive response did not include a body");
+        if (!res.body) {
+            throw unexpectedResponseError("projects.exportArchive response did not include a body");
+        }
         await writeResponseToFile(filePath, res);
     }
     /** Upload a project archive and return its temporary import handle. */
@@ -343,8 +342,10 @@ export class ProjectsResource extends BaseResource {
      * Build a normalized, optionally truncated flow map for a project.
      *
      * Fetches the flow graph and supplementary metadata (datasets, recipes,
-     * managed folders) in parallel. Folder name resolution uses a timeout
-     * to avoid blocking when the folders endpoint is slow.
+     * managed folders) in parallel. Each metadata fetch runs under a total
+     * `timeoutMs` budget: when the budget expires the in-flight request is
+     * aborted and the map is returned without that metadata, reported as a
+     * warning.
      */
     async map(opts) {
         const enc = this.enc(opts?.projectKey);
@@ -352,10 +353,10 @@ export class ProjectsResource extends BaseResource {
         const timeoutMs = DEFAULT_METADATA_TIMEOUT_MS;
         const [rawGraph, foldersMeta, datasetsMeta, recipesMeta, zonesMeta,] = await Promise.all([
             this.client.get(`/public/api/projects/${enc}/flow/graph/`),
-            fetchWithTimeout("Managed folders", timeoutMs, () => this.client.get(`/public/api/projects/${enc}/managedfolders/`)),
-            fetchWithTimeout("Datasets", timeoutMs, () => this.client.get(`/public/api/projects/${enc}/datasets/`)),
-            fetchWithTimeout("Recipes", timeoutMs, () => this.client.get(`/public/api/projects/${enc}/recipes/`)),
-            fetchWithTimeout("Flow zones", timeoutMs, () => this.client.flowZones.list(pk)),
+            fetchWithTimeout("Managed folders", timeoutMs, (getOptions) => this.client.get(`/public/api/projects/${enc}/managedfolders/`, getOptions)),
+            fetchWithTimeout("Datasets", timeoutMs, (getOptions) => this.client.get(`/public/api/projects/${enc}/datasets/`, getOptions)),
+            fetchWithTimeout("Recipes", timeoutMs, (getOptions) => this.client.get(`/public/api/projects/${enc}/recipes/`, getOptions)),
+            fetchWithTimeout("Flow zones", timeoutMs, (getOptions) => this.client.flowZones.list(pk, getOptions)),
         ]);
         // Build folder name lookup
         const folderNamesById = {};

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

@@ -1,6 +1,11 @@
 import type { BuildMode, JobWaitResult, ProjectMetadata, RecipeCreateOptions, RecipeCreateResult, RecipeSummary } from "../schemas.js";
 import { BaseResource } from "./base.js";
 import type { JobBuildTarget, JobBuildTargetType, JobLogFilter, JobLogSummary } from "./jobs.js";
+type JoinType = "LEFT" | "INNER" | "RIGHT" | "FULL";
+type JoinKeyPair = {
+    left: string;
+    right: string;
+};
 export interface RecipeRunOutput extends JobBuildTarget {
     ref: string;
     role: string;
@@ -65,6 +70,28 @@ export interface RecipeCloneResult {
     payloadTextRewrites: Record<string, string>;
     copiedOutputDatasets: string[];
 }
+/**
+ * Pure request construction for POST /recipes/ (no DSS calls). Shared with
+ * `recipe create --plan` so the plan equals the request the command sends.
+ */
+export declare function buildRecipeCreateRequest(opts: RecipeCreateOptions, pk: string): {
+    creationSettings: Record<string, unknown>;
+    fuzzyDistance: string | undefined;
+    fuzzyKeys: JoinKeyPair[] | undefined;
+    fuzzyThreshold: number;
+    inputDatasets: string[] | undefined;
+    inputs: Record<string, unknown>;
+    joinKeys: JoinKeyPair[] | undefined;
+    name: string;
+    normalizedJoinType: JoinType | undefined;
+    outputFolder: string | undefined;
+    outputs: Record<string, unknown>;
+    payload: string | undefined;
+    rawConnection: string | undefined;
+    recipePrototype: Record<string, unknown>;
+    temporaryOutputDataset: string | undefined;
+    type: string;
+};
 export declare class RecipesResource extends BaseResource {
     /** List all recipes in a project. */
     list(projectKey?: string): Promise<RecipeSummary[]>;
@@ -144,3 +171,4 @@ export declare class RecipesResource extends BaseResource {
         projectKey?: string;
     }): Promise<string>;
 }
+export {};