dataiku-sdk 0.1.0

package/dist/src/resources/recipes.js

@@ -0,0 +1,281 @@
+import { writeFile, } from "node:fs/promises";
+import { resolve, } from "node:path";
+import { DataikuError, } from "../errors.js";
+import { RecipeSummaryArraySchema, } from "../schemas.js";
+import { sanitizeFileName, } from "../utils/sanitize.js";
+import { BaseResource, } from "./base.js";
+// ---------------------------------------------------------------------------
+// Helpers: type narrowing
+// ---------------------------------------------------------------------------
+function asString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function asStringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const out = value.filter((v) => typeof v === "string" && v.length > 0);
+    return out.length > 0 ? out : undefined;
+}
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    return value;
+}
+// ---------------------------------------------------------------------------
+// Helpers: retry predicate
+// ---------------------------------------------------------------------------
+function shouldRetryRecipeCreateWithOutputProvisioning(error) {
+    if (!(error instanceof DataikuError))
+        return false;
+    if (error.category !== "validation"
+        && error.category !== "not_found"
+        && error.category !== "unknown") {
+        return false;
+    }
+    const detail = `${error.statusText}\n${error.body}`.toLowerCase();
+    const mentionsMissingDataset = detail.includes("dataset")
+        && (detail.includes("not found")
+            || detail.includes("does not exist")
+            || detail.includes("unknown"));
+    return mentionsMissingDataset;
+}
+// ---------------------------------------------------------------------------
+// Resource
+// ---------------------------------------------------------------------------
+export class RecipesResource extends BaseResource {
+    /** List all recipes in a project. */
+    async list(projectKey) {
+        const enc = this.enc(projectKey);
+        const raw = await this.client.get(`/public/api/projects/${enc}/recipes/`);
+        return this.client.safeParse(RecipeSummaryArraySchema, raw, "recipes.list");
+    }
+    /**
+     * Get a recipe definition (and optionally its payload).
+     * Returns the raw API response shape: `{ recipe, payload }`.
+     */
+    get(recipeName, opts) {
+        const enc = this.enc(opts?.projectKey);
+        const rnEnc = encodeURIComponent(recipeName);
+        const params = new URLSearchParams();
+        if (opts?.includePayload)
+            params.set("includePayload", "true");
+        // oxlint-disable-next-line eqeqeq -- intentional null check
+        if (opts?.payloadMaxLines != null)
+            params.set("payloadMaxLines", String(opts.payloadMaxLines));
+        const qs = params.toString();
+        const url = `/public/api/projects/${enc}/recipes/${rnEnc}${qs ? `?${qs}` : ""}`;
+        return this.client.get(url);
+    }
+    /** Create a recipe, with optional output dataset provisioning and join configuration. */
+    async create(opts) {
+        const pk = this.resolveProjectKey(opts.projectKey);
+        const enc = encodeURIComponent(pk);
+        const { type, payload, outputConnection: rawConnection, joinType: rawJoinType, } = opts;
+        // Build inputs/outputs from simple form (inputDatasets + outputDataset) or
+        // advanced form (inputs + outputs); both may coexist — simple form wins when
+        // the advanced form is absent.
+        const inputDatasets = asStringArray(opts.inputDatasets);
+        const outputDataset = asString(opts.outputDataset);
+        let inputs = asRecord(opts.inputs);
+        let outputs = asRecord(opts.outputs);
+        if (!inputs && inputDatasets) {
+            inputs = {
+                main: {
+                    items: inputDatasets.map((ref) => ({ ref, deps: [], })),
+                },
+            };
+        }
+        if (!outputs && outputDataset) {
+            outputs = {
+                main: {
+                    items: [{ ref: outputDataset, appendMode: false, },],
+                },
+            };
+        }
+        // Auto-generate name if not provided
+        const name = opts.name ?? (type && outputDataset ? `${type}_${outputDataset}` : undefined);
+        if (!type || !name || !inputs || !outputs) {
+            throw new Error("type and (inputDatasets + outputDataset) or (name + inputs + outputs) are required for create.");
+        }
+        const recipePrototype = {
+            type,
+            name,
+            projectKey: pk,
+            inputs,
+            outputs,
+        };
+        const creationSettings = {};
+        if (payload !== undefined) {
+            creationSettings.script = payload;
+        }
+        const createRecipe = () => this.client.post(`/public/api/projects/${enc}/recipes/`, {
+            recipePrototype,
+            creationSettings,
+        });
+        const createdDatasets = [];
+        let usedOutputProvisioningFallback = false;
+        try {
+            await createRecipe();
+        }
+        catch (error) {
+            if (!shouldRetryRecipeCreateWithOutputProvisioning(error)) {
+                throw error;
+            }
+            usedOutputProvisioningFallback = true;
+            // Fetch existing datasets to infer output connection and type
+            const existingDs = await this.client.get(`/public/api/projects/${enc}/datasets/`);
+            let outputConnection = asString(rawConnection);
+            if (!outputConnection) {
+                const managedDs = existingDs.find((d) => d.managed && d.params?.connection);
+                if (managedDs?.params?.connection) {
+                    outputConnection = managedDs.params.connection;
+                }
+            }
+            if (outputConnection) {
+                const existingNames = new Set(existingDs.map((d) => d.name));
+                const connectionSample = existingDs.find((d) => d.params?.connection === outputConnection && d.type);
+                const inferredOutputType = connectionSample?.type ?? "Filesystem";
+                const outputRoles = outputs;
+                for (const role of Object.values(outputRoles)) {
+                    for (const item of role.items ?? []) {
+                        if (item.ref && !existingNames.has(item.ref)) {
+                            const datasetBody = inferredOutputType === "Filesystem"
+                                ? {
+                                    projectKey: pk,
+                                    name: item.ref,
+                                    type: inferredOutputType,
+                                    params: {
+                                        connection: outputConnection,
+                                        path: `\${projectKey}/${item.ref}`,
+                                    },
+                                    formatType: "csv",
+                                    formatParams: {
+                                        style: "excel",
+                                        charset: "utf8",
+                                        separator: "\t",
+                                        quoteChar: '"',
+                                        escapeChar: "\\",
+                                        dateSerializationFormat: "ISO",
+                                        arrayMapFormat: "json",
+                                        parseHeaderRow: true,
+                                        compress: "gz",
+                                    },
+                                    managed: true,
+                                }
+                                : {
+                                    projectKey: pk,
+                                    name: item.ref,
+                                    type: inferredOutputType,
+                                    params: {
+                                        connection: outputConnection,
+                                        mode: "table",
+                                        table: item.ref,
+                                        ...(connectionSample?.params?.schema
+                                            ? { schema: connectionSample.params.schema, }
+                                            : {}),
+                                        ...(connectionSample?.params?.catalog
+                                            ? { catalog: connectionSample.params.catalog, }
+                                            : {}),
+                                    },
+                                    managed: connectionSample?.managed ?? false,
+                                };
+                            await this.client.post(`/public/api/projects/${enc}/datasets/`, datasetBody);
+                            existingNames.add(item.ref);
+                            createdDatasets.push(item.ref);
+                        }
+                    }
+                }
+            }
+            await createRecipe();
+        }
+        // For join recipes: configure join conditions after creation
+        let joinConfigured = false;
+        const joinCols = typeof opts.joinOn === "string" ? [opts.joinOn,] : asStringArray(opts.joinOn);
+        const joinType = asString(rawJoinType) ?? "LEFT";
+        if (type === "join" && joinCols?.length) {
+            const rnEnc = encodeURIComponent(name);
+            const full = await this.client.get(`/public/api/projects/${enc}/recipes/${rnEnc}`);
+            // DSS returns empty payload for fresh join recipes — construct from scratch
+            const inputCount = inputDatasets?.length
+                ?? inputs?.main?.items?.length
+                ?? 2;
+            const virtualInputs = [{ index: 0, preFilter: {}, },];
+            for (let i = 1; i < inputCount; i++) {
+                virtualInputs.push({
+                    index: i,
+                    on: joinCols.map((col) => ({
+                        column: col,
+                        type: "string",
+                        related: col,
+                        relatedType: "string",
+                        maxMatches: 1,
+                    })),
+                    joinType,
+                    preFilter: {},
+                });
+            }
+            const joinPayload = {
+                virtualInputs,
+                computedColumns: [],
+                postFilter: {},
+            };
+            // Ensure inputs/outputs are set — DSS may not persist them from the POST for join recipes
+            const updatedFull = {
+                ...full,
+                recipe: {
+                    ...full.recipe,
+                    inputs,
+                    outputs,
+                },
+                payload: JSON.stringify(joinPayload),
+            };
+            await this.client.put(`/public/api/projects/${enc}/recipes/${rnEnc}`, updatedFull);
+            joinConfigured = true;
+        }
+        return {
+            recipeName: name,
+            type,
+            createdDatasets,
+            joinConfigured,
+            outputProvisioningFallbackUsed: usedOutputProvisioningFallback,
+        };
+    }
+    /**
+     * Update a recipe by merging the patch into the current definition.
+     * The `recipe` sub-object is spread-merged to preserve nested fields.
+     */
+    async update(recipeName, data, projectKey) {
+        const enc = this.enc(projectKey);
+        const rnEnc = encodeURIComponent(recipeName);
+        const current = await this.client.get(`/public/api/projects/${enc}/recipes/${rnEnc}`);
+        const currentRecipe = asRecord(current.recipe);
+        if (!currentRecipe) {
+            throw new Error(`Recipe "${recipeName}" was not found or returned an empty definition.`);
+        }
+        const mergedRecipe = {
+            ...currentRecipe,
+            ...data.recipe,
+        };
+        const merged = { ...current, ...data, recipe: mergedRecipe, };
+        await this.client.put(`/public/api/projects/${enc}/recipes/${rnEnc}`, merged);
+    }
+    /** Delete a recipe. */
+    async delete(recipeName, projectKey) {
+        const enc = this.enc(projectKey);
+        const rnEnc = encodeURIComponent(recipeName);
+        await this.client.del(`/public/api/projects/${enc}/recipes/${rnEnc}`);
+    }
+    /**
+     * Download a recipe definition as a JSON file.
+     * Returns the path to the written file.
+     */
+    async download(recipeName, opts) {
+        const enc = this.enc(opts?.projectKey);
+        const rnEnc = encodeURIComponent(recipeName);
+        const recipe = await this.client.get(`/public/api/projects/${enc}/recipes/${rnEnc}`);
+        const safeRecipeName = sanitizeFileName(recipeName, "recipe");
+        const filePath = opts?.outputPath ?? resolve(process.cwd(), `${safeRecipeName}.json`);
+        await writeFile(filePath, JSON.stringify(recipe, null, 2), "utf-8");
+        return filePath;
+    }
+}

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

