dataiku-sdk 3.2.0 → 3.3.0

package/dist/src/cli.js

@@ -3,28 +3,26 @@ import * as fs from "node:fs/promises";
 import { homedir, } from "node:os";
 import { resolve, } from "node:path";
 import { num, unknownJsonInput, } from "./cli/coerce.js";
+import { commands, } from "./cli/commands/index.js";
 import { dataikuEnvironmentEnabled, loadEnvFile, } from "./cli/env.js";
 import { executionMode, FLAG_ALIASES, isNegativeNumberToken, parseArgs, SHORT_FLAGS, VALUE_FLAGS, } from "./cli/flags.js";
 import { cleanupLedgerEntry, } from "./cli/helpers/cleanup.js";
 import { commandFailureExitCode, CommandResultFailure, flushCliWarnings, isFailedWaitResult, planResult, projectResultFields, setOutputFieldProjection, writeCommandResult, } from "./cli/output.js";
 import { currentCommandContext, resolveCredentials, resolveLoginCredentials, } from "./cli/runtime.js";
-import { COMMANDS_RUN_HINT, missingActionError, noCommandError, requireArgs, unknownActionError, unknownResourceError, UsageError, } from "./cli/usage.js";
+import { COMMANDS_RUN_HINT, inferRequiresProject, missingActionError, noCommandError, requireArgs, RESOURCE_NAMES, unknownActionError, unknownResourceError, UsageError, } from "./cli/usage.js";
 import { cliVersionResult, } from "./cli/version.js";
 import { getCredentialsPath, } from "./config.js";
 import { canonicalStatusText, ClientValidationError, DataikuError, dataikuErrorCode, } from "./errors.js";
 import { appendCleanupLedgerEntry, findCleanupLedgerBindingViolation, preflightCleanupLedgerPath, readCleanupLedger, reserveCleanupLedgerDssUrl, } from "./utils/cleanup-ledger.js";
 import { canonicalDssUrl, } from "./utils/dss-url.js";
-let commands;
+import { sanitizeSecrets, } from "./utils/secret-sanitize.js";
 let contract;
 let commandRuntimeLoad;
