dataiku-sdk 3.6.1 → 3.8.0

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

@@ -46,6 +46,18 @@ export declare class BundlesResource extends BaseResource {
     deleteExported(bundleId: string, projectKey?: string): Promise<void>;
     /** Download an exported Design-node bundle archive. */
     downloadExportedArchive(bundleId: string, projectKey?: string): Promise<Response>;
+    /** Get an exported Design-node bundle's details (content summary, export manifest, changelog). */
+    getExported(bundleId: string, projectKey?: string): Promise<Record<string, unknown>>;
+    /**
+     * Create a project from a bundle on an Automation node (global admin):
+     * upload a local bundle zip (`filePath`) or use an archive already on the
+     * node host (`archivePath`). `projectFolderId` places the new project.
+     */
+    createProjectFromBundle(source: {
+        filePath: string;
+    } | {
+        archivePath: string;
+    }, projectFolderId?: string): Promise<Record<string, unknown> | undefined>;
     /**
      * Publish a Design-node bundle to the Project Deployer. The documented
      * optional `publishedProjectKey` parameter selects the published project
@@ -100,4 +112,26 @@ export declare class ProjectDeployerResource extends BaseResource {
     listInfras(): Promise<Record<string, unknown>[]>;
     /** Create a Project Deployer infrastructure. */
     createInfra(body: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Get a Project Deployer infrastructure (basic info, deployments). */
+    getInfra(infraId: string): Promise<Record<string, unknown>>;
+    /** Get an infrastructure's settings (permissions, automation node, remappings). */
+    getInfraSettings(infraId: string): Promise<Record<string, unknown>>;
+    /** Save infrastructure settings obtained from `getInfraSettings`, edited. */
+    saveInfraSettings(infraId: string, body: Record<string, unknown>): Promise<void>;
+    /** Delete an infrastructure no deployment uses. */
+    deleteInfra(infraId: string): Promise<void>;
+    /** List the Project Deployer stages (Development, Test, Production, ...). */
+    listStages(): Promise<Record<string, unknown>[]>;
+    /** Get a deployment's settings (infra, bundle, remappings). */
+    getDeploymentSettings(deploymentId: string): Promise<Record<string, unknown>>;
+    /** Governance status of the deployment's bundle (or `bundleId`'s): messages on whether it may deploy. */
+    getGovernanceStatus(deploymentId: string, bundleId?: string): Promise<Record<string, unknown>>;
+    /** Delete a published project no deployment uses. */
+    deleteProject(publishedProjectKey: string): Promise<void>;
+    /** Get a published project's settings (permissions, owner). */
+    getProjectSettings(publishedProjectKey: string): Promise<Record<string, unknown>>;
+    /** Save published project settings obtained from `getProjectSettings`, edited. */
+    saveProjectSettings(publishedProjectKey: string, body: Record<string, unknown>): Promise<void>;
+    /** Delete a bundle of a published project that no deployment uses. */
+    deleteBundle(publishedProjectKey: string, bundleId: string): Promise<void>;
 }

package/dist/src/resources/bundles.js

@@ -31,6 +31,28 @@ export class BundlesResource extends BaseResource {
     async downloadExportedArchive(bundleId, projectKey) {
         return this.client.stream(`/public/api/projects/${this.enc(projectKey)}/bundles/exported/${encodeURIComponent(bundleId)}/archive`);
     }
+    /** Get an exported Design-node bundle's details (content summary, export manifest, changelog). */
+    async getExported(bundleId, projectKey) {
+        return this.client.get(`/public/api/projects/${this.enc(projectKey)}/bundles/exported/${encodeURIComponent(bundleId)}`);
+    }
+    /**
+     * Create a project from a bundle on an Automation node (global admin):
+     * upload a local bundle zip (`filePath`) or use an archive already on the
+     * node host (`archivePath`). `projectFolderId` places the new project.
+     */
+    async createProjectFromBundle(source, projectFolderId) {
+        const query = new URLSearchParams();
+        if ("archivePath" in source)
+            query.set("archivePath", source.archivePath);
+        if (projectFolderId)
+            query.set("projectFolderId", projectFolderId);
+        const suffix = query.size > 0 ? `?${query}` : "";
+        if ("archivePath" in source) {
+            return this.client.post(`/public/api/projectsFromBundle/fromArchive${suffix}`);
+        }
+        await this.client.upload(`/public/api/projectsFromBundle/${suffix}`, source.filePath);
+        return undefined;
+    }
     /**
      * Publish a Design-node bundle to the Project Deployer. The documented
      * optional `publishedProjectKey` parameter selects the published project
@@ -135,4 +157,49 @@ export class ProjectDeployerResource extends BaseResource {
     async createInfra(body) {
         return this.client.post("/public/api/project-deployer/infras", body);
     }
+    /** Get a Project Deployer infrastructure (basic info, deployments). */
+    async getInfra(infraId) {
+        return this.client.get(`/public/api/project-deployer/infras/${encodeURIComponent(infraId)}`);
+    }
+    /** Get an infrastructure's settings (permissions, automation node, remappings). */
+    async getInfraSettings(infraId) {
+        return this.client.get(`/public/api/project-deployer/infras/${encodeURIComponent(infraId)}/settings`);
+    }
+    /** Save infrastructure settings obtained from `getInfraSettings`, edited. */
+    async saveInfraSettings(infraId, body) {
+        await this.client.putVoid(`/public/api/project-deployer/infras/${encodeURIComponent(infraId)}/settings`, body);
+    }
+    /** Delete an infrastructure no deployment uses. */
+    async deleteInfra(infraId) {
+        await this.client.del(`/public/api/project-deployer/infras/${encodeURIComponent(infraId)}`);
+    }
+    /** List the Project Deployer stages (Development, Test, Production, ...). */
+    async listStages() {
+        return this.client.get("/public/api/project-deployer/stages");
+    }
+    /** Get a deployment's settings (infra, bundle, remappings). */
+    async getDeploymentSettings(deploymentId) {
+        return this.client.get(`/public/api/project-deployer/deployments/${encodeURIComponent(deploymentId)}/settings`);
+    }
+    /** Governance status of the deployment's bundle (or `bundleId`'s): messages on whether it may deploy. */
+    async getGovernanceStatus(deploymentId, bundleId) {
+        const query = bundleId ? `?bundleId=${encodeURIComponent(bundleId)}` : "";
+        return this.client.get(`/public/api/project-deployer/deployments/${encodeURIComponent(deploymentId)}/governance-status${query}`);
+    }
+    /** Delete a published project no deployment uses. */
+    async deleteProject(publishedProjectKey) {
+        await this.client.del(`/public/api/project-deployer/projects/${encodeURIComponent(publishedProjectKey)}`);
+    }
+    /** Get a published project's settings (permissions, owner). */
+    async getProjectSettings(publishedProjectKey) {
+        return this.client.get(`/public/api/project-deployer/projects/${encodeURIComponent(publishedProjectKey)}/settings`);
+    }
+    /** Save published project settings obtained from `getProjectSettings`, edited. */
+    async saveProjectSettings(publishedProjectKey, body) {
+        await this.client.putVoid(`/public/api/project-deployer/projects/${encodeURIComponent(publishedProjectKey)}/settings`, body);
+    }
+    /** Delete a bundle of a published project that no deployment uses. */
+    async deleteBundle(publishedProjectKey, bundleId) {
+        await this.client.del(`/public/api/project-deployer/projects/${encodeURIComponent(publishedProjectKey)}/bundles/${encodeURIComponent(bundleId)}`);
+    }
 }

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

@@ -55,6 +55,15 @@ export declare class ConnectionsResource extends BaseResource {
     adminList(): Promise<Record<string, Record<string, unknown>>>;
     /** Gets one connection by name (Admin required). */
     adminGet(connectionName: string): Promise<Record<string, unknown>>;
+    /**
+     * Reads one connection's usage view (no admin privilege required): the
+     * non-admin Python-client route `GET /connections/{name}/info`
+     * (`DSSConnection.get_info()`). Works for every connection the key can
+     * query, where the admin definition GET answers 403 for non-admin keys.
+     * Returns `{type, params, credentialsMode, ...}` per the server payload;
+     * CLI output layers redact credential-bearing params.
+     */
+    info(connectionName: string): Promise<Record<string, unknown>>;
     /**
      * Creates a connection (Admin required). Body is the Connection definition
      * (`{name, type, params, ...}`); params are connection-type specific per

package/dist/src/resources/connections.js

@@ -185,6 +185,21 @@ export class ConnectionsResource extends BaseResource {
         const enc = requireNonEmpty(connectionName, "connectionName").trim();
         return this.client.get(`/public/api/admin/connections/${encodeURIComponent(enc)}`);
     }
+    /**
+     * Reads one connection's usage view (no admin privilege required): the
+     * non-admin Python-client route `GET /connections/{name}/info`
+     * (`DSSConnection.get_info()`). Works for every connection the key can
+     * query, where the admin definition GET answers 403 for non-admin keys.
+     * Returns `{type, params, credentialsMode, ...}` per the server payload;
+     * CLI output layers redact credential-bearing params.
+     */
+    async info(connectionName) {
+        const enc = requireNonEmpty(connectionName, "connectionName").trim();
+        const raw = await this.client.get(`/public/api/connections/${encodeURIComponent(enc)}/info`);
+        return raw !== undefined && raw !== null && typeof raw === "object" && !Array.isArray(raw)
+            ? raw
+            : {};
+    }
     /**
      * Creates a connection (Admin required). Body is the Connection definition
      * (`{name, type, params, ...}`); params are connection-type specific per

package/dist/src/resources/data-quality.d.ts

@@ -51,4 +51,24 @@ export declare class DataQualityResource extends BaseResource {
     computeRulesAndWait(datasetName: string, opts?: DataQualityComputeAndWaitOptions): Promise<FutureWaitResult>;
     projectStatus(opts?: DataQualityProjectStatusOptions): Promise<DataQualityProjectStatus>;
     projectTimeline(opts?: DataQualityProjectTimelineOptions): Promise<DataQualityTimeline>;
+    /**
+     * Current Data Quality status of every monitored project the caller can
+     * read (GET /data-quality/status), keyed by project key.
+     */
+    instanceStatus(): Promise<Record<string, unknown>>;
+    /**
+     * Last rule outcome per partition (POST /data-quality/get-partitions-status,
+     * `partitions` query parameter repeated as dataikuapi sends it). Without
+     * partitions this asks for `NP`: DSS 15 answers a parameterless call with a
+     * NullPointerException although the docs make it optional.
+     */
+    partitionsStatus(datasetName: string, opts?: DataQualityProjectOptions & {
+        partitions?: string[];
+    }): Promise<Record<string, unknown>>;
+    /**
+     * Delete rule computation history for one partition (`NP` for a
+     * non-partitioned dataset, `ALL` for every partition): DELETE
+     * /data-quality/history/{partition}.
+     */
+    deleteHistory(datasetName: string, opts?: DataQualityPartitionOptions): Promise<void>;
 }

package/dist/src/resources/data-quality.js

@@ -119,4 +119,34 @@ export class DataQualityResource extends BaseResource {
         const raw = await this.client.get(`${projectPath(pk)}/timeline${queryString(params)}`);
         return this.client.safeParse(DataQualityTimelineSchema, raw, "dataQuality.projectTimeline");
     }
+    /**
+     * Current Data Quality status of every monitored project the caller can
+     * read (GET /data-quality/status), keyed by project key.
+     */
+    async instanceStatus() {
+        return this.client.get("/public/api/data-quality/status");
+    }
+    /**
+     * Last rule outcome per partition (POST /data-quality/get-partitions-status,
+     * `partitions` query parameter repeated as dataikuapi sends it). Without
+     * partitions this asks for `NP`: DSS 15 answers a parameterless call with a
+     * NullPointerException although the docs make it optional.
+     */
+    async partitionsStatus(datasetName, opts = {}) {
+        const pk = this.resolveProjectKey(opts.projectKey);
+        const params = new URLSearchParams();
+        const partitions = opts.partitions?.length ? opts.partitions : ["NP",];
+        for (const partition of partitions)
+            params.append("partitions", partition);
+        return this.client.post(`${dataQualityPath(pk, datasetName)}/get-partitions-status${queryString(params)}`);
+    }
+    /**
+     * Delete rule computation history for one partition (`NP` for a
+     * non-partitioned dataset, `ALL` for every partition): DELETE
+     * /data-quality/history/{partition}.
+     */
+    async deleteHistory(datasetName, opts = {}) {
+        const pk = this.resolveProjectKey(opts.projectKey);
+        await this.client.del(`${dataQualityPath(pk, datasetName)}/history/${encodeURIComponent(opts.partition ?? "NP")}`);
+    }
 }

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

