dataiku-sdk 1.0.0 → 1.1.0

package/dist/src/cli/version.js

@@ -1,4 +1,4 @@
-import { readFileSync, } from "node:fs";
+import { readdirSync, readFileSync, statSync, } from "node:fs";
 import { dirname, resolve, } from "node:path";
 import { fileURLToPath, } from "node:url";
 export function findPackageRoot() {
@@ -36,22 +36,174 @@ export function gitDirectory(packageRoot) {
     }
     return resolve(packageRoot, ".git");
 }
+/**
+ * A full lowercase hexadecimal revision is the only provenance claim trusted.
+ * Git is never invoked from runtime version reporting; revisions are resolved
+ * directly from the filesystem layouts Git documents.
+ */
+const FULL_REVISION_PATTERN = /^[0-9a-f]{40}$/;
+export function isFullRevision(value) {
+    return typeof value === "string" && FULL_REVISION_PATTERN.test(value);
+}
+function readGitFile(base, relative) {
+    try {
+        return readFileSync(resolve(base, relative), "utf-8").trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+function isSafeRefName(ref) {
+    return (ref.length > 0
+        && !ref.startsWith("/")
+        && !ref.endsWith("/")
+        && !ref.includes("\\")
+        && !ref.split("/").includes(".."));
+}
+/** Resolve an entry from packed-refs; peeled `^` lines never match a ref. */
+function packedRefFile(base, ref) {
+    let contents;
+    try {
+        contents = readFileSync(resolve(base, "packed-refs"), "utf-8");
+    }
+    catch {
+        return undefined;
+    }
+    for (const line of contents.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0 || trimmed.startsWith("#") || trimmed.startsWith("^"))
+            continue;
+        const splitAt = trimmed.indexOf(" ");
+        if (splitAt <= 0)
+            continue;
+        const hash = trimmed.slice(0, splitAt);
+        if (isFullRevision(hash) && trimmed.slice(splitAt + 1).trim() === ref)
+            return hash;
+    }
+    return undefined;
+}
+/**
+ * The shared git dir behind a linked worktree or submodule checkout: the
+ * `commondir` file inside the worktree's git dir, resolved relative to that
+ * dir. Normal checkouts (no `commondir` file) share their own git dir.
+ */
+function gitCommonDirectory(gitDir) {
+    try {
+        const commondir = readFileSync(resolve(gitDir, "commondir"), "utf-8").trim();
+        return commondir.length > 0 ? resolve(gitDir, commondir) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Full checkout HEAD revision (40-lowercase-hex) — the basis for staleness
+ * comparison. Resolution follows Git's own layouts: a detached revision, then
+ * loose refs in the worktree git dir, then the shared store reached through
+ * `commondir`, then packed-refs in each. Anything that is not a full
+ * lowercase hexadecimal revision is rejected.
+ */
+export function gitFullRevision(packageRoot) {
+    if (!packageRoot)
+        return undefined;
+    const gitDir = gitDirectory(packageRoot);
+    const head = readGitFile(gitDir, "HEAD");
+    if (!head)
+        return undefined;
+    if (isFullRevision(head))
+        return head;
+    if (!head.startsWith("ref:"))
+        return undefined;
+    const ref = head.slice("ref:".length).trim();
+    if (!isSafeRefName(ref))
+        return undefined;
+    for (const base of [gitDir, gitCommonDirectory(gitDir),]) {
+        if (!base)
+            continue;
+        const loose = readGitFile(base, ref);
+        if (loose && isFullRevision(loose))
+            return loose;
+        const packed = packedRefFile(base, ref);
+        if (packed)
+            return packed;
+    }
+    return undefined;
+}
 export function gitRevision(packageRoot) {
+    const full = gitFullRevision(packageRoot);
+    return full ? full.slice(0, 7) : undefined;
+}
+export function detectLoadSource(modulePath = fileURLToPath(import.meta.url)) {
+    return modulePath.replaceAll("\\", "/").includes("/dist/") ? "dist" : "source";
+}
+export function buildMetadataRevision(packageRoot) {
     if (!packageRoot)
         return undefined;
     try {
-        const gitDir = gitDirectory(packageRoot);
-        const head = readFileSync(resolve(gitDir, "HEAD"), "utf-8").trim();
-        if (!head.startsWith("ref:"))
-            return head.slice(0, 7);
-        const ref = head.slice("ref:".length).trim();
-        const full = readFileSync(resolve(gitDir, ref), "utf-8").trim();
-        return full.slice(0, 7);
+        const metadata = JSON.parse(readFileSync(resolve(packageRoot, "dist", "build-metadata.json"), "utf-8"));
+        return typeof metadata.buildRevision === "string"
+            && isFullRevision(metadata.buildRevision)
+            ? metadata.buildRevision
+            : undefined;
     }
     catch {
         return undefined;
     }
 }
+/**
+ * Whether compiled CLI output predates any source input. The build metadata
+ * file is written after `tsc`, so its mtime is the build-completion marker.
+ * Installed packages omit `src/`; without both sides there is no drift claim.
+ */
+export function sourceTreeNewerThanBuild(packageRoot) {
+    if (!packageRoot)
+        return false;
+    try {
+        const buildMtimeMs = statSync(resolve(packageRoot, "dist", "build-metadata.json")).mtimeMs;
+        const pending = [resolve(packageRoot, "src"),];
+        while (pending.length > 0) {
+            const path = pending.pop();
+            if (!path)
+                break;
+            const stat = statSync(path);
+            if (stat.mtimeMs > buildMtimeMs)
+                return true;
+            if (!stat.isDirectory())
+                continue;
+            for (const entry of readdirSync(path, { withFileTypes: true, })) {
+                if (entry.isDirectory() || entry.isFile()) {
+                    pending.push(resolve(path, entry.name));
+                }
+            }
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+export function detectRuntime() {
+    return process.versions.bun ? "bun" : "node";
+}
+export function buildVersionPayload(input) {
+    const isDist = input.loadSource === "dist";
+    // Source execution never claims a build revision, even if the environment
+    // happens to carry one.
+    const buildRevision = isDist && input.buildRevision ? input.buildRevision : null;
+    const staleBuild = isDist
+        && ((buildRevision !== null
+            && input.checkoutFullRevision !== undefined
+            && input.checkoutFullRevision !== buildRevision)
+            || input.sourceNewerThanBuild === true);
+    return {
+        version: input.packageVersion,
+        gitRevision: input.checkoutRevision ?? null,
+        source: isDist ? "dist" : "source",
+        runtime: input.runtime,
+        buildRevision,
+        staleBuild,
+    };
+}
 export const PACKAGE_ROOT = findPackageRoot();
 export const CLI_VERSION = packageVersion(PACKAGE_ROOT);
 export const CLI_GIT_REVISION = gitRevision(PACKAGE_ROOT);
@@ -59,5 +211,19 @@ export const AGENT_CONTRACT_VERSION = 2;
 export const JSON_SCHEMA_DRAFT = "https://json-schema.org/draft/2020-12/schema";
 export const AGENT_CONTRACT_SCHEMA_ID = "https://clssck.github.io/dataiku-sdk/schemas/agent-contract-v2.json";
 export function cliVersionResult() {
-    return { version: CLI_VERSION, gitRevision: CLI_GIT_REVISION ?? null, };
+    const loadSource = process.env["DSS_LOAD_SOURCE"] ?? detectLoadSource();
+    const envBuildRevision = process.env["DSS_BUILD_REVISION"];
+    return buildVersionPayload({
+        packageVersion: CLI_VERSION,
+        checkoutRevision: CLI_GIT_REVISION,
+        checkoutFullRevision: gitFullRevision(PACKAGE_ROOT),
+        loadSource,
+        buildRevision: isFullRevision(envBuildRevision)
+            ? envBuildRevision
+            : (loadSource === "dist" ? buildMetadataRevision(PACKAGE_ROOT) : undefined),
+        sourceNewerThanBuild: loadSource === "dist"
+            ? sourceTreeNewerThanBuild(PACKAGE_ROOT)
+            : false,
+        runtime: detectRuntime(),
+    });
 }

package/dist/src/cli.js

@@ -32,19 +32,28 @@ import { canonicalDssUrl, } from "./utils/dss-url.js";
 // ---------------------------------------------------------------------------
 // Auth commands (run before client creation)
 // ---------------------------------------------------------------------------
-function findUnboundAppCleanup(entries) {
+function findUnboundLifecycleCleanup(entries) {
     for (const [index, entry,] of entries.entries()) {
         const parsed = parseArgs(entry.cleanup.argv);
         const [resource, action,] = parsed.positional;
-        if (resource !== "app" || action !== "delete-instance")
+        if (resource === "app" && action === "delete-instance") {
+            if (parsed.flags["unconfirmed-creation"] === true)
+                continue;
+            const expected = parsed.flags["expect-project-incarnation"];
+            if (typeof expected !== "string")
+                return { index, resource, action, reason: "missing", };
+            if (!/^[0-9a-f]{64}$/.test(expected))
+                return { index, resource, action, reason: "invalid", };
             continue;
-        if (parsed.flags["unconfirmed-creation"] === true)
+        }
+        if (resource === "project" && action === "delete") {
+            const expected = parsed.flags["expect-project-incarnation"];
+            if (typeof expected !== "string")
+                return { index, resource, action, reason: "missing", };
+            if (!/^[0-9a-f]{64}$/.test(expected))
+                return { index, resource, action, reason: "invalid", };
             continue;
-        const expected = parsed.flags["expect-project-incarnation"];
-        if (typeof expected !== "string")
-            return { index, reason: "missing", };
-        if (!/^[0-9a-f]{64}$/.test(expected))
-            return { index, reason: "invalid", };
+        }
     }
     return undefined;
 }
@@ -119,9 +128,10 @@ async function runCleanup(flags) {
         };
     }
     // Lifecycle binding is as load-bearing as server binding. Validate the whole
-    // reversed plan before step one so a later legacy app entry cannot leave an
-    // earlier cleanup applied and then fail on project-key reuse protection.
-    const lifecycleViolation = findUnboundAppCleanup(ordered);
+    // reversed plan before step one so a later legacy app or project entry
+    // cannot leave an earlier cleanup applied and then fail on project-key
+    // reuse protection.
+    const lifecycleViolation = findUnboundLifecycleCleanup(ordered);
     if (lifecycleViolation) {
         return {
             result: {
@@ -129,8 +139,8 @@ async function runCleanup(flags) {
                 steps,
                 lifecycleError: {
                     entryIndex: lifecycleViolation.index,
-                    resource: "app",
-                    action: "delete-instance",
+                    resource: lifecycleViolation.resource,
+                    action: lifecycleViolation.action,
                     reason: lifecycleViolation.reason,
                 },
             },
@@ -147,6 +157,11 @@ async function runCleanup(flags) {
                 || !commands[resource]?.[action]) {
                 throw new UsageError(`Invalid cleanup argv: ${entry.cleanup.argv.join(" ")}`);
             }
+            if (resource === "project"
+                && action === "delete"
+                && typeof parsed.flags["expect-project-incarnation"] !== "string") {
+                throw new UsageError("Project cleanup entry is not bound to a project incarnation. Refusing deletion after possible project-key reuse.", "validation_failed", "Capture a new cleanup entry from the current CLI. Legacy entries cannot safely delete projects.");
+            }
             if (resource === "app"
                 && action === "delete-instance"
                 && parsed.flags["unconfirmed-creation"] !== true
@@ -1194,6 +1209,8 @@ const MISSING_PROJECT_KEY_ERROR_PREFIX = "projectKey is required";
 function errorExitCode(err) {
     if (err instanceof CommandResultFailure)
         return err.exitCode;
+    if (err instanceof ClientValidationError && err.code === "ambiguous_outcome")
+        return 2;
     if (err instanceof UsageError || err instanceof ClientValidationError)
         return 1;
     if (err instanceof DataikuError)
@@ -1205,6 +1222,19 @@ function errorExitCode(err) {
 function buildErrorReport(err) {
     const context = rawCommandContext();
     const exitCode = errorExitCode(err);
+    if (err instanceof ClientValidationError && err.code === "ambiguous_outcome") {
+        return {
+            type: "error",
+            ok: false,
+            error: err.message,
+            code: err.code,
+            category: "dss",
+            exitCode,
+            ...(err.hint ? { hint: err.hint, } : {}),
+            ...(err.details ? { details: err.details, } : {}),
+            ...context,
+        };
+    }
     if (err instanceof UsageError || err instanceof ClientValidationError) {
         return {
             type: "error",
@@ -1346,6 +1376,14 @@ async function main() {
         writeCommandResult(plan);
         return;
     }
+    if (actionMeta.localHandler) {
+        const result = await actionMeta.localHandler(args, flags);
+        const failureExitCode = commandFailureExitCode(result);
+        if (failureExitCode !== undefined)
+            throw new CommandResultFailure(result, failureExitCode);
+        writeCommandResult(result);
+        return;
+    }
     const { url, apiKey, projectKey, tlsRejectUnauthorized, caCertPath, } = resolveCredentials(flags);
     currentCommandContext.projectKey = projectKey;
     if (!url) {

package/dist/src/client.d.ts

@@ -45,6 +45,21 @@ export interface DataikuClientTraceEvent {
     elapsedMs?: number;
     detail?: string;
 }
+/**
+ * Selected response metadata captured alongside a public API response body.
+ * A fixed whitelist of non-sensitive headers: authorization data is never
+ * returned. Null means the header was absent.
+ */
+export interface DataikuClientResponseMeta {
+    /** `DSS-Version` — version of the DSS backend answering the request. */
+    dssVersion: string | null;
+    /** `DSS-API-Version` — version of the API server handling the request. */
+    dssApiVersion: string | null;
+    /** `Date` — origin server timestamp, when present. */
+    date: string | null;
+    /** Server-provided request id, when present. */
+    requestId: string | null;
+}
 export interface DataikuClientConfig {
     /** DSS base URL (e.g. https://dss.example.com) */
     url: string;
@@ -163,6 +178,15 @@ export declare class DataikuClient {
     getRequestTimeoutMs(): number;
     resolveProjectKey(paramValue?: string): string;
     get<T = unknown>(path: string): Promise<T>;
+    /**
+     * GET returning the parsed JSON body plus selected response metadata
+     * (documented DSS version headers, server date, request id). Authorization
+     * headers are never included.
+     */
+    getWithMetadata<T = unknown>(path: string): Promise<{
+        data: T;
+        meta: DataikuClientResponseMeta;
+    }>;
     getText(path: string): Promise<string>;
     getTextLimited(path: string, maxBytes: number): Promise<{
         text: string;
@@ -180,10 +204,13 @@ export declare class DataikuClient {
     put<T = unknown>(path: string, body: unknown): Promise<T>;
     del(path: string): Promise<void>;
     putVoid(path: string, body: unknown): Promise<void>;
-    upload(path: string, filePath: string): Promise<void>;
+    private uploadResponse;
+    upload(path: string, filePath: string, fileName?: string): Promise<void>;
+    uploadJson<T>(path: string, filePath: string, fileName?: string): Promise<T>;
     stream(path: string): Promise<Response>;
     private getHeaders;
     private getAnyHeaders;
+    private responseMeta;
     private logTrace;
     /**
      * Validate raw data against a TypeBox schema, throwing on structural mismatch.

package/dist/src/client.js

@@ -1,4 +1,5 @@
-import { readFileSync, } from "node:fs";
+import { openAsBlob, readFileSync, } from "node:fs";
+import { basename, } from "node:path";
 import { getCACertificates, } from "node:tls";
 import { Value, } from "@sinclair/typebox/value";
 import { safeParseSchema, } from "./schemas.js";
@@ -360,6 +361,19 @@ export class DataikuClient {
         });
         return this.parseJsonResponse(res);
     }
+    /**
+     * GET returning the parsed JSON body plus selected response metadata
+     * (documented DSS version headers, server date, request id). Authorization
+     * headers are never included.
+     */
+    async getWithMetadata(path) {
+        const res = await this.fetchWithRetry(`${this.baseUrl}${path}`, {
+            method: "GET",
+            headers: this.getHeaders(),
+        });
+        const data = await this.parseJsonResponse(res);
+        return { data, meta: this.responseMeta(res.headers), };
+    }
     async getText(path) {
         const res = await this.fetchWithRetry(`${this.baseUrl}${path}`, {
             method: "GET",
@@ -464,19 +478,23 @@ export class DataikuClient {
             body: JSON.stringify(body),
         });
     }
-    async upload(path, filePath) {
-        const { openAsBlob, } = await import("node:fs");
-        const { basename, } = await import("node:path");
+    async uploadResponse(path, filePath, fileName) {
         const fileBlob = await openAsBlob(filePath);
-        const fileName = basename(filePath);
         const formData = new FormData();
-        formData.append("file", fileBlob, fileName);
-        await this.fetchWithRetry(`${this.baseUrl}${path}`, {
+        formData.append("file", fileBlob, fileName ?? basename(filePath));
+        return this.fetchWithRetry(`${this.baseUrl}${path}`, {
             method: "POST",
             headers: { Authorization: `Bearer ${this.apiKey}`, },
             body: formData,
         });
     }
+    async upload(path, filePath, fileName) {
+        await this.uploadResponse(path, filePath, fileName);
+    }
+    async uploadJson(path, filePath, fileName) {
+        const response = await this.uploadResponse(path, filePath, fileName);
+        return this.parseJsonResponse(response);
+    }
     async stream(path) {
         return this.fetchWithRetry(`${this.baseUrl}${path}`, {
             method: "GET",
@@ -497,6 +515,15 @@ export class DataikuClient {
             Accept: "*/*",
         };
     }
+    responseMeta(headers) {
+        // Fixed non-sensitive whitelist. `Headers.get` is case-insensitive.
+        return {
+            dssVersion: headers.get("dss-version"),
+            dssApiVersion: headers.get("dss-api-version"),
+            date: headers.get("date"),
+            requestId: this.requestIdFromHeaders(headers) ?? null,
+        };
+    }
     logTrace(event) {
         if (this.verbose)
             this.onTrace({ type: "trace", ...event, });

package/dist/src/index.d.ts

@@ -12,7 +12,7 @@ export { type ConnectionSchemaListOptions, ConnectionsResource, type ConnectionT
 export { ContinuousActivitiesResource, } from "./resources/continuous-activities.js";
 export { DashboardsResource, } from "./resources/dashboards.js";
 export { DataQualityResource, } from "./resources/data-quality.js";
-export { type DatasetBuildValidationResult, type DatasetCloneOptions, type DatasetCloneResult, type DatasetSchemaColumnInput, DatasetsResource, } from "./resources/datasets.js";
+export { type DatasetBuildValidationResult, type DatasetCloneOptions, type DatasetCloneResult, type DatasetSchemaColumnInput, DatasetsResource, type UploadDatasetFileOptions, type UploadDatasetFileResult, type UploadedFileMetadata, } from "./resources/datasets.js";
 export { DiscussionsResource, } from "./resources/discussions.js";
 export { type FlowZoneItemInput, FlowZonesResource, } from "./resources/flow-zones.js";
 export { FoldersResource, } from "./resources/folders.js";
@@ -26,7 +26,7 @@ export * from "./resources/model-evaluation-stores.js";
 export { NotebooksResource, } from "./resources/notebooks.js";
 export * from "./resources/project-git.js";
 export { ProjectLibraryResource, } from "./resources/project-library.js";
-export { type FlowMapResult, ProjectsResource, } from "./resources/projects.js";
+export { type FlowMapResult, type ProjectImportProcessResult, type ProjectImportResult, type ProjectImportSettings, type ProjectImportUploadResult, ProjectsResource, } from "./resources/projects.js";
 export { type RecipeCloneOptions, type RecipeCloneResult, type RecipeGraphReference, type RecipeGraphValidationResult, type RecipeRunOptions, type RecipeRunOutput, type RecipeRunResult, RecipesResource, } from "./resources/recipes.js";
 export * from "./resources/saved-models.js";
 export { normalizeScenarioUpdateData, SCENARIO_CANONICAL_EDITABLE_FIELDS, type ScenarioFieldChange, type ScenarioFieldMismatch, type ScenarioScriptRunResult, ScenariosResource, type ScenarioUpdateNormalization, type ScenarioUpdatePreview, scenarioUpdatePreview, type ScenarioUpdateResult, } from "./resources/scenarios.js";
@@ -42,5 +42,6 @@ export type { SafeParseResult, } from "./schemas.js";
 export type { BuildMode, CodeEnvActionResult, CodeEnvCreateOptions, CodeEnvDetails, CodeEnvPackageList, CodeEnvSetPackagesOptions, CodeEnvSummary, CodeEnvUpdatePackagesOptions, CodeEnvUsage, CodeEnvWaitOptions, ConnectionSummary, DashboardDetails, DashboardSummary, DataQualityComputeResult, DataQualityProjectStatus, DataQualityRule, DataQualityRuleResult, DataQualityRules, DataQualityStatus, DataQualityStatusByPartition, DataQualityTimeline, DataQualityTimelineEntry, DatasetCreateOptions, DatasetDetails, DatasetSchema, DatasetSummary, FlowMapOptions, FlowZone, FlowZoneCreateOptions, FlowZoneItem, FlowZoneObjectType, FlowZonePosition, FlowZoneUpdateOptions, FolderCreateOptions, FolderDetails, FolderItem, FolderSummary, FutureState, FutureWaitResult, InsightDetails, InsightSummary, JobSummary, JobWaitResult, JupyterCell, JupyterNotebookContent, JupyterNotebookSummary, NotebookSession, ProjectDetails, ProjectGitActionResult, ProjectGitDiffResult, ProjectGitFutureResponse, ProjectGitFutureState, ProjectGitLibraries, ProjectGitLibrary, ProjectGitLogResult, ProjectGitRemote, ProjectGitStatus, ProjectGitTag, ProjectGitTags, ProjectMetadata, ProjectSummary, ProjectVariables, RecipeCreateOptions, RecipeCreateResult, RecipeDetails, RecipeSummary, ScenarioDetails, ScenarioStatus, ScenarioStepRun, ScenarioSummary, ScenarioWaitResult, SqlNotebookCell, SqlNotebookContent, SqlNotebookSummary, SqlQueryResponse, SqlQueryResult, SqlQuerySchema, WikiArticleData, WikiArticleMetadata, WikiSettings, WikiTaxonomyNode, } from "./schemas.js";
 export { deepMerge, } from "./utils/deep-merge.js";
 export { type NormalizedFlowEdge, type NormalizedFlowMap, type NormalizedFlowNode, normalizeFlowGraph, } from "./utils/flow-map.js";
+export * from "./utils/project-archive.js";
 export { sanitizeFileName, } from "./utils/sanitize.js";
 export { validateStreamColumns, } from "./resources/datasets.js";

package/dist/src/index.js

@@ -46,6 +46,7 @@ export { BuildModeSchema, CodeEnvActionResultSchema, CodeEnvCreateOptionsSchema,
 // Utilities
 export { deepMerge, } from "./utils/deep-merge.js";
 export { normalizeFlowGraph, } from "./utils/flow-map.js";
+export * from "./utils/project-archive.js";
 export { sanitizeFileName, } from "./utils/sanitize.js";
 // Stream validation
 export { validateStreamColumns, } from "./resources/datasets.js";

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

@@ -32,6 +32,25 @@ export interface DatasetCloneResult {
     created: Record<string, unknown>;
     settings: Record<string, unknown>;
 }
+export interface UploadedFileMetadata {
+    filename: string;
+    path?: string;
+    length?: number;
+    mime?: string;
+    weird?: boolean;
+    [key: string]: unknown;
+}
+export interface UploadDatasetFileOptions {
+    projectKey?: string;
+    fileName: string;
+}
+export interface UploadDatasetFileResult {
+    datasetName: string;
+    projectKey: string;
+    fileName: string;
+    bytes: number;
+    after: UploadedFileMetadata;
+}
 /**
  * Compare streamed TSV header columns against a known dataset schema.
  * Returns an array of warning strings (empty if all columns match).
@@ -49,6 +68,11 @@ export declare class DatasetsResource extends BaseResource {
     schema(datasetName: string, projectKey?: string): Promise<DatasetSchema>;
     /** Replace dataset schema columns directly through the schema endpoint. */
     updateSchema(datasetName: string, columns: DatasetSchemaColumnInput[], projectKey?: string): Promise<void>;
+    /**
+     * Get the raw dataset schema object exactly as the DSS schema endpoint
+     * returns it, without schema validation — used for deterministic comparison.
+     */
+    getSchemaObject(datasetName: string, projectKey?: string): Promise<unknown>;
     /**
      * Preview dataset rows as structured data: column names plus row arrays,
      * mirroring the sql query shape ({ columns, rows, rowCount }). Streams TSV
@@ -70,6 +94,21 @@ export declare class DatasetsResource extends BaseResource {
         }>;
         rows: string[][];
         rowCount: number;
+        truncated: boolean;
+        limit: number;
+    }>;
+    /**
+     * Count dataset rows by streaming the TSV data endpoint and stopping as soon
+     * as `expected + 1` rows have been seen, so a mismatched dataset is never
+     * fully scanned. Returns the observed count together with `exact` (false when
+     * the probe cap was reached, i.e. the count is a lower bound) and whether the
+     * count satisfies the assertion.
+     */
+    assertRowCount(datasetName: string, expected: number, projectKey?: string): Promise<{
+        expected: number;
+        count: number;
+        exact: boolean;
+        satisfied: boolean;
     }>;
     /** Get dataset metadata (tags, custom fields, checklists). */
     metadata(datasetName: string, projectKey?: string): Promise<Record<string, unknown>>;
@@ -102,6 +141,10 @@ export declare class DatasetsResource extends BaseResource {
     create(opts: DatasetCreateOptions): Promise<Record<string, unknown>>;
     /** Validate common build blockers before running a dataset build. */
     validateBuildSettings(datasetName: string, projectKey?: string): Promise<DatasetBuildValidationResult>;
+    /** List files stored by an UploadedFiles dataset. */
+    listUploadedFiles(datasetName: string, projectKey?: string): Promise<UploadedFileMetadata[]>;
+    /** Add a new file to an UploadedFiles dataset and verify its byte length. */
+    uploadDatasetFile(datasetName: string, localPath: string, opts: UploadDatasetFileOptions): Promise<UploadDatasetFileResult>;
     /** Clone dataset settings, preserving connection/storage, format, and schema fields. */
     clone(sourceName: string, targetName: string, opts?: DatasetCloneOptions): Promise<DatasetCloneResult>;
     /** Update a dataset by deep-merging a patch into the current definition. */