dataiku-sdk 0.11.0 → 0.12.1

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

@@ -0,0 +1,130 @@
+import { UsageError, } from "../cli/usage.js";
+import { BaseResource, } from "./base.js";
+const TRAIN_POLL_INTERVAL_MS = 5_000;
+function requireNonEmpty(value, name) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new UsageError(`${name} must be a non-empty string.`, "validation_failed");
+    }
+    return value;
+}
+function delay(ms) {
+    const { promise, resolve, } = Promise.withResolvers();
+    setTimeout(resolve, ms);
+    return promise;
+}
+function modelIdsFromStatus(status) {
+    if (!Array.isArray(status.fullModelIds))
+        return [];
+    const modelIds = [];
+    for (const model of status.fullModelIds) {
+        if (typeof model?.id === "string" && model.id.length > 0)
+            modelIds.push(model.id);
+    }
+    return modelIds;
+}
+export class MlTasksResource extends BaseResource {
+    /** Create a prediction or clustering task in an existing visual analysis. */
+    async create(opts) {
+        if (opts.taskType !== "PREDICTION" && opts.taskType !== "CLUSTERING") {
+            throw new UsageError("taskType must be PREDICTION or CLUSTERING.", "invalid_enum");
+        }
+        if (opts.taskType === "PREDICTION"
+            && (typeof opts.targetVariable !== "string" || opts.targetVariable.trim().length === 0)) {
+            throw new UsageError("targetVariable is required for PREDICTION ML tasks.", "missing_required_arg");
+        }
+        const analysisId = encodeURIComponent(requireNonEmpty(opts.analysisId, "analysisId"));
+        const backendType = opts.backendType ?? "PY_MEMORY";
+        const guessPolicy = opts.guessPolicy
+            ?? (opts.taskType === "CLUSTERING" ? "KMEANS" : "DEFAULT");
+        requireNonEmpty(backendType, "backendType");
+        requireNonEmpty(guessPolicy, "guessPolicy");
+        if (opts.targetVariable !== undefined)
+            requireNonEmpty(opts.targetVariable, "targetVariable");
+        if (opts.predictionType !== undefined)
+            requireNonEmpty(opts.predictionType, "predictionType");
+        return this.client.post(`/public/api/projects/${this.enc(opts.projectKey)}/lab/${analysisId}/models/`, {
+            taskType: opts.taskType,
+            ...(opts.targetVariable !== undefined
+                ? { targetVariable: opts.targetVariable, }
+                : {}),
+            ...(opts.predictionType !== undefined
+                ? { predictionType: opts.predictionType, }
+                : {}),
+            backendType,
+            guessPolicy,
+        });
+    }
+    /** Get the current guessing, training, and trained-model status of a task. */
+    async status(analysisId, mlTaskId, projectKey) {
+        return this.client.get(`${this.taskPath(analysisId, mlTaskId, projectKey)}/status`);
+    }
+    /** Get the editable settings of an ML task. */
+    async getSettings(analysisId, mlTaskId, projectKey) {
+        return this.client.get(`${this.taskPath(analysisId, mlTaskId, projectKey)}/settings`);
+    }
+    /** Save the full settings object of an ML task. */
+    async saveSettings(analysisId, mlTaskId, settings, projectKey) {
+        if (settings === null || typeof settings !== "object" || Array.isArray(settings)) {
+            throw new UsageError("settings must be an object.", "validation_failed");
+        }
+        return this.client.post(`${this.taskPath(analysisId, mlTaskId, projectKey)}/settings`, settings);
+    }
+    /** Start training, optionally waiting for the task to finish. */
+    async train(opts) {
+        if (opts.sessionName !== undefined)
+            requireNonEmpty(opts.sessionName, "sessionName");
+        if (opts.sessionDescription !== undefined) {
+            requireNonEmpty(opts.sessionDescription, "sessionDescription");
+        }
+        const taskPath = this.taskPath(opts.analysisId, opts.mlTaskId, opts.projectKey);
+        const session = await this.client.post(`${taskPath}/train`, {
+            sessionName: opts.sessionName,
+            sessionDescription: opts.sessionDescription,
+            runQueue: opts.runQueue ?? false,
+        });
+        if (opts.wait !== true)
+            return session;
+        let status = await this.status(opts.analysisId, opts.mlTaskId, opts.projectKey);
+        while (status.training !== false) {
+            await delay(TRAIN_POLL_INTERVAL_MS);
+            status = await this.status(opts.analysisId, opts.mlTaskId, opts.projectKey);
+        }
+        return {
+            sessionId: session.sessionId,
+            trainedModelIds: modelIdsFromStatus(status),
+        };
+    }
+    /** List identifiers for every trained model currently present on the task. */
+    async listTrainedModels(analysisId, mlTaskId, projectKey) {
+        return modelIdsFromStatus(await this.status(analysisId, mlTaskId, projectKey));
+    }
+    /** Get full details for a trained model. */
+    async trainedModelDetails(analysisId, mlTaskId, modelId, projectKey) {
+        const id = encodeURIComponent(requireNonEmpty(modelId, "modelId"));
+        return this.client.get(`${this.taskPath(analysisId, mlTaskId, projectKey)}/models/${id}/details`);
+    }
+    /** Deploy a trained model to the Flow as a saved model and training recipe. */
+    async deployToFlow(opts) {
+        const modelId = encodeURIComponent(requireNonEmpty(opts.modelId, "modelId"));
+        const trainDatasetRef = requireNonEmpty(opts.trainDatasetRef, "trainDatasetRef");
+        const modelName = requireNonEmpty(opts.modelName, "modelName");
+        if (opts.testDatasetRef !== undefined) {
+            requireNonEmpty(opts.testDatasetRef, "testDatasetRef");
+        }
+        return this.client.post(`${this.taskPath(opts.analysisId, opts.mlTaskId, opts.projectKey)}/models/${modelId}/actions/deployToFlow`, {
+            trainDatasetRef,
+            testDatasetRef: opts.testDatasetRef,
+            modelName,
+            redoOptimization: opts.redoOptimization ?? true,
+        });
+    }
+    /** Delete an ML task and its trained models. */
+    async delete(analysisId, mlTaskId, projectKey) {
+        await this.client.del(`${this.taskPath(analysisId, mlTaskId, projectKey)}/`);
+    }
+    taskPath(analysisId, mlTaskId, projectKey) {
+        const analysis = encodeURIComponent(requireNonEmpty(analysisId, "analysisId"));
+        const task = encodeURIComponent(requireNonEmpty(mlTaskId, "mlTaskId"));
+        return `/public/api/projects/${this.enc(projectKey)}/models/lab/${analysis}/${task}`;
+    }
+}