@@ -0,0 +1,38 @@
+/**
+ * Reject dataset types the public API can create but never populate. An
+ * editable (`Inline`) dataset keeps its rows in a DSS config file that no
+ * public endpoint writes; without it every downstream build fails.
+ */
+export declare function assertDatasetTypeCreatable(dsType: string): void;
+/**
+ * Dataset types that read from a SQL connection. These are the types DSS
+ * detects schemas for through `testAndDetectSettings/externalSQL` (the list
+ * dataikuapi's `DSSDataset.autodetect_settings` uses).
+ */
+export declare const SQL_DATASET_TYPES: readonly ["JDBC", "PostgreSQL", "MySQL", "Vertica", "Snowflake", "Redshift", "Greenplum", "Teradata", "Oracle", "SQLServer", "SAPHANA", "Netezza", "BigQuery", "Athena", "hiveserver2", "Synapse", "FabricWarehouse", "Databricks", "DatabricksLakebase"];
+export declare function isSqlDatasetType(dsType: string): boolean;
+/**
+ * Validate the SQL source options (`table`/`dbSchema`/`catalog`/`query`) of a
+ * dataset creation against its type. Shared by `dataset create`, its plan, and
+ * the SDK so every entry point rejects the same combinations.
+ */
+export declare function assertSqlDatasetSource(dsType: string, source: {
+    table?: string;
+    dbSchema?: string;
+    catalog?: string;
+    query?: string;
+}): void;
+/** Wire body for POST /datasets/; shared with `dataset create --plan` so the plan matches the request. */
+export declare function buildDatasetCreateBody(opts: {
+    projectKey: string;
+    datasetName: string;
+    connection?: string;
+    dsType: string;
+    table?: string;
+    dbSchema?: string;
+    catalog?: string;
+    query?: string;
+    formatType?: string;
+    formatParams?: Record<string, unknown>;
+    managed?: boolean;
+}): Record<string, unknown>;