@@ -0,0 +1,26 @@
+import type { ScenarioDetails, ScenarioStatus, ScenarioSummary } from "../schemas.js";
+import { BaseResource } from "./base.js";
+export declare class ScenariosResource extends BaseResource {
+    /** List all scenarios in a project. */
+    list(projectKey?: string): Promise<ScenarioSummary[]>;
+    /** Get full scenario details. */
+    get(scenarioId: string, opts?: {
+        projectKey?: string;
+    }): Promise<ScenarioDetails>;
+    /** Create a new scenario. */
+    create(scenarioId: string, name: string, opts?: {
+        scenarioType?: "step_based" | "custom_python";
+        data?: Record<string, unknown>;
+        projectKey?: string;
+    }): Promise<void>;
+    /** Trigger a scenario run. */
+    run(scenarioId: string, projectKey?: string): Promise<{
+        runId: string;
+    }>;
+    /** Get the light/status view of a scenario. */
+    status(scenarioId: string, projectKey?: string): Promise<ScenarioStatus>;
+    /** Merge-update a scenario's definition. */
+    update(scenarioId: string, data: Record<string, unknown>, projectKey?: string): Promise<void>;
+    /** Delete a scenario. */
+    delete(scenarioId: string, projectKey?: string): Promise<void>;
+}