package/dist/src/resources/model-evaluation-stores.d.ts

@@ -0,0 +1,41 @@
+import { BaseResource } from "./base.js";
+export interface ModelEvaluationStoreListItem extends Record<string, unknown> {
+    id?: string;
+    name?: string;
+    projectKey?: string;
+    mesFlavor?: string;
+}
+export interface ModelEvaluationStore extends Record<string, unknown> {
+    id?: string;
+    name?: string;
+    projectKey?: string;
+    mesFlavor?: string;
+}
+export interface ModelEvaluationStoreCreateOptions {
+    name: string;
+    projectKey?: string;
+}
+export interface ModelEvaluationStoreCreateResult extends Record<string, unknown> {
+    id?: string;
+    name?: string;
+    projectKey?: string;
+}
+export interface ModelEvaluationListItem extends Record<string, unknown> {
+    id?: string;
+    evaluationId?: string;
+    createdOn?: number;
+    label?: string;
+}
+export declare class ModelEvaluationStoresResource extends BaseResource {
+    /** List model evaluation stores in a project. */
+    list(projectKey?: string): Promise<ModelEvaluationStoreListItem[]>;
+    /** Get model evaluation store settings and metadata. */
+    get(modelEvaluationStoreId: string, projectKey?: string): Promise<ModelEvaluationStore>;
+    /** Create a tabular model evaluation store. */
+    create(opts: ModelEvaluationStoreCreateOptions): Promise<ModelEvaluationStoreCreateResult>;
+    /** List evaluations in a model evaluation store. */
+    listEvaluations(modelEvaluationStoreId: string, projectKey?: string): Promise<ModelEvaluationListItem[]>;
+    /** Delete a model evaluation store and its evaluations. */
+    delete(modelEvaluationStoreId: string, projectKey?: string): Promise<void>;
+    private storePath;
+}

package/dist/src/resources/model-evaluation-stores.js