package/dist/src/resources/dataset-create.js

@@ -0,0 +1,135 @@
+import { ClientValidationError, } from "../errors.js";
+/**
+ * Reject dataset types the public API can create but never populate. An
+ * editable (`Inline`) dataset keeps its rows in a DSS config file that no
+ * public endpoint writes; without it every downstream build fails.
+ */
+export function assertDatasetTypeCreatable(dsType) {
+    if (dsType.toLowerCase() !== "inline")
+        return;
+    throw new ClientValidationError("Inline (editable) datasets cannot be created here: the DSS public API cannot write their rows, and an Inline dataset without rows fails every downstream build (SourceDatasetNotReadyException). For a small static table, create an UploadedFiles dataset and upload a CSV with dss dataset upload-file, or write the rows from a python recipe into a managed dataset.", "validation_failed");
+}
+/**
+ * Dataset types that read from a SQL connection. These are the types DSS
+ * detects schemas for through `testAndDetectSettings/externalSQL` (the list
+ * dataikuapi's `DSSDataset.autodetect_settings` uses).
+ */
+export const SQL_DATASET_TYPES = [
+    "JDBC",
+    "PostgreSQL",
+    "MySQL",
+    "Vertica",
+    "Snowflake",
+    "Redshift",
+    "Greenplum",
+    "Teradata",
+    "Oracle",
+    "SQLServer",
+    "SAPHANA",
+    "Netezza",
+    "BigQuery",
+    "Athena",
+    "hiveserver2",
+    "Synapse",
+    "FabricWarehouse",
+    "Databricks",
+    "DatabricksLakebase",
+];
+export function isSqlDatasetType(dsType) {
+    const lower = dsType.toLowerCase();
+    return SQL_DATASET_TYPES.some((type) => type.toLowerCase() === lower);
+}
+/**
+ * Validate the SQL source options (`table`/`dbSchema`/`catalog`/`query`) of a
+ * dataset creation against its type. Shared by `dataset create`, its plan, and
+ * the SDK so every entry point rejects the same combinations.
+ */
+export function assertSqlDatasetSource(dsType, source) {
+    const hasTable = source.table !== undefined;
+    const hasQuery = source.query !== undefined;
+    if (hasTable && hasQuery) {
+        throw new ClientValidationError("Pass either a table or a query for a SQL dataset, not both.", "conflicting_input_sources");
+    }
+    if (!hasTable && (source.dbSchema !== undefined || source.catalog !== undefined)) {
+        throw new ClientValidationError("A schema or catalog only applies together with a table.", "validation_failed", "Add --table, or drop --schema/--catalog (a query names its own tables).");
+    }
+    if (hasTable && source.table.trim() === "") {
+        throw new ClientValidationError("table must be a non-empty table name.", "invalid_flag_value");
+    }
+    if (hasQuery && source.query.trim() === "") {
+        throw new ClientValidationError("query must be a non-empty SQL query.", "invalid_flag_value");
+    }
+    if ((hasTable || hasQuery) && !isSqlDatasetType(dsType)) {
+        throw new ClientValidationError(`A table or query only applies to SQL dataset types, not "${dsType}".`, "validation_failed", `SQL types: ${SQL_DATASET_TYPES.join(", ")}.`);
+    }
+}
+/** Wire body for POST /datasets/; shared with `dataset create --plan` so the plan matches the request. */
+export function buildDatasetCreateBody(opts) {
+    assertDatasetTypeCreatable(opts.dsType);
+    if (opts.dsType.toLowerCase() === "uploadedfiles") {
+        return {
+            projectKey: opts.projectKey,
+            name: opts.datasetName,
+            type: opts.dsType,
+            params: opts.connection ? { uploadConnection: opts.connection, } : {},
+        };
+    }
+    if (!opts.connection) {
+        throw new ClientValidationError("connection is required unless dsType is UploadedFiles.");
+    }
+    if (opts.query !== undefined) {
+        if (opts.table !== undefined) {
+            throw new ClientValidationError("Pass either a table or a query for a SQL dataset, not both.", "conflicting_input_sources");
+        }
+        if (opts.query.trim() === "") {
+            throw new ClientValidationError("query must be a non-empty SQL query.", "invalid_flag_value");
+        }
+        return {
+            projectKey: opts.projectKey,
+            name: opts.datasetName,
+            type: opts.dsType,
+            params: { connection: opts.connection, mode: "query", query: opts.query, },
+            managed: opts.managed ?? false,
+        };
+    }
+    if (opts.table) {
+        const params = {
+            connection: opts.connection,
+            mode: "table",
+            table: opts.table,
+        };
+        if (opts.dbSchema)
+            params.schema = opts.dbSchema;
+        if (opts.catalog)
+            params.catalog = opts.catalog;
+        return {
+            projectKey: opts.projectKey,
+            name: opts.datasetName,
+            type: opts.dsType,
+            params,
+            managed: opts.managed ?? false,
+        };
+    }
+    return {
+        projectKey: opts.projectKey,
+        name: opts.datasetName,
+        type: opts.dsType,
+        params: {
+            connection: opts.connection,
+            path: `/dataiku/${opts.projectKey}/${opts.datasetName}`,
+        },
+        formatType: opts.formatType ?? "csv",
+        formatParams: opts.formatParams ?? {
+            style: "excel",
+            charset: "utf8",
+            separator: "\t",
+            quoteChar: '"',
+            escapeChar: "\\",
+            dateSerializationFormat: "ISO",
+            arrayMapFormat: "json",
+            parseHeaderRow: true,
+            compress: "gz",
+        },
+        managed: opts.managed ?? true,
+    };
+}

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