package/dist/src/resources/scenarios.js

@@ -0,0 +1,57 @@
+import { ScenarioDetailsSchema, ScenarioStatusSchema, ScenarioSummaryArraySchema, } from "../schemas.js";
+import { deepMerge, } from "../utils/deep-merge.js";
+import { BaseResource, } from "./base.js";
+export class ScenariosResource extends BaseResource {
+    /** List all scenarios in a project. */
+    async list(projectKey) {
+        const raw = await this.client.get(`/public/api/projects/${this.enc(projectKey)}/scenarios/`);
+        return this.client.safeParse(ScenarioSummaryArraySchema, raw, "scenarios.list");
+    }
+    /** Get full scenario details. */
+    async get(scenarioId, opts) {
+        const scEnc = encodeURIComponent(scenarioId);
+        const raw = await this.client.get(`/public/api/projects/${this.enc(opts?.projectKey)}/scenarios/${scEnc}/`);
+        return this.client.safeParse(ScenarioDetailsSchema, raw, "scenarios.get");
+    }
+    /** Create a new scenario. */
+    async create(scenarioId, name, opts) {
+        const pk = this.resolveProjectKey(opts?.projectKey);
+        const scenarioType = opts?.scenarioType ?? "step_based";
+        const body = {
+            id: scenarioId,
+            name,
+            projectKey: pk,
+            type: scenarioType,
+            params: scenarioType === "step_based" ? { steps: [], triggers: [], reporters: [], } : {},
+            ...opts?.data,
+        };
+        await this.client.post(`/public/api/projects/${this.enc(opts?.projectKey)}/scenarios/`, body);
+    }
+    /** Trigger a scenario run. */
+    async run(scenarioId, projectKey) {
+        const scEnc = encodeURIComponent(scenarioId);
+        const result = await this.client.post(`/public/api/projects/${this.enc(projectKey)}/scenarios/${scEnc}/run/`, {});
+        return {
+            runId: result.id ?? result.runId ?? "unknown",
+        };
+    }
+    /** Get the light/status view of a scenario. */
+    async status(scenarioId, projectKey) {
+        const scEnc = encodeURIComponent(scenarioId);
+        const raw = await this.client.get(`/public/api/projects/${this.enc(projectKey)}/scenarios/${scEnc}/light/`);
+        return this.client.safeParse(ScenarioStatusSchema, raw, "scenarios.status");
+    }
+    /** Merge-update a scenario's definition. */
+    async update(scenarioId, data, projectKey) {
+        const scEnc = encodeURIComponent(scenarioId);
+        const pkEnc = this.enc(projectKey);
+        const current = await this.client.get(`/public/api/projects/${pkEnc}/scenarios/${scEnc}/`);
+        const merged = deepMerge(current, data);
+        await this.client.put(`/public/api/projects/${pkEnc}/scenarios/${scEnc}/`, merged);
+    }
+    /** Delete a scenario. */
+    async delete(scenarioId, projectKey) {
+        const scEnc = encodeURIComponent(scenarioId);
+        await this.client.del(`/public/api/projects/${this.enc(projectKey)}/scenarios/${scEnc}/`);
+    }
+}

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