@@ -0,0 +1,36 @@
+import { UsageError, } from "../cli/usage.js";
+import { BaseResource, } from "./base.js";
+function requireNonEmpty(value, name) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new UsageError(`${name} must be a non-empty string.`, "validation_failed");
+    }
+    return value;
+}
+export class ModelEvaluationStoresResource extends BaseResource {
+    /** List model evaluation stores in a project. */
+    async list(projectKey) {
+        return this.client.get(`/public/api/projects/${this.enc(projectKey)}/evaluationstores/`);
+    }
+    /** Get model evaluation store settings and metadata. */
+    async get(modelEvaluationStoreId, projectKey) {
+        return this.client.get(this.storePath(modelEvaluationStoreId, projectKey));
+    }
+    /** Create a tabular model evaluation store. */
+    async create(opts) {
+        const name = requireNonEmpty(opts.name, "name");
+        const projectKey = this.resolveProjectKey(opts.projectKey);
+        return this.client.post(`/public/api/projects/${encodeURIComponent(projectKey)}/evaluationstores/?flavor=TABULAR`, { projectKey, name, });
+    }
+    /** List evaluations in a model evaluation store. */
+    async listEvaluations(modelEvaluationStoreId, projectKey) {
+        return this.client.get(`${this.storePath(modelEvaluationStoreId, projectKey)}/evaluations/`);
+    }
+    /** Delete a model evaluation store and its evaluations. */
+    async delete(modelEvaluationStoreId, projectKey) {
+        await this.client.del(this.storePath(modelEvaluationStoreId, projectKey));
+    }
+    storePath(modelEvaluationStoreId, projectKey) {
+        const id = encodeURIComponent(requireNonEmpty(modelEvaluationStoreId, "modelEvaluationStoreId"));
+        return `/public/api/projects/${this.enc(projectKey)}/evaluationstores/${id}`;
+    }
+}

package/dist/src/resources/recipes.js

@@ -22,6 +22,67 @@ function asRecord(value) {
         return undefined;
     return value;
 }
