dataiku-sdk 3.6.1 → 3.7.0

package/dist/src/resources/metrics.js

@@ -16,6 +16,16 @@ export class MetricsResource extends BaseResource {
         const pk = this.enc(projectKey);
         return this.client.post(`${datasetPath(pk, datasetName)}/actions/computeMetrics?partition=`);
     }
+    /**
+     * Run the dataset's checks (POST /actions/runChecks/{?partitions}). Without
+     * `checks` DSS runs the checks configured on the dataset; with `checks` it
+     * runs those definitions instead (body `{"checks": [...]}`).
+     */
+    async runDatasetChecks(datasetName, opts = {}) {
+        const pk = this.enc(opts.projectKey);
+        const query = opts.partitions ? `?partitions=${encodeURIComponent(opts.partitions)}` : "";
+        return this.client.post(`${datasetPath(pk, datasetName)}/actions/runChecks/${query}`, opts.checks ? { checks: opts.checks, } : undefined);
+    }
     /** Get the last metric values for a managed folder. */
     async getFolderMetrics(folderId, projectKey) {
         const pk = this.enc(projectKey);

package/dist/src/resources/ml-tasks.d.ts

@@ -1,14 +1,41 @@
 import { BaseResource } from "./base.js";
+import { TrainedModel } from "./trained-model.js";
 export type MlTaskType = "PREDICTION" | "CLUSTERING";
-export interface MlTaskCreateOptions {
-    analysisId: string;
+/** ML task definition; time series forecasting is PREDICTION with predictionType TIMESERIES_FORECAST. */
+export interface MlTaskCreateFields {
     taskType: MlTaskType;
     targetVariable?: string;
     predictionType?: string;
+    /** Forecasting tasks: the parsed-date time column. */
+    timeVariable?: string;
+    /** Forecasting tasks: columns identifying each series of a multi-series dataset. */
+    timeseriesIdentifiers?: string[];
     backendType?: string;
     guessPolicy?: string;
     projectKey?: string;
 }
+export interface MlTaskCreateOptions extends MlTaskCreateFields {
+    analysisId: string;
+}
+export interface MlTaskCreateForDatasetOptions extends MlTaskCreateFields {
+    inputDataset: string;
+}
+export interface MlTaskListItem extends Record<string, unknown> {
+    analysisId?: string;
+    mlTaskId?: string;
+    analysisName?: string;
+    mlTaskName?: string;
+    taskType?: string;
+    inputDataset?: string;
+}
+export interface MlTaskReguessOptions {
+    predictionType?: string;
+    targetVariable?: string;
+    timeVariable?: string;
+    timeseriesIdentifiers?: string[];
+    /** Re-guess every setting after the core change, not just the impacted ones. */
+    fullReguess?: boolean;
+}
 export interface MlTaskCreateResult extends Record<string, unknown> {
     analysisId?: string;
     mlTaskId?: string;
@@ -91,6 +118,14 @@ export interface MlTaskDeployResult extends Record<string, unknown> {
     savedModelId?: string;
     trainRecipeName?: string;
 }
+/** Query of POST .../guess; repeated `timeseriesIdentifiers` as dataikuapi sends a list (pure; shared with `--plan`). */
+export declare function mlTaskReguessQuery(opts: MlTaskReguessOptions): URLSearchParams;
+/**
+ * Task-creation body shared by `create` (existing analysis) and
+ * `createForDataset` (new analysis), with dataikuapi's defaults (pure; shared
+ * with `--plan`).
+ */
+export declare function mlTaskCreateBody(opts: MlTaskCreateFields): Record<string, unknown>;
 export declare class MlTasksResource extends BaseResource {
     /** Create a prediction or clustering task in an existing visual analysis. */
     create(opts: MlTaskCreateOptions): Promise<MlTaskCreateResult>;
@@ -122,5 +157,33 @@ export declare class MlTasksResource extends BaseResource {
     deployToFlow(opts: MlTaskDeployOptions): Promise<MlTaskDeployResult>;
     /** Delete an ML task and its trained models. */
     delete(analysisId: string, mlTaskId: string, projectKey?: string): Promise<void>;
+    /** Every ML task of the project, with its visual analysis (GET /models/lab/). */
+    list(projectKey?: string): Promise<MlTaskListItem[]>;
+    /**
+     * Create a new visual analysis on `inputDataset` with one ML task
+     * (POST /models/lab/). Returns `{analysisId, mlTaskId}`; DSS guesses the
+     * settings asynchronously (watch `status().guessing`).
+     */
+    createForDataset(opts: MlTaskCreateForDatasetOptions): Promise<MlTaskCreateResult>;
+    /**
+     * Re-guess the task settings: all of them, or (prediction tasks) after
+     * setting a new prediction type, target, time variable, or series
+     * identifiers — only the impacted settings unless `fullReguess`.
+     */
+    reguess(analysisId: string, mlTaskId: string, opts?: MlTaskReguessOptions, projectKey?: string): Promise<void>;
+    /**
+     * Time series forecasting tasks: change the forecasting parameters
+     * (`forecastHorizon`, `validationHorizons`, `timestepParams`,
+     * `updateAlgorithmSettings`) and re-guess the impacted algorithm settings.
+     */
+    reguessForecasting(analysisId: string, mlTaskId: string, params: Record<string, unknown>, projectKey?: string): Promise<void>;
+    /**
+     * One trained lab model as a {@link TrainedModel}: diagnostics
+     * (subpopulation analyses, partial dependencies, timeseries residuals and
+     * per-series results), documentation, scoring exports, user metadata.
+     */
+    model(analysisId: string, mlTaskId: string, modelId: string, projectKey?: string): TrainedModel;
+    /** GET a generated lab model documentation (docx) by the `exportId` of its finished future. */
+    downloadModelDocumentation(exportId: string, projectKey?: string): Promise<Response>;
     private taskPath;
 }

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

@@ -1,6 +1,7 @@
 import { ClientValidationError, } from "../errors.js";
 import { computeNextPollDelayMs, isRequestDeadlineError, } from "../utils/polling.js";
-import { BaseResource, requireNonEmpty, } from "./base.js";
+import { BaseResource, requireArrayResponse, requireNonEmpty, requireObject, } from "./base.js";
+import { TrainedModel, } from "./trained-model.js";
 const TRAIN_POLL_INTERVAL_MS = 5_000;
 const TRAIN_DEFAULT_TIMEOUT_MS = 120_000;
 function delay(ms) {
@@ -18,37 +19,64 @@ function modelIdsFromStatus(status) {
     }
     return modelIds;
 }
+/** Query of POST .../guess; repeated `timeseriesIdentifiers` as dataikuapi sends a list (pure; shared with `--plan`). */
+export function mlTaskReguessQuery(opts) {
+    const query = new URLSearchParams();
+    if (opts.predictionType !== undefined)
+        query.set("predictionType", opts.predictionType);
+    if (opts.targetVariable !== undefined)
+        query.set("targetVariable", opts.targetVariable);
+    if (opts.timeVariable !== undefined)
+        query.set("timeVariable", opts.timeVariable);
+    for (const id of opts.timeseriesIdentifiers ?? [])
+        query.append("timeseriesIdentifiers", id);
+    if (opts.fullReguess !== undefined)
+        query.set("fullReguess", String(opts.fullReguess));
+    return query;
+}
+/**
+ * Task-creation body shared by `create` (existing analysis) and
+ * `createForDataset` (new analysis), with dataikuapi's defaults (pure; shared
+ * with `--plan`).
+ */
+export function mlTaskCreateBody(opts) {
+    if (opts.taskType !== "PREDICTION" && opts.taskType !== "CLUSTERING") {
+        throw new ClientValidationError("taskType must be PREDICTION or CLUSTERING.", "invalid_enum");
+    }
+    if (opts.taskType === "PREDICTION"
+        && (typeof opts.targetVariable !== "string" || opts.targetVariable.trim().length === 0)) {
+        throw new ClientValidationError("targetVariable is required for PREDICTION ML tasks.", "missing_required_arg");
+    }
+    const forecast = opts.predictionType === "TIMESERIES_FORECAST";
+    if (forecast && (typeof opts.timeVariable !== "string" || opts.timeVariable.trim().length === 0)) {
+        throw new ClientValidationError("timeVariable is required for TIMESERIES_FORECAST ML tasks.", "missing_required_arg");
+    }
+    const backendType = opts.backendType ?? "PY_MEMORY";
+    const guessPolicy = opts.guessPolicy
+        ?? (opts.taskType === "CLUSTERING" ? "KMEANS" : forecast ? "TIMESERIES_DEFAULT" : "DEFAULT");
+    requireNonEmpty(backendType, "backendType");
+    requireNonEmpty(guessPolicy, "guessPolicy");
+    if (opts.targetVariable !== undefined)
+        requireNonEmpty(opts.targetVariable, "targetVariable");
+    if (opts.predictionType !== undefined)
+        requireNonEmpty(opts.predictionType, "predictionType");
+    return {
+        taskType: opts.taskType,
+        ...(opts.targetVariable !== undefined ? { targetVariable: opts.targetVariable, } : {}),
+        ...(opts.predictionType !== undefined ? { predictionType: opts.predictionType, } : {}),
+        ...(opts.timeVariable !== undefined ? { timeVariable: opts.timeVariable, } : {}),
+        ...(opts.timeseriesIdentifiers !== undefined
+            ? { timeseriesIdentifiers: opts.timeseriesIdentifiers, }
+            : {}),
+        backendType,
+        guessPolicy,
+    };
+}
 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 ClientValidationError("taskType must be PREDICTION or CLUSTERING.", "invalid_enum");
-        }
-        if (opts.taskType === "PREDICTION"
-            && (typeof opts.targetVariable !== "string" || opts.targetVariable.trim().length === 0)) {
-            throw new ClientValidationError("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,
-        });
+        return this.client.post(`/public/api/projects/${this.enc(opts.projectKey)}/lab/${analysisId}/models/`, mlTaskCreateBody(opts));
     }
     /** Get the current guessing, training, and trained-model status of a task. */
     async status(analysisId, mlTaskId, projectKey) {
@@ -211,6 +239,52 @@ export class MlTasksResource extends BaseResource {
     async delete(analysisId, mlTaskId, projectKey) {
         await this.client.del(`${this.taskPath(analysisId, mlTaskId, projectKey)}/`);
     }
+    /** Every ML task of the project, with its visual analysis (GET /models/lab/). */
+    async list(projectKey) {
+        const res = await this.client.get(`/public/api/projects/${this.enc(projectKey)}/models/lab/`);
+        return requireArrayResponse(res.mlTasks, "mlTasks.list");
+    }
+    /**
+     * Create a new visual analysis on `inputDataset` with one ML task
+     * (POST /models/lab/). Returns `{analysisId, mlTaskId}`; DSS guesses the
+     * settings asynchronously (watch `status().guessing`).
+     */
+    async createForDataset(opts) {
+        return this.client.post(`/public/api/projects/${this.enc(opts.projectKey)}/models/lab/`, {
+            inputDataset: requireNonEmpty(opts.inputDataset, "inputDataset"),
+            ...mlTaskCreateBody(opts),
+        });
+    }
+    /**
+     * Re-guess the task settings: all of them, or (prediction tasks) after
+     * setting a new prediction type, target, time variable, or series
+     * identifiers — only the impacted settings unless `fullReguess`.
+     */
+    async reguess(analysisId, mlTaskId, opts = {}, projectKey) {
+        const query = mlTaskReguessQuery(opts);
+        await this.client.post(`${this.taskPath(analysisId, mlTaskId, projectKey)}/guess${query.size > 0 ? `?${query}` : ""}`);
+    }
+    /**
+     * Time series forecasting tasks: change the forecasting parameters
+     * (`forecastHorizon`, `validationHorizons`, `timestepParams`,
+     * `updateAlgorithmSettings`) and re-guess the impacted algorithm settings.
+     */
+    async reguessForecasting(analysisId, mlTaskId, params, projectKey) {
+        await this.client.post(`${this.taskPath(analysisId, mlTaskId, projectKey)}/reguess-with-forecasting-params`, requireObject(params, "params"));
+    }
+    /**
+     * One trained lab model as a {@link TrainedModel}: diagnostics
+     * (subpopulation analyses, partial dependencies, timeseries residuals and
+     * per-series results), documentation, scoring exports, user metadata.
+     */
+    model(analysisId, mlTaskId, modelId, projectKey) {
+        const id = encodeURIComponent(requireNonEmpty(modelId, "modelId"));
+        return new TrainedModel(this.client, `${this.taskPath(analysisId, mlTaskId, projectKey)}/models/${id}`);
+    }
+    /** GET a generated lab model documentation (docx) by the `exportId` of its finished future. */
+    async downloadModelDocumentation(exportId, projectKey) {
+        return this.client.stream(`/public/api/projects/${this.enc(projectKey)}/models/lab/documentations/${encodeURIComponent(requireNonEmpty(exportId, "exportId"))}`);
+    }
     taskPath(analysisId, mlTaskId, projectKey) {
         const analysis = encodeURIComponent(requireNonEmpty(analysisId, "analysisId"));
         const task = encodeURIComponent(requireNonEmpty(mlTaskId, "mlTaskId"));

package/dist/src/resources/mlflow-extension.d.ts

@@ -0,0 +1,73 @@
+import { BaseResource } from "./base.js";
+export type MlflowPredictionType = "REGRESSION" | "BINARY_CLASSIFICATION" | "MULTICLASS" | "OTHER";
+export interface MlflowInferenceInfo {
+    runId: string;
+    predictionType: MlflowPredictionType;
+    /** Ordered classes; required for and only allowed with classification types. */
+    classes?: string[];
+    codeEnvName?: string;
+    target?: string;
+}
+export interface MlflowDeployRunOptions {
+    runId: string;
+    savedModelId: string;
+    /** Version id; DSS overwrites an existing one. Defaults to a timestamp, as in dataikuapi. */
+    versionId?: string;
+    /** Model name, needed when the run logged several models (see `listModels`). */
+    modelName?: string;
+    /** Evaluation dataset; without it the version is deployed but not evaluated. */
+    evaluationDataset?: string;
+    targetColumnName?: string;
+    classLabels?: string[];
+    codeEnvName?: string;
+    /** Use the run's inference info (`setRunInferenceInfo`); default true. */
+    useInferenceInfo?: boolean;
+    activate?: boolean;
+    binaryClassificationThreshold?: number;
+    useOptimalThreshold?: boolean;
+    skipExpensiveReports?: boolean;
+}
+export interface MlflowExperimentsDatasetOptions {
+    datasetName: string;
+    experimentIds?: string[];
+    viewType?: "ACTIVE_ONLY" | "DELETED_ONLY" | "ALL";
+    /** MLflow search expression. */
+    filter?: string;
+    orderBy?: string[];
+    format?: "LONG" | "JSON";
+}
+/** Body of POST set-run-inference-info, validated as dataikuapi does. */
+export declare function inferenceInfoBody(info: MlflowInferenceInfo): Record<string, string>;
+/**
+ * Query of POST deploy-run, as dataikuapi `deploy_run_model` sends it. The
+ * version id must be resolved first (`deployRun` defaults it to a timestamp).
+ */
+export declare function deployRunQuery(opts: MlflowDeployRunOptions & {
+    versionId: string;
+}, projectKey: string): URLSearchParams;
+/** Body of POST create-project-experiments-dataset with the documented defaults. */
+export declare function experimentsDatasetBody(opts: MlflowExperimentsDatasetOptions): Record<string, unknown>;
+/**
+ * DSS MLflow extension endpoints (`/api/2.0/mlflow/extension/*`): models of a
+ * run, inference info, deploying a run as a saved-model version, the
+ * experiments virtual dataset, and cleanup. Every call except `cleanDb`
+ * carries the `x-dku-mlflow-project-key` header naming the tracking project.
+ */
+export declare class MlflowExtensionResource extends BaseResource {
+    private projectHeader;
+    /** Models logged by a run (`[{runId, artifactPath}]`). */
+    listModels(runId: string, projectKey?: string): Promise<Array<Record<string, unknown>>>;
+    /** Record a run's prediction type (and classes, code env, target) for deployment and evaluation. */
+    setRunInferenceInfo(info: MlflowInferenceInfo, projectKey?: string): Promise<void>;
+    /** Deploy a run's model as a version of an existing saved model. */
+    deployRun(opts: MlflowDeployRunOptions, projectKey?: string): Promise<{
+        savedModelId: string;
+        versionId: string;
+    }>;
+    /** Create a virtual dataset exposing the project's experiment tracking data. */
+    createExperimentsDataset(opts: MlflowExperimentsDatasetOptions, projectKey?: string): Promise<void>;
+    /** Permanently delete the project's experiments and runs marked as deleted. */
+    garbageCollect(projectKey?: string): Promise<void>;
+    /** Delete all experiment tracking data (experiments, runs, metrics, ...) of a project (admin). */
+    cleanDb(projectKey?: string): Promise<void>;
+}

package/dist/src/resources/mlflow-extension.js

@@ -0,0 +1,105 @@
+import { ClientValidationError, } from "../errors.js";
+import { BaseResource, } from "./base.js";
+/** DSS hosts its MLflow tracking API next to the public API (dataikuapi `/dip/publicapi/api/2.0/mlflow`). */
+const MLFLOW_EXTENSION_PATH = "/public/api/api/2.0/mlflow/extension";
+const PREDICTION_TYPES = {
+    REGRESSION: true,
+    BINARY_CLASSIFICATION: true,
+    MULTICLASS: true,
+    OTHER: true,
+};
+/** Body of POST set-run-inference-info, validated as dataikuapi does. */
+export function inferenceInfoBody(info) {
+    if (PREDICTION_TYPES[info.predictionType] !== true) {
+        throw new ClientValidationError(`predictionType must be one of ${Object.keys(PREDICTION_TYPES).join(", ")}.`, "invalid_enum");
+    }
+    const classification = info.predictionType === "BINARY_CLASSIFICATION"
+        || info.predictionType === "MULTICLASS";
+    if (classification !== (info.classes !== undefined && info.classes.length > 0)) {
+        throw new ClientValidationError("classes are required for BINARY_CLASSIFICATION and MULTICLASS, and only allowed for them.", "validation_failed");
+    }
+    return {
+        run_id: info.runId,
+        prediction_type: info.predictionType,
+        ...(info.classes ? { classes: JSON.stringify(info.classes), } : {}),
+        ...(info.codeEnvName ? { code_env_name: info.codeEnvName, } : {}),
+        ...(info.target ? { target: info.target, } : {}),
+    };
+}
+/**
+ * Query of POST deploy-run, as dataikuapi `deploy_run_model` sends it. The
+ * version id must be resolved first (`deployRun` defaults it to a timestamp).
+ */
+export function deployRunQuery(opts, projectKey) {
+    const modelVersionInfo = {
+        ...(opts.evaluationDataset ? { gatherFeaturesFromDataset: opts.evaluationDataset, } : {}),
+        ...(opts.targetColumnName ? { targetColumnName: opts.targetColumnName, } : {}),
+        classLabels: (opts.classLabels ?? []).map((label) => ({ label, })),
+        ...(opts.codeEnvName ? { pythonCodeEnvName: opts.codeEnvName, } : {}),
+    };
+    const query = new URLSearchParams({
+        projectKey,
+        runId: opts.runId,
+        smId: opts.savedModelId,
+        versionId: opts.versionId,
+        modelVersionInfo: JSON.stringify(modelVersionInfo),
+        activate: String(opts.activate ?? true),
+        binaryClassificationThreshold: String(opts.binaryClassificationThreshold ?? 0.5),
+        useOptimalThreshold: String(opts.useOptimalThreshold ?? true),
+        skipExpensiveReports: String(opts.skipExpensiveReports ?? false),
+        useInferenceInfo: String(opts.useInferenceInfo ?? true),
+    });
+    if (opts.modelName)
+        query.set("modelName", opts.modelName);
+    return query;
+}
+/** Body of POST create-project-experiments-dataset with the documented defaults. */
+export function experimentsDatasetBody(opts) {
+    return {
+        datasetName: opts.datasetName,
+        experimentIds: opts.experimentIds ?? [],
+        viewType: opts.viewType ?? "ACTIVE_ONLY",
+        filter: opts.filter ?? "",
+        orderBy: opts.orderBy ?? [],
+        format: opts.format ?? "LONG",
+    };
+}
+/**
+ * DSS MLflow extension endpoints (`/api/2.0/mlflow/extension/*`): models of a
+ * run, inference info, deploying a run as a saved-model version, the
+ * experiments virtual dataset, and cleanup. Every call except `cleanDb`
+ * carries the `x-dku-mlflow-project-key` header naming the tracking project.
+ */
+export class MlflowExtensionResource extends BaseResource {
+    projectHeader(projectKey) {
+        return { headers: { "x-dku-mlflow-project-key": this.resolveProjectKey(projectKey), }, };
+    }
+    /** Models logged by a run (`[{runId, artifactPath}]`). */
+    async listModels(runId, projectKey) {
+        return this.client.get(`${MLFLOW_EXTENSION_PATH}/models/${encodeURIComponent(runId)}`, this.projectHeader(projectKey));
+    }
+    /** Record a run's prediction type (and classes, code env, target) for deployment and evaluation. */
+    async setRunInferenceInfo(info, projectKey) {
+        await this.client.post(`${MLFLOW_EXTENSION_PATH}/set-run-inference-info`, inferenceInfoBody(info), this.projectHeader(projectKey));
+    }
+    /** Deploy a run's model as a version of an existing saved model. */
+    async deployRun(opts, projectKey) {
+        const pk = this.resolveProjectKey(projectKey);
+        // dataikuapi defaults to a %Y_%m_%dT%H_%M_%S timestamp; version ids allow no dashes.
+        const versionId = opts.versionId ?? new Date().toISOString().slice(0, 19).replace(/[-:]/g, "_");
+        await this.client.post(`${MLFLOW_EXTENSION_PATH}/deploy-run?${deployRunQuery({ ...opts, versionId, }, pk)}`, undefined, this.projectHeader(pk));
+        return { savedModelId: opts.savedModelId, versionId, };
+    }
+    /** Create a virtual dataset exposing the project's experiment tracking data. */
+    async createExperimentsDataset(opts, projectKey) {
+        await this.client.post(`${MLFLOW_EXTENSION_PATH}/create-project-experiments-dataset`, experimentsDatasetBody(opts), this.projectHeader(projectKey));
+    }
+    /** Permanently delete the project's experiments and runs marked as deleted. */
+    async garbageCollect(projectKey) {
+        await this.client.post(`${MLFLOW_EXTENSION_PATH}/garbage-collect`, undefined, this.projectHeader(projectKey));
+    }
+    /** Delete all experiment tracking data (experiments, runs, metrics, ...) of a project (admin). */
+    async cleanDb(projectKey) {
+        await this.client.del(`${MLFLOW_EXTENSION_PATH}/clean-db/${this.enc(projectKey)}`);
+    }
+}

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

@@ -132,6 +132,12 @@ export declare class ProjectsResource extends BaseResource {
      * absent from the payload are removed from the project.
      */
     setMetadata(projectKey: string | undefined, metadata: ProjectMetadata): Promise<void>;
+    /**
+     * Push the project to a Git remote already declared in DSS (per-project Git
+     * mode): POST /actions/push-to-git-remote?remote=. The project-git family
+     * covers branches, commits, pulls, and remotes.
+     */
+    pushToGitRemote(remote: string, projectKey?: string): Promise<void>;
     /** Get project-level tags (tag name → {color?}). */
     tags(projectKey?: string): Promise<ProjectTags>;
     /**

package/dist/src/resources/projects.js

@@ -311,6 +311,14 @@ export class ProjectsResource extends BaseResource {
     async setMetadata(projectKey, metadata) {
         await this.client.putVoid(`/public/api/projects/${this.enc(projectKey)}/metadata`, metadata);
     }
+    /**
+     * Push the project to a Git remote already declared in DSS (per-project Git
+     * mode): POST /actions/push-to-git-remote?remote=. The project-git family
+     * covers branches, commits, pulls, and remotes.
+     */
+    async pushToGitRemote(remote, projectKey) {
+        await this.client.post(`/public/api/projects/${this.enc(projectKey)}/actions/push-to-git-remote?remote=${encodeURIComponent(remote)}`);
+    }
     /** Get project-level tags (tag name → {color?}). */
     async tags(projectKey) {
         const enc = this.enc(projectKey);

package/dist/src/resources/recipe-create.d.ts

@@ -0,0 +1,65 @@
+import type { RecipeCreateOptions, RecipeSchemaUpdateComputable } from "../schemas.js";
+export declare function asString(value: unknown): string | undefined;
+export declare function asStringArray(value: unknown): string[] | undefined;
+export type JoinType = "LEFT" | "INNER" | "RIGHT" | "FULL";
+export type JoinKeyPair = {
+    left: string;
+    right: string;
+};
+export declare function parseJoinKeyPairs(values: string[], optionName?: string): JoinKeyPair[];
+export declare function normalizeFuzzyDistance(value: unknown): string;
+export declare function normalizeJoinType(value: unknown): JoinType;
+export declare function recipeInputItems(recipe: Record<string, unknown>): Array<{
+    ref: string;
+    role: string;
+}>;
+/** Whether DSS can compute this recipe type's output schema (visual and SQL query recipes). */
+export declare function recipeOutputSchemaIsComputable(recipeType: string): boolean;
+/** The id DSS expects in actions/updateOutputSchema (dataikuapi RequiredSchemaUpdates.apply). */
+export declare function schemaUpdateComputableId(computable: RecipeSchemaUpdateComputable): string;
+/** A computed schema is worth writing when it has columns and differs from (or fills) the current one. */
+export declare function schemaUpdateIsPending(computable: RecipeSchemaUpdateComputable): boolean;
+/** Grouping keys, aggregates per column (DSS flag names), and the first/last ordering column. */
+export interface GroupingPayloadConfig {
+    keys: string[];
+    aggregates: Record<string, string[]>;
+    orderBy?: string;
+}
+/** Grouping configuration from create options, or undefined when none was asked for. */
+export declare function groupingPayloadConfig(opts: RecipeCreateOptions): GroupingPayloadConfig | undefined;
+/**
+ * Apply grouping keys and aggregates to the payload DSS created: `keys` lists
+ * the group columns; each aggregated column's `values[]` entry gets its
+ * aggregate flags (and `orderColumn` for first/last).
+ */
+export declare function applyGroupingPayload(payload: Record<string, unknown>, config: GroupingPayloadConfig): Record<string, unknown>;
+/**
+ * Prepare (shaker) steps from create options, in a fixed order: rename,
+ * fill empty, formula column, row filter, drop columns, keep columns. Later
+ * steps see renamed columns. Empty when no prepare option was given.
+ */
+export declare function prepareSteps(opts: RecipeCreateOptions): Record<string, unknown>[];
+/**
+ * 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;
+    grouping: GroupingPayloadConfig | undefined;
+    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;
+    prepareSteps: Record<string, unknown>[];
+    rawConnection: string | undefined;
+    recipePrototype: Record<string, unknown>;
+    temporaryOutputDataset: string | undefined;
+    type: string;
+};