@@ -0,0 +1,40 @@
+import type { SqlQueryResponse, SqlQueryResult } from "../schemas.js";
+import { BaseResource } from "./base.js";
+export declare class SqlResource extends BaseResource {
+    /**
+     * Start a SQL query and return the queryId + schema.
+     * Specify either `connection` (run against a DB connection)
+     * or `datasetFullName` (run against a dataset's connection).
+     */
+    startQuery(opts: {
+        query: string;
+        connection?: string;
+        datasetFullName?: string;
+        database?: string;
+        preQueries?: string[];
+        postQueries?: string[];
+        type?: string;
+    }): Promise<SqlQueryResult>;
+    /**
+     * Stream results of a started query as parsed JSON (array of arrays).
+     */
+    streamResults(queryId: string): Promise<unknown[][]>;
+    /**
+     * Verify that a query finished successfully server-side.
+     * Throws on failure.
+     */
+    finishStreaming(queryId: string): Promise<void>;
+    /**
+     * Execute a SQL query end-to-end: start, stream all rows, verify, return combined result.
+     * This is the primary method most callers want.
+     */
+    query(opts: {
+        query: string;
+        connection?: string;
+        datasetFullName?: string;
+        database?: string;
+        preQueries?: string[];
+        postQueries?: string[];
+        type?: string;
+    }): Promise<SqlQueryResponse>;
+}

package/dist/src/resources/sql.js