@@ -1,5 +1,12 @@
 import { BaseResource } from "./base.js";
 import type { DatasetCreateOptions, DatasetDetails, DatasetSchema, DatasetSummary } from "../schemas.js";
+/** Column and partition selection for dataset data reads (POST /data body). */
+export interface DatasetDataSelection {
+    /** Only these columns, in this order. */
+    columns?: string[];
+    /** DSS partition spec, e.g. `2026-01` or `2026-01,2026-02`. */
+    partitions?: string;
+}
 export interface DatasetBuildValidationResult {
     valid: boolean;
     datasetName: string;
@@ -48,6 +55,18 @@ export interface DatasetManagedCreateResult {
     projectKey: string;
     creationSettings: Record<string, unknown>;
 }
+/** Outcome of {@link DatasetsResource.detectSqlSchema}. */
+export interface DatasetSqlSchemaDetection {
+    /** True when DSS suggested a schema and it was stored on the dataset. */
+    detected: boolean;
+    /** Stored columns (empty when detection failed). */
+    columns: Array<{
+        name: string;
+        type: string;
+    }>;
+    /** Why detection failed. */
+    error?: string;
+}
 export interface DatasetCloneOptions {
     projectKey?: string;
     path?: string;
@@ -89,19 +108,6 @@ export interface UploadDatasetFileResult {
 export declare function validateStreamColumns(headerRow: string[], expectedColumns: {
     name: string;
 }[]): string[];
-/** Wire body for POST /datasets/; shared with `dataset create --plan` so the plan matches the request. */
-export declare function buildDatasetCreateBody(opts: {
-    projectKey: string;
-    datasetName: string;
-    connection?: string;
-    dsType: string;
-    table?: string;
-    dbSchema?: string;
-    catalog?: string;
-    formatType?: string;
-    formatParams?: Record<string, unknown>;
-    managed?: boolean;
-}): Record<string, unknown>;
 export declare function buildDatasetCloneSettings(source: DatasetDetails, targetName: string, projectKey: string, opts: DatasetCloneOptions): Record<string, unknown>;
 export declare class DatasetsResource extends BaseResource {
     /** List all datasets in a project. */
@@ -112,11 +118,26 @@ 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>;
+    /**
+     * Detect the schema of a SQL dataset (table or query mode) with DSS and
+     * store it: `POST /actions/testAndDetectSettings/externalSQL` (what
+     * dataikuapi's `autodetect_settings` calls), then `PUT /schema` with the
+     * suggested schema. DSS reports connection, table, and query problems in the
+     * response body (HTTP 200), so a failed detection is returned with
+     * `detected: false` and the reason instead of thrown.
+     */
+    detectSqlSchema(datasetName: string, projectKey?: string): Promise<DatasetSqlSchemaDetection>;
     /**
      * 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>;
+    /**
+     * TSV data stream of at most `limit` rows. A column or partition selection
+     * uses the documented POST variant of the data endpoint (body `columns`,
+     * `partitions`, `format`, `sampling`); otherwise the GET endpoint.
+     */
+    private dataStream;
     /**
      * Preview dataset rows as structured data: column names plus row arrays,
      * mirroring the sql query shape ({ columns, rows, rowCount }). Streams TSV
@@ -136,7 +157,7 @@ export declare class DatasetsResource extends BaseResource {
             name: string;
         }[];
         timeoutMs?: number;
-    }): Promise<{
+    } & DatasetDataSelection): Promise<{
         columns: Array<{
             name: string;
         }>;
@@ -173,6 +194,16 @@ export declare class DatasetsResource extends BaseResource {
      * preserved verbatim.
      */
     updateMetadata(datasetName: string, metadata: Record<string, unknown>, projectKey?: string): Promise<Record<string, unknown>>;
+    /**
+     * Create or update the Hive table of an HDFS dataset so it matches the
+     * dataset schema (POST /actions/synchronizeHiveMetastore).
+     */
+    synchronizeHiveMetastore(datasetName: string, projectKey?: string): Promise<void>;
+    /**
+     * Update an HDFS dataset (path, schema, partitioning, format) from its
+     * Hive table (POST /actions/updateFromHive).
+     */
+    updateFromHive(datasetName: string, projectKey?: string): Promise<void>;
     /**
      * Create a managed dataset through the dedicated
      * `POST /projects/{projectKey}/datasets/managed` endpoint. DSS handles the
@@ -227,7 +258,7 @@ export declare class DatasetsResource extends BaseResource {
         limit?: number;
         /** Preserve exact cell bytes (no spreadsheet-safe formula neutralization), default false. */
         rawData?: boolean;
-    }): Promise<{
+    } & DatasetDataSelection): Promise<{
         path: string;
         rows: number;
         truncated: boolean;