+function parseRecipePayload(payload) {
+    if (!payload)
+        return {};
+    const parsed = JSON.parse(payload);
+    return asRecord(parsed) ?? {};
+}
+function parseJoinKeyPairs(values, optionName = "joinOn") {
+    const pairs = [];
+    for (const raw of values) {
+        const token = raw.trim();
+        if (!token)
+            continue;
+        const eq = token.indexOf("=");
+        if (eq === -1) {
+            pairs.push({ left: token, right: token, });
+            continue;
+        }
+        const left = token.slice(0, eq).trim();
+        const right = token.slice(eq + 1).trim();
+        if (!left || !right)
+            throw new Error(`${optionName} values must use COL or LEFT=RIGHT.`);
+        pairs.push({ left, right, });
+    }
+    return pairs;
+}
+function normalizeFuzzyDistance(value) {
+    const normalized = typeof value === "string" && value.trim().length > 0
+        ? value.trim().toUpperCase()
+        : "DAMERAU_LEVENSHTEIN";
+    if (normalized === "DAMERAU_LEVENSHTEIN")
+        return "LEVENSHTEIN";
+    if (normalized === "HAMMING" || normalized === "JACCARD" || normalized === "COSINE"
+        || normalized === "EUCLIDEAN") {
+        return normalized;
+    }
+    throw new Error("fuzzyDistance must be one of DAMERAU_LEVENSHTEIN, HAMMING, JACCARD, COSINE, or EUCLIDEAN.");
+}
+function normalizeJoinType(value) {
+    const normalized = typeof value === "string" && value.trim().length > 0
+        ? value.trim().toUpperCase()
+        : "LEFT";
+    if (normalized === "LEFT" || normalized === "INNER" || normalized === "RIGHT"
+        || normalized === "FULL") {
+        return normalized;
+    }
+    throw new Error("joinType must be one of LEFT, INNER, RIGHT, or FULL.");
+}
+function recipeVirtualInputs(payload, inputCount) {
+    const current = Array.isArray(payload.virtualInputs) ? payload.virtualInputs : [];
+    const virtualInputs = [];
+    for (let i = 0; i < inputCount; i++) {
+        virtualInputs.push({
+            preFilter: {},
+            outputColumnsSelectionMode: "AUTO_NON_CONFLICTING",
+            computedColumns: [],
+            ...asRecord(current[i]),
+            index: i,
+        });
+    }
+    return virtualInputs;
+}
 const RECIPE_DEFINITION_FIELDS = new Set(["params", "inputs", "outputs", "scriptSettings",]);
 function rootRecipeDefinitionFields(data) {
     return Object.keys(data).filter((key) => RECIPE_DEFINITION_FIELDS.has(key));
@@ -467,17 +528,37 @@ export class RecipesResource extends BaseResource {
         if (!type || !name || !inputs || !outputs) {
             throw new Error("type and (inputDatasets + outputDataset/outputFolder) or (name + inputs + outputs) are required for create.");
         }
+        const joinCols = typeof opts.joinOn === "string" ? [opts.joinOn,] : asStringArray(opts.joinOn);
+        const joinKeys = type === "join" && joinCols?.length
+            ? parseJoinKeyPairs(joinCols)
+            : undefined;
+        const fuzzyOn = opts.fuzzyOn ?? (type === "fuzzyjoin" ? opts.joinOn : undefined);
+        const fuzzyCols = typeof fuzzyOn === "string" ? [fuzzyOn,] : asStringArray(fuzzyOn);
+        const fuzzyKeys = type === "fuzzyjoin" && fuzzyCols?.length
+            ? parseJoinKeyPairs(fuzzyCols, "fuzzyOn")
+            : undefined;
+        const normalizedJoinType = joinKeys?.length || fuzzyKeys?.length
+            ? normalizeJoinType(rawJoinType)
+            : undefined;
+        const fuzzyDistance = fuzzyKeys?.length ? normalizeFuzzyDistance(opts.fuzzyDistance) : undefined;
+        const fuzzyThreshold = opts.fuzzyThreshold ?? 1;
+        if (!Number.isFinite(fuzzyThreshold)) {
+            throw new Error("fuzzyThreshold must be a finite number.");
+        }
         const recipePrototype = {
             type,
             name,
             projectKey: pk,
-            inputs,
+            ...(type === "fuzzyjoin" ? {} : { inputs, }),
             outputs,
         };
         const creationSettings = {};
         if (payload !== undefined) {
             creationSettings.script = payload;
         }
+        if (type === "fuzzyjoin") {
+            creationSettings.virtualInputs = recipeInputItems({ inputs, }).map((item) => item.ref);
+        }
         const createRecipe = () => this.client.post(`/public/api/projects/${enc}/recipes/`, {
             recipePrototype,
             creationSettings,
@@ -597,37 +678,29 @@ export class RecipesResource extends BaseResource {
         }
         // 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) {
+        if (type === "join" && joinKeys?.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,
+            const joinPayload = parseRecipePayload(full.payload);
+            const inputCount = recipeInputItems({ inputs, }).length || inputDatasets?.length || 2;
+            const joinType = normalizedJoinType ?? "LEFT";
+            joinPayload.virtualInputs = recipeVirtualInputs(joinPayload, inputCount);
+            joinPayload.joins = Array.from({ length: Math.max(0, inputCount - 1), }, (_, index) => {
+                const table2 = index + 1;
+                return {
+                    table1: 0,
+                    table2,
+                    conditionsMode: "AND",
+                    type: joinType,
+                    outerJoinOnTheLeft: joinType === "LEFT",
+                    on: joinKeys.map((key) => ({
+                        column1: { name: key.left, table: 0, },
+                        column2: { name: key.right, table: table2, },
+                        type: "EQ",
                     })),
-                    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 = {
+                };
+            });
+            await this.client.put(`/public/api/projects/${enc}/recipes/${rnEnc}`, {
                 ...full,
                 recipe: {
                     ...full.recipe,
@@ -635,8 +708,52 @@ export class RecipesResource extends BaseResource {
                     outputs,
                 },
                 payload: JSON.stringify(joinPayload),
-            };
-            await this.client.put(`/public/api/projects/${enc}/recipes/${rnEnc}`, updatedFull);
+            });
+            joinConfigured = true;
+        }
+        if (type === "fuzzyjoin" && fuzzyKeys?.length) {
+            const rnEnc = encodeURIComponent(name);
+            const full = await this.client.get(`/public/api/projects/${enc}/recipes/${rnEnc}`);
+            const fuzzyPayload = parseRecipePayload(full.payload);
+            const inputCount = recipeInputItems({ inputs, }).length || inputDatasets?.length || 2;
+            const joinType = normalizedJoinType ?? "LEFT";
+            fuzzyPayload.virtualInputs = recipeVirtualInputs(fuzzyPayload, inputCount);
+            fuzzyPayload.joins = Array.from({ length: Math.max(0, inputCount - 1), }, (_, index) => {
+                const table2 = index + 1;
+                return {
+                    table1: 0,
+                    table2,
+                    conditionsMode: "AND",
+                    type: joinType,
+                    on: fuzzyKeys.map((key) => ({
+                        column1: { name: key.left, table: 0, },
+                        column2: { name: key.right, table: table2, },
+                        type: "EQ",
+                        fuzzyMatchDesc: {
+                            distanceType: fuzzyDistance ?? "LEVENSHTEIN",
+                            threshold: fuzzyThreshold,
+                        },
+                        ...(opts.fuzzyNormalize === true
+                            ? {
+                                normaliseDesc: {
+                                    caseInsensitive: true,
+                                    normaliseText: true,
+                                    unicodeCasting: true,
+                                },
+                            }
+                            : {}),
+                    })),
+                };
+            });
+            await this.client.put(`/public/api/projects/${enc}/recipes/${rnEnc}`, {
+                ...full,
+                recipe: {
+                    ...full.recipe,
+                    inputs,
+                    outputs,
+                },
+                payload: JSON.stringify(fuzzyPayload),
+            });
             joinConfigured = true;
         }
         let temporaryOutputDatasetDeleted;

package/dist/src/resources/saved-models.d.ts

@@ -0,0 +1,41 @@
+import { BaseResource } from "./base.js";
+export interface SavedModelListItem extends Record<string, unknown> {
+    id?: string;
+    name?: string;
+    projectKey?: string;
+    activeVersion?: string;
+}
+export interface SavedModel extends Record<string, unknown> {
+    id?: string;
+    name?: string;
+    projectKey?: string;
+    activeVersion?: string;
+}
+export interface SavedModelVersionListItem extends Record<string, unknown> {
+    id?: string;
+    active?: boolean;
+    createdOn?: number;
+}
+export interface SavedModelVersionDetails extends Record<string, unknown> {
+    id?: string;
+    algorithm?: string;
+    predictionType?: string;
+}
+export interface SavedModelActionResult extends Record<string, unknown> {
+    message?: string;
+}
+export declare class SavedModelsResource extends BaseResource {
+    /** List saved models in a project. */
+    list(projectKey?: string): Promise<SavedModelListItem[]>;
+    /** Get saved-model settings and metadata. */
+    get(savedModelId: string, projectKey?: string): Promise<SavedModel>;
+    /** List all versions of a saved model. */
+    listVersions(savedModelId: string, projectKey?: string): Promise<SavedModelVersionListItem[]>;
+    /** Get full details for one saved-model version. */
+    versionDetails(savedModelId: string, versionId: string, projectKey?: string): Promise<SavedModelVersionDetails>;
+    /** Make one saved-model version active. */
+    setActiveVersion(savedModelId: string, versionId: string, projectKey?: string): Promise<SavedModelActionResult | undefined>;
+    /** Delete a saved model and all of its versions. */
+    delete(savedModelId: string, projectKey?: string): Promise<void>;
+    private savedModelPath;
+}

package/dist/src/resources/saved-models.js

@@ -0,0 +1,40 @@
+import { UsageError, } from "../cli/usage.js";
+import { BaseResource, } from "./base.js";
+function requireNonEmpty(value, name) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new UsageError(`${name} must be a non-empty string.`, "validation_failed");
+    }
+    return value;
+}
+export class SavedModelsResource extends BaseResource {
+    /** List saved models in a project. */
+    async list(projectKey) {
+        return this.client.get(`/public/api/projects/${this.enc(projectKey)}/savedmodels/`);
+    }
+    /** Get saved-model settings and metadata. */
+    async get(savedModelId, projectKey) {
+        return this.client.get(this.savedModelPath(savedModelId, projectKey));
+    }
+    /** List all versions of a saved model. */
+    async listVersions(savedModelId, projectKey) {
+        return this.client.get(`${this.savedModelPath(savedModelId, projectKey)}/versions`);
+    }
+    /** Get full details for one saved-model version. */
+    async versionDetails(savedModelId, versionId, projectKey) {
+        const version = encodeURIComponent(requireNonEmpty(versionId, "versionId"));
+        return this.client.get(`${this.savedModelPath(savedModelId, projectKey)}/versions/${version}/details`);
+    }
+    /** Make one saved-model version active. */
+    async setActiveVersion(savedModelId, versionId, projectKey) {
+        const version = encodeURIComponent(requireNonEmpty(versionId, "versionId"));
+        return this.client.post(`${this.savedModelPath(savedModelId, projectKey)}/versions/${version}/actions/setActive`, {});
+    }
+    /** Delete a saved model and all of its versions. */
+    async delete(savedModelId, projectKey) {
+        await this.client.del(this.savedModelPath(savedModelId, projectKey));
+    }
+    savedModelPath(savedModelId, projectKey) {
+        const id = encodeURIComponent(requireNonEmpty(savedModelId, "savedModelId"));
+        return `/public/api/projects/${this.enc(projectKey)}/savedmodels/${id}`;
+    }
+}

package/dist/src/resources/scenarios.js

@@ -86,6 +86,34 @@ function extractCodeRunOutput(log) {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function scenarioStepWarningSummary(stepResult) {
+    const container = stepResult?.warnings;
+    if (!isRecord(container))
+        return {};
+    const rawWarnings = container.warnings;
+    const warnings = isRecord(rawWarnings)
+        ? Object.entries(rawWarnings).flatMap(([key, value,]) => {
+            if (!isRecord(value))
+                return [];
+            const rawType = value.type;
+            const type = typeof rawType === "string" && rawType.length > 0 ? rawType : key;
+            const rawCount = value.count;
+            return [{
+                    type,
+                    ...(typeof rawCount === "number" && Number.isFinite(rawCount)
+                        ? { count: rawCount, }
+                        : {}),
+                },];
+        })
+        : [];
+    const rawTotal = container.totalCount;
+    return {
+        ...(typeof rawTotal === "number" && Number.isFinite(rawTotal)
+            ? { warningCount: rawTotal, }
+            : {}),
+        ...(warnings.length > 0 ? { warnings, } : {}),
+    };
+}
 function jsonValueEqual(left, right) {
     if (Object.is(left, right))
         return true;
@@ -352,6 +380,7 @@ export class ScenariosResource extends BaseResource {
                         name: stepDef?.name,
                         type: stepDef?.type,
                         outcome: stepResult?.outcome ?? "UNKNOWN",
+                        ...scenarioStepWarningSummary(stepResult),
                     };
                 });
                 if (mapped.length > 0)

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "dataiku-sdk",
-	"version": "0.11.0",
+	"version": "0.12.1",
 	"description": "Dataiku DSS SDK and CLI for programmatic access to DSS REST APIs",
 	"type": "module",
 	"workspaces": [

package/packages/types/dist/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>;
 }>;
@@ -269,6 +273,11 @@ 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;
+    warningCount: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    warnings: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        type: import("@sinclair/typebox").TString;
+        count: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    }>>>;
 }>;
 export type ScenarioStepRun = Static<typeof ScenarioStepRunSchema>;
 export declare const ScenarioWaitResultSchema: import("@sinclair/typebox").TObject<{
@@ -284,6 +293,11 @@ export declare const ScenarioWaitResultSchema: import("@sinclair/typebox").TObje
         name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
         type: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
         outcome: import("@sinclair/typebox").TString;
+        warningCount: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+        warnings: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            type: import("@sinclair/typebox").TString;
+            count: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+        }>>>;
     }>>>;
 }>;
 export type ScenarioWaitResult = Static<typeof ScenarioWaitResultSchema>;

package/packages/types/dist/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()),
 });
@@ -318,6 +322,11 @@ export const ScenarioStepRunSchema = Type.Object({
     name: Type.Optional(Type.String()),
     type: Type.Optional(Type.String()),
     outcome: Type.String(),
+    warningCount: Type.Optional(Type.Number()),
+    warnings: Type.Optional(Type.Array(Type.Object({
+        type: Type.String(),
+        count: Type.Optional(Type.Number()),
+    }, { additionalProperties: false, }))),
 }, { additionalProperties: false, });
 export const ScenarioWaitResultSchema = Type.Object({
     scenarioId: Type.String(),