@@ -0,0 +1,40 @@
+import { BaseResource, } from "./base.js";
+export class SqlResource extends BaseResource {
+    /**
+     * Start a SQL query and return the queryId + schema.
+     * Specify either `connection` (run against a DB connection)
+     * or `datasetFullName` (run against a dataset's connection).
+     */
+    async startQuery(opts) {
+        return this.client.post(`/public/api/sql/queries`, opts);
+    }
+    /**
+     * Stream results of a started query as parsed JSON (array of arrays).
+     */
+    async streamResults(queryId) {
+        const id = encodeURIComponent(queryId);
+        const text = await this.client.getText(`/public/api/sql/queries/${id}/stream?format=json`);
+        return JSON.parse(text);
+    }
+    /**
+     * Verify that a query finished successfully server-side.
+     * Throws on failure.
+     */
+    async finishStreaming(queryId) {
+        const id = encodeURIComponent(queryId);
+        const text = await this.client.getText(`/public/api/sql/queries/${id}/finish-streaming`);
+        if (text.length > 0) {
+            throw new Error(`SQL query ${queryId} failed: ${text}`);
+        }
+    }
+    /**
+     * Execute a SQL query end-to-end: start, stream all rows, verify, return combined result.
+     * This is the primary method most callers want.
+     */
+    async query(opts) {
+        const { queryId, schema, } = await this.startQuery(opts);
+        const rows = await this.streamResults(queryId);
+        await this.finishStreaming(queryId);
+        return { queryId, schema, rows, };
+    }
+}

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

@@ -0,0 +1,10 @@
+import type { ProjectVariables } from "../schemas.js";
+import { BaseResource } from "./base.js";
+export declare class VariablesResource extends BaseResource {
+    get(projectKey?: string): Promise<ProjectVariables>;
+    set(opts: {
+        standard?: Record<string, unknown>;
+        local?: Record<string, unknown>;
+        projectKey?: string;
+    }): Promise<ProjectVariables>;
+}

package/dist/src/resources/variables.js

@@ -0,0 +1,22 @@
+import { ProjectVariablesSchema, } from "../schemas.js";
+import { BaseResource, } from "./base.js";
+export class VariablesResource extends BaseResource {
+    async get(projectKey) {
+        const enc = this.enc(projectKey);
+        const raw = await this.client.get(`/public/api/projects/${enc}/variables/`);
+        return this.client.safeParse(ProjectVariablesSchema, raw, "variables.get");
+    }
+    async set(opts) {
+        if (opts.standard === undefined && opts.local === undefined) {
+            throw new Error("At least one of standard or local must be provided");
+        }
+        const existing = await this.get(opts.projectKey);
+        const merged = {
+            standard: { ...existing.standard, ...opts.standard, },
+            local: { ...existing.local, ...opts.local, },
+        };
+        const enc = this.enc(opts.projectKey);
+        await this.client.putVoid(`/public/api/projects/${enc}/variables/`, merged);
+        return merged;
+    }
+}

package/dist/src/schemas.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Re-export all schemas, types, and validation helpers from the types package.
+ * The types package (packages/types/) owns the TypeBox schema definitions.
+ * SDK consumers get everything through this re-export.
+ */
+export { BuildModeSchema, CodeEnvDetailsSchema, CodeEnvSummaryArraySchema, CodeEnvSummarySchema, ConnectionSummarySchema, DatasetCreateOptionsSchema, DatasetDetailsSchema, DatasetSchemaSchema, DatasetSummaryArraySchema, DatasetSummarySchema, FlowMapOptionsSchema, FolderDetailsSchema, FolderItemArraySchema, FolderItemSchema, FolderSummaryArraySchema, FolderSummarySchema, JobSummaryArraySchema, JobSummarySchema, JobWaitResultSchema, JupyterCellSchema, JupyterNotebookContentSchema, JupyterNotebookSummaryArraySchema, JupyterNotebookSummarySchema, NotebookSessionArraySchema, NotebookSessionSchema, parseSchema, ProjectDetailsSchema, ProjectMetadataSchema, ProjectSummaryArraySchema, ProjectSummarySchema, ProjectVariablesSchema, RecipeCreateOptionsSchema, RecipeCreateResultSchema, RecipeDetailsSchema, RecipeSummaryArraySchema, RecipeSummarySchema, safeParseSchema, ScenarioDetailsSchema, ScenarioStatusSchema, ScenarioSummaryArraySchema, ScenarioSummarySchema, SqlNotebookCellSchema, SqlNotebookContentSchema, SqlNotebookSummaryArraySchema, SqlNotebookSummarySchema, SqlQueryResponseSchema, SqlQueryResultSchema, SqlQuerySchemaSchema, } from "../packages/types/src/index.js";
+export type { BuildMode, CodeEnvDetails, CodeEnvSummary, ConnectionSummary, DatasetCreateOptions, DatasetDetails, DatasetSchema, DatasetSummary, FlowMapOptions, FolderDetails, FolderItem, FolderSummary, JobSummary, JobWaitResult, JupyterCell, JupyterNotebookContent, JupyterNotebookSummary, NotebookSession, ProjectDetails, ProjectMetadata, ProjectSummary, ProjectVariables, RecipeCreateOptions, RecipeCreateResult, RecipeDetails, RecipeSummary, SafeParseResult, ScenarioDetails, ScenarioStatus, ScenarioSummary, SqlNotebookCell, SqlNotebookContent, SqlNotebookSummary, SqlQueryResponse, SqlQueryResult, SqlQuerySchema, } from "../packages/types/src/index.js";