-// Dispatch and error reporting initialize these bindings before synchronous validation.
+// Command definitions are resource-lazy; full contract metadata loads only
+// after a valid action is selected or explicit discovery is requested.
 function loadCommandRuntime() {
-    return commandRuntimeLoad ??= Promise.all([
-        import("./cli/commands/index.js"),
-        import("./cli/contract.js"),
-    ]).then(([commandModule, contractModule,]) => {
-        commands = commandModule.commands;
-        contract = contractModule;
+    return commandRuntimeLoad ??= import("./cli/contract.js").then((module) => {
+        contract = module;
     });
 }
 // ---------------------------------------------------------------------------
@@ -279,6 +277,8 @@ const META_COMMAND_RESOURCES = {
 };
 const commandRegistryCache = new Map();
 function cachedCommandRegistry(resource) {
+    if (!contract)
+        return undefined;
     if (!commandRegistryCache.has(resource)) {
         commandRegistryCache.set(resource, contract.buildCommandRegistry(resource)[resource]);
     }
@@ -415,11 +415,21 @@ const batchDryRunClientHandler = {
         throw new BatchDryRunValidationComplete();
     },
 };
-const batchDryRunClient = new Proxy(batchDryRunClientTarget, batchDryRunClientHandler);
+const batchDryRunResource = new Proxy(batchDryRunClientTarget, batchDryRunClientHandler);
+let batchDryRunClient;
 async function validateDryRunHandlerPreconditions(handler, args, flags) {
     const readsFromStdin = flags["stdin"] === true || flags["sql"] === "-";
     if (readsFromStdin)
         return;
+    if (!batchDryRunClient) {
+        const { DataikuClient, } = await import("./client.js");
+        batchDryRunClient = new Proxy(new DataikuClient({
+            url: "http://dry-run.invalid",
+            apiKey: "dry-run-validation",
+        }), {
+            get: (_target, property) => property === "then" ? undefined : batchDryRunResource,
+        });
+    }
     try {
         await handler(batchDryRunClient, args, flags);
     }
@@ -760,9 +770,8 @@ function batchPlan(flags) {
     });
 }
 async function runMetaCommand(resource, action, flags) {
-    if (resource !== "version")
-        await loadCommandRuntime();
     if (resource === "doctor") {
+        await loadCommandRuntime();
         if (action !== undefined && action !== "run") {
             throw unknownActionError("doctor", action, ["run",]);
         }
@@ -772,6 +781,7 @@ async function runMetaCommand(resource, action, flags) {
         return { action: "run", result, exitCode, };
     }
     if (resource === "auth") {
+        await loadCommandRuntime();
         const validActions = Object.keys(contract.AUTH_ACTIONS);
         if (!action) {
             throw missingActionError("auth", validActions, "dss auth login --url URL --api-key KEY");
@@ -787,6 +797,7 @@ async function runMetaCommand(resource, action, flags) {
         return { action, result: await authMeta.handler(flags), exitCode: 0, };
     }
     if (resource === "install-skill") {
+        await loadCommandRuntime();
         if (action !== undefined && action !== "run") {
             throw unknownActionError("install-skill", action, ["run",]);
         }
@@ -794,6 +805,7 @@ async function runMetaCommand(resource, action, flags) {
         return { action: "run", result: await runInstallSkill(flags), exitCode: 0, };
     }
     if (resource === "agent") {
+        await loadCommandRuntime();
         if (!action)
             throw missingActionError("agent", ["contract",], contract.AGENT_CONTRACT_USAGE);
         currentCommandContext.action = action;
@@ -802,6 +814,7 @@ async function runMetaCommand(resource, action, flags) {
         return { action, result: contract.buildAgentContract(), exitCode: 0, };
     }
     if (resource === "commands") {
+        await loadCommandRuntime();
         if (!action)
             throw missingActionError("commands", ["run",], contract.COMMANDS_USAGE);
         currentCommandContext.action = action;
@@ -809,24 +822,28 @@ async function runMetaCommand(resource, action, flags) {
             throw unknownActionError("commands", action, ["run",]);
         validateSupportedCommandFlags("commands", "run", flags);
         const selectors = commandRegistrySelectors(flags);
-        const registry = contract.buildCommandRegistry();
+        const outputPath = flags["output"];
+        if (selectors.length === 0 && typeof outputPath !== "string") {
+            return { action, result: contract.commandActionSummary(), exitCode: 0, };
+        }
+        const registry = selectors.length === 0 ? contract.buildCommandRegistry() : {};
         for (const selector of selectors) {
             const selectorParts = selector.split(".");
             if (selectorParts.some((part) => part.length === 0)) {
                 throw new UsageError(`Invalid --fields selector: ${selector}. Expected RESOURCE or RESOURCE.ACTION[.FIELD...].`, "usage_error", contract.COMMANDS_USAGE, { selector, });
             }
             const [selectedResource, selectedAction,] = selectorParts;
-            const resourceActions = registry[selectedResource];
+            const resourceActions = cachedCommandRegistry(selectedResource);
             if (!resourceActions)
                 throw unknownResourceError(selectedResource);
+            registry[selectedResource] = resourceActions;
             if (selectedAction && !resourceActions[selectedAction]) {
                 throw unknownActionError(selectedResource, selectedAction, Object.keys(resourceActions));
             }
         }
-        const outputPath = flags["output"];
         const selectedRegistry = selectors.length === 0
             ? registry
-            : projectResultFields(registry, selectors);
+            : projectResultFields(registry, selectors, () => Object.keys(contract.commandActionSummary()).sort());
         if (typeof outputPath === "string") {
             const exported = selectedRegistry;
             await fs.writeFile(outputPath, `${JSON.stringify(exported)}\n`, "utf-8");
@@ -834,7 +851,7 @@ async function runMetaCommand(resource, action, flags) {
         }
         return {
             action,
-            result: selectors.length === 0 ? contract.commandActionSummary(registry) : selectedRegistry,
+            result: selectedRegistry,
             exitCode: 0,
         };
     }
@@ -846,6 +863,7 @@ async function runMetaCommand(resource, action, flags) {
         return { action: "run", result: cliVersionResult(), exitCode: 0, };
     }
     if (resource === "cleanup") {
+        await loadCommandRuntime();
         if (action !== undefined && action !== "run") {
             throw unknownActionError("cleanup", action, ["run",]);
         }
@@ -857,6 +875,7 @@ async function runMetaCommand(resource, action, flags) {
         return { action: "run", result, exitCode, };
     }
     if (resource === "fixtures") {
+        await loadCommandRuntime();
         if (action !== undefined && action !== "run") {
             throw unknownActionError("fixtures", action, ["run",]);
         }
@@ -865,6 +884,7 @@ async function runMetaCommand(resource, action, flags) {
         return { action: "run", result: await runFixtures(flags), exitCode: 0, };
     }
     if (resource === "batch") {
+        await loadCommandRuntime();
         if (action !== undefined && action !== "run") {
             throw unknownActionError("batch", action, ["run",]);
         }
@@ -1181,27 +1201,12 @@ function summarizeCleanupFailures(failures) {
             : [];
     }));
 }
-function rawFlagValue(argv, flagName) {
-    const longFlag = `--${flagName}`;
-    for (let index = 0; index < argv.length; index++) {
-        const arg = argv[index];
-        if (arg === longFlag) {
-            const next = argv[index + 1];
-            return next && !next.startsWith("-") ? next : undefined;
-        }
-        if (arg.startsWith(`${longFlag}=`))
-            return arg.slice(longFlag.length + 1);
-    }
-    return undefined;
-}
-function commandIsProjectScoped(resource, action) {
-    if (!resource)
-        return false;
-    const usage = commands[resource]?.[action ?? ""]?.usage ?? "";
-    return contract.inferRequiresProject(resource, action ?? "", usage);
-}
-function rawCommandContext() {
-    const argv = process.argv.slice(2);
+/**
+ * Positional arguments scanned with the same flag grammar as `parseArgs`, so
+ * error reporting can recover the invoked resource/action without depending
+ * on the command registry being loaded.
+ */
+function rawPositionals(argv) {
     const positionals = [];
     for (let index = 0; index < argv.length; index++) {
         const arg = argv[index];
@@ -1224,6 +1229,30 @@ function rawCommandContext() {
         }
         positionals.push(arg);
     }
+    return positionals;
+}
+function rawFlagValue(argv, flagName) {
+    const longFlag = `--${flagName}`;
+    for (let index = 0; index < argv.length; index++) {
+        const arg = argv[index];
+        if (arg === longFlag) {
+            const next = argv[index + 1];
+            return next && !next.startsWith("-") ? next : undefined;
+        }
+        if (arg.startsWith(`${longFlag}=`))
+            return arg.slice(longFlag.length + 1);
+    }
+    return undefined;
+}
+function commandIsProjectScoped(resource, action) {
+    if (!resource)
+        return false;
+    const usage = commands[resource]?.[action ?? ""]?.usage ?? "";
+    return inferRequiresProject(resource, action ?? "", usage);
+}
+function rawCommandContext() {
+    const argv = process.argv.slice(2);
+    const positionals = rawPositionals(argv);
     const resource = currentCommandContext.resource ?? positionals[0];
     const action = currentCommandContext.action ?? positionals[1];
     const explicitProjectKey = rawFlagValue(argv, "project-key") ?? rawFlagValue(argv, "project");
@@ -1274,6 +1303,67 @@ function requestIdFromBody(body) {
     }
     return undefined;
 }
+/** DSS diagnostic fields, in the resource layer's read order (detailedMessage → message → errorMessage). */
+const DSS_DIAGNOSTIC_MESSAGE_FIELDS = ["detailedMessage", "message", "errorMessage",];
+const MAX_DSS_DIAGNOSTIC_LENGTH = 300;
+/**
+ * Credential material for redacting a server echo in a receipt: resolved
+ * through the same resolver every command uses (flag → env → saved), so the
+ * report path never grows a second credential-precedence convention.
+ */
+function cliSecretValues() {
+    try {
+        const { apiKey, } = resolveCredentials(parseArgs(process.argv.slice(2)).flags);
+        return apiKey ? [apiKey,] : [];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Bounded, sanitized server diagnostic preserved on an ambiguous mutation
+ * envelope (`dssMessage`/`dssErrorType`, next to the existing `dssCategory`):
+ * the DSS error text and Java error type the response body carried, so the
+ * receipt explains why the server failed while the mutation outcome stays
+ * unknown. Whitespace collapses to one line, credential material is redacted,
+ * long text truncates, and the raw body/stack never pass through.
+ */
+function dssDiagnosticDetails(err) {
+    try {
+        const parsed = JSON.parse(err.body);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return {};
+        const record = parsed;
+        let secrets;
+        const diagnostic = (value) => {
+            if (typeof value !== "string" || value.trim() === "")
+                return undefined;
+            secrets ??= cliSecretValues();
+            const sanitized = sanitizeSecrets(value.replace(/\s+/g, " ").trim(), {
+                sensitiveKeys: {},
+                secrets,
+                redactUrlUserinfo: true,
+            });
+            return sanitized.length > MAX_DSS_DIAGNOSTIC_LENGTH
+                ? `${sanitized.slice(0, MAX_DSS_DIAGNOSTIC_LENGTH)}…`
+                : sanitized;
+        };
+        let message;
+        for (const field of DSS_DIAGNOSTIC_MESSAGE_FIELDS) {
+            message = diagnostic(record[field]);
+            if (message !== undefined)
+                break;
+        }
+        const errorType = diagnostic(record["errorType"]);
+        return {
+            ...(message !== undefined ? { dssMessage: message, } : {}),
+            ...(errorType !== undefined ? { dssErrorType: errorType, } : {}),
+        };
+    }
+    catch {
+        return {};
+    }
+}
 const MISSING_PROJECT_KEY_ERROR_PREFIX = "projectKey is required";
 function isAmbiguousMutationFailure(err, context) {
     if (!(err instanceof DataikuError))
@@ -1384,6 +1474,8 @@ function buildErrorReport(err) {
             requestId: err.requestId ?? requestIdFromBody(err.body),
             details: {
                 dssCategory: err.category,
+                ...(err.bodyTruncated ? { bodyTruncated: true, } : {}),
+                ...dssDiagnosticDetails(err),
                 statusText: canonicalStatusText(err.status),
                 idempotency: "none",
                 ...(err.retry ? { retry: err.retry, } : {}),
@@ -1417,6 +1509,7 @@ function buildErrorReport(err) {
             requestId: err.requestId ?? requestIdFromBody(err.body),
             details: {
                 dssCategory: err.category,
+                ...(err.bodyTruncated ? { bodyTruncated: true, } : {}),
                 statusText: canonicalStatusText(err.status),
                 body: safeBody,
                 ...(err.retry ? { retry: err.retry, } : {}),
@@ -1451,6 +1544,14 @@ function writeErrorReport(err) {
     flushCliWarnings();
     process.stdout.write(`${JSON.stringify(buildErrorReport(err))}\n`);
 }
+/** Only ambiguous mutation failures require full contract metadata. */
+function errorReportNeedsCommandRuntime(err) {
+    if (contract || !(err instanceof DataikuError))
+        return false;
+    const method = err.retry?.method.toUpperCase();
+    return !!method && method !== "GET" && method !== "HEAD"
+        && (err.status === 0 || err.status >= 500);
+}
 // ---------------------------------------------------------------------------
 // Main
 // ---------------------------------------------------------------------------
@@ -1489,7 +1590,8 @@ async function main() {
             process.exitCode = metaCommand.exitCode;
         return;
     }
-    if (!commands[resource])
+    // Resource and action recovery require only this resource's definitions.
+    if (!RESOURCE_NAMES.includes(resource))
         throw unknownResourceError(resource);
     const resourceActions = commands[resource];
     if (positional.length === 1) {
@@ -1500,8 +1602,12 @@ async function main() {
     const actionMeta = resourceActions[action];
     if (!actionMeta)
         throw unknownActionError(resource, action, Object.keys(resourceActions));
+    await loadCommandRuntime();
     validateSupportedCommandFlags(resource, action, flags);
     const args = positional.slice(2);
+    // Command-local validation runs for live, --plan, and --dry-run alike, so a
+    // bad identifier is a usage error before any plan is built or request made.
+    actionMeta.validate?.(args, flags);
     if (executionMode(flags).plan) {
         const plan = contract.buildMutationPlan(resource, action, actionMeta, args, flags);
         writeCommandResult(plan);
@@ -1515,7 +1621,6 @@ async function main() {
         writeCommandResult(result);
         return;
     }
-    actionMeta.validate?.(args, flags);
     const { url, apiKey, projectKey, tlsRejectUnauthorized, caCertPath, } = resolveCredentials(flags);
     currentCommandContext.projectKey = projectKey;
     if (!url) {
@@ -1547,7 +1652,8 @@ async function main() {
     writeCommandResult(result);
 }
 main().catch(async (err) => {
-    await loadCommandRuntime();
+    if (errorReportNeedsCommandRuntime(err))
+        await loadCommandRuntime();
     writeErrorReport(err);
     process.exitCode = errorExitCode(err);
 });

package/dist/src/client.d.ts

@@ -8,19 +8,26 @@ import { CodeEnvsResource } from "./resources/code-envs.js";
 import { ConnectionsResource } from "./resources/connections.js";
 import { ContinuousActivitiesResource } from "./resources/continuous-activities.js";
 import { DashboardsResource } from "./resources/dashboards.js";
+import { DataCollectionsResource } from "./resources/data-collections.js";
 import { DataQualityResource } from "./resources/data-quality.js";
 import { DatasetsResource } from "./resources/datasets.js";
 import { DiscussionsResource } from "./resources/discussions.js";
 import { FlowZonesResource } from "./resources/flow-zones.js";
 import { FoldersResource } from "./resources/folders.js";
 import { FuturesResource } from "./resources/futures.js";
+import { GroupsResource } from "./resources/groups.js";
 import { InsightsResource } from "./resources/insights.js";
 import { JobsResource } from "./resources/jobs.js";
+import { KnowledgeBanksResource } from "./resources/knowledge-banks.js";
+import { LlmsResource } from "./resources/llms.js";
+import { MacrosResource } from "./resources/macros.js";
 import { MeaningsResource } from "./resources/meanings.js";
 import { MetricsResource } from "./resources/metrics.js";
 import { MlTasksResource } from "./resources/ml-tasks.js";
 import { ModelEvaluationStoresResource } from "./resources/model-evaluation-stores.js";
 import { NotebooksResource } from "./resources/notebooks.js";
+import { PluginsResource } from "./resources/plugins.js";
+import { ProjectFoldersResource } from "./resources/project-folders.js";
 import { ProjectGitResource } from "./resources/project-git.js";
 import { ProjectLibraryResource } from "./resources/project-library.js";
 import { ProjectsResource } from "./resources/projects.js";
@@ -30,10 +37,43 @@ import { ScenariosResource } from "./resources/scenarios.js";
 import { SqlResource } from "./resources/sql.js";
 import { StatisticsResource } from "./resources/statistics.js";
 import { StreamingEndpointsResource } from "./resources/streaming-endpoints.js";
+import { UsersResource } from "./resources/users.js";
 import { VariablesResource } from "./resources/variables.js";
 import { WebappsResource } from "./resources/webapps.js";
 import { WikiResource } from "./resources/wiki.js";
 import { WorkspacesResource } from "./resources/workspaces.js";
+/** One part of a {@link DataikuClient.uploadForm} multipart/form-data body. */
+export interface UploadFormPart {
+    /** Form field name. */
+    name: string;
+    /** Text field value. Mutually exclusive with `blob`/`fileName` file parts. */
+    value?: string;
+    /** File content. Omit (or null) together with `fileName` for a zero-byte file part. */
+    blob?: Blob | null;
+    /** Filename for file parts. */
+    fileName?: string;
+}
+/**
+ * Multipart part modes for {@link DataikuClient.uploadForm}:
+ * - `value`: a form text field;
+ * - neither `blob` nor `fileName`: a filename-less, zero-length field part —
+ *   the official Python client's files={"file": (None, None)} shape required
+ *   by the managed-folder MLflow import (a Blob would add `filename=`, even
+ *   when empty);
+ * - `blob` (optionally with `fileName`): a file part.
+ */
+/** Per-call overrides for {@link DataikuClient.get}. */
+export interface DataikuGetOptions {
+    /**
+     * TOTAL duration budget in milliseconds for this call, measured from call
+     * start: it bounds every retry attempt's fetch, the backoff sleeps between
+     * attempts, and the response body read. When the budget is exhausted the
+     * request is aborted and a timeout DataikuError is thrown. The client-level
+     * requestTimeoutMs still caps each attempt and buffered body read; this
+     * budget may shorten those limits but never extends them.
+     */
+    timeoutMs?: number;
+}
 export interface DataikuClientTraceEvent {
     type: "trace";
     phase: "request" | "response" | "error";
@@ -72,9 +112,9 @@ export interface DataikuClientConfig {
     /** Max retry attempts for idempotent requests (default 4, capped at 10) */
     retryMaxAttempts?: number;
     /**
-     * Maximum bytes buffered from a single response body by the text/JSON
-     * consumer methods (default 50 MiB). Responses larger than this are
-     * rejected with a DataikuError after the stream is cancelled.
+     * Maximum bytes retained from a single response body by text/JSON consumers
+     * (default 50 MiB). Oversized successful responses are rejected. Error
+     * responses retain a bounded prefix with DataikuError.bodyTruncated=true.
      */
     maxResponseBodyBytes?: number;
     /** Emit HTTP request/response trace events. Defaults to JSONL on stderr when verbose is true. */
@@ -139,6 +179,14 @@ export declare class DataikuClient {
     private mlTasksResource?;
     private savedModelsResource?;
     private modelEvaluationStoresResource?;
+    private projectFoldersResource?;
+    private dataCollectionsResource?;
+    private llmsResource?;
+    private knowledgeBanksResource?;
+    private macrosResource?;
+    private pluginsResource?;
+    private usersResource?;
+    private groupsResource?;
     get projects(): ProjectsResource;
     get datasets(): DatasetsResource;
     get dashboards(): DashboardsResource;
@@ -175,6 +223,14 @@ export declare class DataikuClient {
     get mlTasks(): MlTasksResource;
     get savedModels(): SavedModelsResource;
     get modelEvaluationStores(): ModelEvaluationStoresResource;
+    get projectFolders(): ProjectFoldersResource;
+    get dataCollections(): DataCollectionsResource;
+    get llms(): LlmsResource;
+    get knowledgeBanks(): KnowledgeBanksResource;
+    get macros(): MacrosResource;
+    get plugins(): PluginsResource;
+    get users(): UsersResource;
+    get groups(): GroupsResource;
     constructor(config?: DataikuClientConfig);
     /**
      * Canonical request base URL: the exact prefix every HTTP verb concatenates
@@ -189,7 +245,7 @@ export declare class DataikuClient {
      */
     getMaxResponseBodyBytes(): number;
     resolveProjectKey(paramValue?: string): string;
-    get<T = unknown>(path: string): Promise<T>;
+    get<T = unknown>(path: string, options?: DataikuGetOptions): Promise<T>;
     /**
      * GET returning the parsed JSON body plus selected response metadata
      * (documented DSS version headers, server date, request id). Authorization
@@ -239,10 +295,32 @@ export declare class DataikuClient {
      * {@link getText} (byte cap `maxResponseBodyBytes`, request deadline).
      */
     postText(path: string, body?: unknown): Promise<string>;
+    /** Send raw file contents through the shared authenticated transport. */
+    postRawBody(path: string, body: string | Uint8Array): Promise<void>;
+    /** Git endpoints require Basic API-key authentication, unlike the bearer API. */
+    requestGit(method: string, path: string, body?: unknown, deadlineAt?: number): Promise<Response>;
     postStream(path: string, body?: unknown): Promise<Response>;
     put<T = unknown>(path: string, body: unknown): Promise<T>;
     del(path: string): Promise<void>;
     putVoid(path: string, body: unknown): Promise<void>;
+    /**
+     * PUT without a request body. A few DSS endpoints (bundle export) reject
+     * an empty JSON object body with 400 validation, and the official Python
+     * client sends no body at all for them.
+     */
+    putVoidNoBody(path: string): Promise<void>;
+    /**
+     * POST a multipart/form-data body built from explicit parts, with optional
+     * query parameters appended to the path, returning the parsed JSON body.
+     *
+     * A part with `value` becomes a form text field; a part with `blob`
+     * (or a `fileName` with no blob) becomes a file part — a `fileName` without
+     * blob yields a zero-byte file part, which some DSS import endpoints
+     * (e.g. saved-model MLflow version import) require for metadata-only parts.
+     * The `Content-Type` header is left to the runtime so the multipart
+     * boundary is set correctly.
+     */
+    uploadForm<T = unknown>(path: string, parts: UploadFormPart[], query?: URLSearchParams): Promise<T>;
     private uploadResponse;
     upload(path: string, filePath: string, fileName?: string): Promise<void>;
     uploadJson<T>(path: string, filePath: string, fileName?: string): Promise<T>;
@@ -271,7 +349,7 @@ export declare class DataikuClient {
     private requestIdFromHeaders;
     private parseJsonResponse;
     /**
-     * Read at most `maxBytes` of a 2xx response body as UTF-8 text.
+     * Read at most `maxBytes` of a response body as UTF-8 text.
      *
      * The body is consumed with the request deadline still active (measured
      * from the first read): a stalled body throws a DataikuError instead of