package/dist/src/schemas.js

@@ -0,0 +1,6 @@
+/**
+ * Re-export all schemas, types, and validation helpers from the types package.
+ * The types package (packages/types/) owns the TypeBox schema definitions.
+ * SDK consumers get everything through this re-export.
+ */
+export { BuildModeSchema, CodeEnvDetailsSchema, CodeEnvSummaryArraySchema, CodeEnvSummarySchema, ConnectionSummarySchema, DatasetCreateOptionsSchema, DatasetDetailsSchema, DatasetSchemaSchema, DatasetSummaryArraySchema, DatasetSummarySchema, FlowMapOptionsSchema, FolderDetailsSchema, FolderItemArraySchema, FolderItemSchema, FolderSummaryArraySchema, FolderSummarySchema, JobSummaryArraySchema, JobSummarySchema, JobWaitResultSchema, JupyterCellSchema, JupyterNotebookContentSchema, JupyterNotebookSummaryArraySchema, JupyterNotebookSummarySchema, NotebookSessionArraySchema, NotebookSessionSchema, parseSchema, ProjectDetailsSchema, ProjectMetadataSchema, ProjectSummaryArraySchema, ProjectSummarySchema, ProjectVariablesSchema, RecipeCreateOptionsSchema, RecipeCreateResultSchema, RecipeDetailsSchema, RecipeSummaryArraySchema, RecipeSummarySchema, safeParseSchema, ScenarioDetailsSchema, ScenarioStatusSchema, ScenarioSummaryArraySchema, ScenarioSummarySchema, SqlNotebookCellSchema, SqlNotebookContentSchema, SqlNotebookSummaryArraySchema, SqlNotebookSummarySchema, SqlQueryResponseSchema, SqlQueryResultSchema, SqlQuerySchemaSchema, } from "../packages/types/src/index.js";

package/dist/src/utils/deep-merge.d.ts

@@ -0,0 +1 @@
+export declare function deepMerge<T extends Record<string, unknown>>(base: T, patch: Record<string, unknown>): T;

package/dist/src/utils/deep-merge.js

@@ -0,0 +1,15 @@
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function deepMerge(base, patch) {
+    const out = { ...base, };
+    for (const [key, patchValue,] of Object.entries(patch)) {
+        const baseValue = out[key];
+        if (isPlainObject(baseValue) && isPlainObject(patchValue)) {
+            out[key] = deepMerge(baseValue, patchValue);
+            continue;
+        }
+        out[key] = patchValue;
+    }
+    return out;
+}

package/dist/src/utils/flow-map.d.ts

@@ -0,0 +1,37 @@
+export type FlowNodeKind = "dataset" | "recipe" | "folder" | "other";
+export type FlowEdgeRelation = "reads" | "writes" | "depends_on" | "unknown";
+export interface NormalizedFlowNode {
+    id: string;
+    kind: FlowNodeKind;
+    name?: string;
+    subtype?: string;
+    connection?: string;
+}
+export interface NormalizedFlowEdge {
+    from: string;
+    to: string;
+    relation: FlowEdgeRelation;
+}
+export interface NormalizedFlowMap {
+    projectKey: string;
+    nodes: NormalizedFlowNode[];
+    edges: NormalizedFlowEdge[];
+    stats: {
+        nodeCount: number;
+        edgeCount: number;
+        datasets: number;
+        recipes: number;
+        roots: number;
+        leaves: number;
+    };
+    roots: string[];
+    leaves: string[];
+    warnings: string[];
+}
+export interface NormalizeFlowGraphOptions {
+    folderNamesById?: Record<string, string>;
+    allDatasetNames?: string[];
+    allRecipeNames?: string[];
+    allFolderIds?: string[];
+}
+export declare function normalizeFlowGraph(raw: unknown, projectKey: string, options?: NormalizeFlowGraphOptions): NormalizedFlowMap;