dataiku-sdk 3.2.0 → 3.3.0

package/dist/src/resources/applications.js

@@ -4,13 +4,13 @@ import { compareStrings, stableHash, stableJson, } from "../utils/stable-hash.js
 import { BaseResource, } from "./base.js";
 /**
  * Source-verifiable app-manifest reference locations. Validation is scoped to
- * homepage tiles so identically named keys in arbitrary custom-form `config`
+ * homepage tiles so identically named keys in arbitrary custom tile `config`
  * objects are never treated as references.
  */
 export const APP_MANIFEST_REFERENCE_KEYS = {
     scenario: ["SCENARIO_RUN.scenarioId",],
-    folder: ["DOWNLOAD_FILE.folderId", "DOWNLOAD_FILE.managedFolderId",],
-    variable: ["params[].name",],
+    folder: ["DOWNLOAD_MANAGED_FOLDER_FILE.folderId",],
+    variable: ["PROJECT_VARIABLES_EDIT.params[].name",],
 };
 /**
  * The only concurrency control the public app-manifest endpoint permits. DSS
@@ -382,11 +382,13 @@ export class ApplicationsResource extends BaseResource {
     }
     /**
      * Validate source-verifiable references in app homepage tiles:
-     * SCENARIO_RUN scenario IDs, DOWNLOAD_FILE managed-folder IDs, and runtime
-     * form parameter names (which DSS maps to project variables). Arbitrary
-     * custom-form `config` objects remain opaque. The manifest is never mutated.
-     * Missing/malformed references are returned deterministically; a reference
-     * kind with no applicable tiles does not trigger its project API.
+     * SCENARIO_RUN scenario IDs, DOWNLOAD_MANAGED_FOLDER_FILE managed-folder IDs,
+     * and PROJECT_VARIABLES_EDIT parameter names (which DSS maps to project
+     * variables). Tile types outside that set, including custom tiles and their
+     * `config` objects, remain opaque and are never parsed for references. The
+     * manifest is never mutated. Missing/malformed references are returned
+     * deterministically; a reference kind with no applicable tiles does not
+     * trigger its project API.
      */
     async validateAppManifest(manifest, projectKey) {
         const pk = this.resolveProjectKey(projectKey);
@@ -416,21 +418,19 @@ export class ApplicationsResource extends BaseResource {
                         if (tile["type"] === "SCENARIO_RUN") {
                             collectReferenceValue(tile["scenarioId"], propertyPath(tilePath, "scenarioId"), "scenarioId", "scenario", references, referenceIssues);
                         }
-                        if (tile["type"] === "DOWNLOAD_FILE") {
-                            for (const key of ["folderId", "managedFolderId",]) {
-                                if (!Object.prototype.hasOwnProperty.call(tile, key))
-                                    continue;
-                                collectReferenceValue(tile[key], propertyPath(tilePath, key), key, "folder", references, referenceIssues);
-                            }
+                        if (tile["type"] === "DOWNLOAD_MANAGED_FOLDER_FILE") {
+                            collectReferenceValue(tile["folderId"], propertyPath(tilePath, "folderId"), "folderId", "folder", references, referenceIssues);
                         }
-                        const params = tile["params"];
-                        if (!Array.isArray(params))
-                            continue;
-                        for (let paramIndex = 0; paramIndex < params.length; paramIndex += 1) {
-                            const param = params[paramIndex];
-                            if (!isPlainRecord(param))
+                        if (tile["type"] === "PROJECT_VARIABLES_EDIT") {
+                            const params = tile["params"];
+                            if (!Array.isArray(params))
                                 continue;
-                            collectReferenceValue(param["name"], `${propertyPath(tilePath, "params")}[${paramIndex}]["name"]`, "name", "variable", references, referenceIssues);
+                            for (let paramIndex = 0; paramIndex < params.length; paramIndex += 1) {
+                                const param = params[paramIndex];
+                                if (!isPlainRecord(param))
+                                    continue;
+                                collectReferenceValue(param["name"], `${propertyPath(tilePath, "params")}[${paramIndex}]["name"]`, "name", "variable", references, referenceIssues);
+                            }
                         }
                     }
                 }

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

@@ -1,4 +1,8 @@
 import type { DataikuClient } from "../client.js";
+/** Never disguise an unexpected successful HTTP payload as an empty listing. */
+export declare function requireArrayResponse<T>(value: unknown, operation: string): T[];
+/** Validate identifiers without changing significant whitespace or encoding. */
+export declare function requireNonEmpty(value: unknown, name: string): string;
 export declare abstract class BaseResource {
     protected readonly client: DataikuClient;
     constructor(client: DataikuClient);

package/dist/src/resources/base.js

@@ -1,3 +1,18 @@
+import { ClientValidationError, DataikuError, } from "../errors.js";
+/** Never disguise an unexpected successful HTTP payload as an empty listing. */
+export function requireArrayResponse(value, operation) {
+    if (!Array.isArray(value)) {
+        throw new DataikuError(200, "Unexpected Response", `${operation}: DSS did not return an array.`);
+    }
+    return value;
+}
+/** Validate identifiers without changing significant whitespace or encoding. */
+export function requireNonEmpty(value, name) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new ClientValidationError(`${name} must be a non-empty string.`, "validation_failed");
+    }
+    return value;
+}
 export class BaseResource {
     client;
     constructor(client) {

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

@@ -31,10 +31,15 @@ export declare class BundlesResource extends BaseResource {
     /** List bundles exported from a project on the Design node. */
     listExported(projectKey?: string): Promise<Record<string, unknown>[]>;
     /**
-     * Create or overwrite an exported Design-node bundle. The documented
-     * optional parameters are forwarded as query parameters:
-     * `releaseNotes` when provided, and `evaluateProjectStandardsChecks`
-     * (defaults to true, matching the official client which always sends it).
+     * Create an exported Design-node bundle. The documented optional
+     * parameters are forwarded as query parameters: `releaseNotes` when
+     * provided, and `evaluateProjectStandardsChecks` (defaults to true,
+     * matching the official client which always sends it). The official
+     * client sends this PUT without a request body, and this resource
+     * mirrors that; DSS 15 additionally refuses re-exporting an existing
+     * bundle id ("Bundle <id> already exists"), so the documented
+     * "create or overwrite" claim does not hold — callers must delete the
+     * bundle first to replace it.
      */
     exportBundle(bundleId: string, projectKey?: string, options?: BundleExportOptions): Promise<void>;
     /** Delete an exported Design-node bundle. */

package/dist/src/resources/bundles.js

@@ -6,17 +6,22 @@ export class BundlesResource extends BaseResource {
         return res.bundles ?? [];
     }
     /**
-     * Create or overwrite an exported Design-node bundle. The documented
-     * optional parameters are forwarded as query parameters:
-     * `releaseNotes` when provided, and `evaluateProjectStandardsChecks`
-     * (defaults to true, matching the official client which always sends it).
+     * Create an exported Design-node bundle. The documented optional
+     * parameters are forwarded as query parameters: `releaseNotes` when
+     * provided, and `evaluateProjectStandardsChecks` (defaults to true,
+     * matching the official client which always sends it). The official
+     * client sends this PUT without a request body, and this resource
+     * mirrors that; DSS 15 additionally refuses re-exporting an existing
+     * bundle id ("Bundle <id> already exists"), so the documented
+     * "create or overwrite" claim does not hold — callers must delete the
+     * bundle first to replace it.
      */
     async exportBundle(bundleId, projectKey, options = {}) {
         const params = new URLSearchParams();
         if (options.releaseNotes !== undefined)
             params.set("releaseNotes", options.releaseNotes);
         params.set("evaluateProjectStandardsChecks", String(options.evaluateProjectStandardsChecks ?? true));
-        await this.client.putVoid(`/public/api/projects/${this.enc(projectKey)}/bundles/exported/${encodeURIComponent(bundleId)}?${params.toString()}`, {});
+        await this.client.putVoidNoBody(`/public/api/projects/${this.enc(projectKey)}/bundles/exported/${encodeURIComponent(bundleId)}?${params.toString()}`);
     }
     /** Delete an exported Design-node bundle. */
     async deleteExported(bundleId, projectKey) {

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

@@ -1,6 +1,21 @@
 import type { DataikuClient } from "../client.js";
-import type { ConnectionSummary } from "../schemas.js";
+import { type ConnectionSummary, type FutureState } from "../schemas.js";
 import { BaseResource } from "./base.js";
+/**
+ * Connection definition for admin create/update. `name` and `type` are
+ * required on create; params are connection-type specific per the docs and may
+ * carry credentials (e.g. `params.password`), which this SDK forwards verbatim
+ * over TLS and never logs.
+ */
+export interface ConnectionAdminInput extends Record<string, unknown> {
+    name?: string;
+    type?: string;
+    params?: Record<string, unknown>;
+    allowWrite?: boolean;
+    allowManagedDatasets?: boolean;
+    usableBy?: string;
+    allowedGroups?: string[];
+}
 export declare function resolveAdminManagedStorageConnection(client: DataikuClient, capability: "allowManagedDatasets" | "allowManagedFolders", preferredName?: string): Promise<string | undefined>;
 export interface ConnectionSchemaListOptions {
     connection: string;
@@ -31,4 +46,66 @@ export declare class ConnectionsResource extends BaseResource {
     }): Promise<ConnectionSummary[]>;
     schemas(opts: ConnectionSchemaListOptions): Promise<string[]>;
     tables(opts: ConnectionTableListOptions): Promise<Record<string, unknown>>;
+    /**
+     * Lists all connections on the DSS instance (Admin required). Returns the
+     * documented dictionary of connection name to Connection object. Connection
+     * params may contain credentials (e.g. `params.password`); the SDK returns
+     * the server payload faithfully, and CLI output/plan layers redact them.
+     */
+    adminList(): Promise<Record<string, Record<string, unknown>>>;
+    /** Gets one connection by name (Admin required). */
+    adminGet(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
+     * the docs. DSS answers 200 with an empty body.
+     */
+    adminCreate(body: ConnectionAdminInput): Promise<Record<string, unknown>>;
+    /**
+     * Updates a connection (Admin required). Per the docs the body MUST have
+     * been obtained from a prior GET at the same URL; `type` and `name` may not
+     * be modified and undocumented attributes should pass through unchanged.
+     * DSS answers 204 with an empty body.
+     */
+    adminUpdate(connectionName: string, body: ConnectionAdminInput): Promise<Record<string, unknown>>;
+    /**
+     * Deletes a connection (Admin required). Per the docs DSS performs no check
+     * that the connection is not in use by a dataset, so this is destructive.
+     */
+    adminDelete(connectionName: string): Promise<{
+        deleted: string;
+    }>;
+    /**
+     * Tests whether a connection is available. Routed like the official
+     * dataikuapi Python client (`DSSConnection.test()`):
+     * `GET /connections/{connectionName}/test` — a pure availability test, not
+     * a settings read. Returns an error when testing is not supported for the
+     * connection type; the result carries `connectionOK` (true when available).
+     * The REST reference documents a same-URL "Test connection" variant of
+     * `GET /admin/connections/{name}`; this route is preferred because it
+     * cannot be confused with a settings retrieval.
+     */
+    adminTest(connectionName: string): Promise<Record<string, unknown>>;
+    /**
+     * Prepares the import of selected SQL or Hive tables (WRITE_CONF required).
+     * `keys` entries carry `{connectionName, name}` plus optional
+     * `catalog`/`schema`; Hive keys use the `@virtual(hive-jdbc):...`
+     * connection-name form documented by DSS. Returns a future reference; poll
+     * with `client.futures` when the result is not inline.
+     */
+    prepareTablesImport(opts: {
+        keys: Array<Record<string, unknown>>;
+        projectKey?: string;
+    }): Promise<FutureState>;
+    /**
+     * Performs an import from table candidates (WRITE_CONF required). At least
+     * one of `sqlImportCandidates` or `hiveImportCandidates` must be supplied;
+     * shapes follow the DSS SQL/Hive import candidate objects. Returns a future
+     * reference; poll with `client.futures`.
+     */
+    executeTablesImport(opts: {
+        sqlImportCandidates?: Array<Record<string, unknown>>;
+        hiveImportCandidates?: Array<Record<string, unknown>>;
+        projectKey?: string;
+    }): Promise<FutureState>;
 }

package/dist/src/resources/connections.js

@@ -1,4 +1,6 @@
-import { BaseResource, } from "./base.js";
+import { ClientValidationError, } from "../errors.js";
+import { FutureStateSchema, } from "../schemas.js";
+import { BaseResource, requireNonEmpty, } from "./base.js";
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -9,6 +11,12 @@ function normalizeConnectionNames(value) {
         .filter((v) => typeof v === "string" && v.length > 0)
         .sort();
 }
+function validateConnectionAdminInput(body, method) {
+    if (body === null || body === undefined || typeof body !== "object" || Array.isArray(body)) {
+        throw new ClientValidationError(`${method}: body must be a Connection object.`);
+    }
+    return body;
+}
 export async function resolveAdminManagedStorageConnection(client, capability, preferredName) {
     try {
         const raw = await client.get("/public/api/admin/connections/");
@@ -156,4 +164,127 @@ export class ConnectionsResource extends BaseResource {
             params.set("schemaName", opts.schema);
         return this.client.get(`/public/api/projects/${encodeURIComponent(pk)}/datasets/tables-import/actions/list-tables?${params.toString()}`);
     }
+    /* ----------------------------------------------------------------- */
+    /*  Admin connection management (GET/POST/PUT/DELETE /admin/connections) */
+    /* ----------------------------------------------------------------- */
+    /**
+     * Lists all connections on the DSS instance (Admin required). Returns the
+     * documented dictionary of connection name to Connection object. Connection
+     * params may contain credentials (e.g. `params.password`); the SDK returns
+     * the server payload faithfully, and CLI output/plan layers redact them.
+     */
+    async adminList() {
+        const raw = await this.client.get("/public/api/admin/connections");
+        if (raw === undefined || raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+            return {};
+        }
+        return raw;
+    }
+    /** Gets one connection by name (Admin required). */
+    async adminGet(connectionName) {
+        const enc = requireNonEmpty(connectionName, "connectionName").trim();
+        return this.client.get(`/public/api/admin/connections/${encodeURIComponent(enc)}`);
+    }
+    /**
+     * Creates a connection (Admin required). Body is the Connection definition
+     * (`{name, type, params, ...}`); params are connection-type specific per
+     * the docs. DSS answers 200 with an empty body.
+     */
+    async adminCreate(body) {
+        const validated = validateConnectionAdminInput(body, "connections.adminCreate");
+        const raw = await this.client.post("/public/api/admin/connections", validated);
+        return raw !== undefined && raw !== null && typeof raw === "object" && !Array.isArray(raw)
+            ? raw
+            : {};
+    }
+    /**
+     * Updates a connection (Admin required). Per the docs the body MUST have
+     * been obtained from a prior GET at the same URL; `type` and `name` may not
+     * be modified and undocumented attributes should pass through unchanged.
+     * DSS answers 204 with an empty body.
+     */
+    async adminUpdate(connectionName, body) {
+        const enc = requireNonEmpty(connectionName, "connectionName").trim();
+        const validated = validateConnectionAdminInput(body, "connections.adminUpdate");
+        const raw = await this.client.put(`/public/api/admin/connections/${encodeURIComponent(enc)}`, validated);
+        return raw !== undefined && raw !== null && typeof raw === "object" && !Array.isArray(raw)
+            ? raw
+            : {};
+    }
+    /**
+     * Deletes a connection (Admin required). Per the docs DSS performs no check
+     * that the connection is not in use by a dataset, so this is destructive.
+     */
+    async adminDelete(connectionName) {
+        const enc = requireNonEmpty(connectionName, "connectionName").trim();
+        await this.client.del(`/public/api/admin/connections/${encodeURIComponent(enc)}`);
+        return { deleted: enc, };
+    }
+    /**
+     * Tests whether a connection is available. Routed like the official
+     * dataikuapi Python client (`DSSConnection.test()`):
+     * `GET /connections/{connectionName}/test` — a pure availability test, not
+     * a settings read. Returns an error when testing is not supported for the
+     * connection type; the result carries `connectionOK` (true when available).
+     * The REST reference documents a same-URL "Test connection" variant of
+     * `GET /admin/connections/{name}`; this route is preferred because it
+     * cannot be confused with a settings retrieval.
+     */
+    async adminTest(connectionName) {
+        const enc = requireNonEmpty(connectionName, "connectionName").trim();
+        const raw = await this.client.get(`/public/api/connections/${encodeURIComponent(enc)}/test`);
+        return raw !== undefined && raw !== null && typeof raw === "object" && !Array.isArray(raw)
+            ? raw
+            : {};
+    }
+    /* ----------------------------------------------------------------- */
+    /*  Tables import (prepare-from-keys / execute-from-candidates)      */
+    /* ----------------------------------------------------------------- */
+    /**
+     * Prepares the import of selected SQL or Hive tables (WRITE_CONF required).
+     * `keys` entries carry `{connectionName, name}` plus optional
+     * `catalog`/`schema`; Hive keys use the `@virtual(hive-jdbc):...`
+     * connection-name form documented by DSS. Returns a future reference; poll
+     * with `client.futures` when the result is not inline.
+     */
+    async prepareTablesImport(opts) {
+        if (!Array.isArray(opts?.keys) || opts.keys.length === 0
+            || opts.keys.some((k) => k === null || typeof k !== "object" || Array.isArray(k))) {
+            throw new ClientValidationError("connections.prepareTablesImport: keys must be a non-empty array of key objects.");
+        }
+        for (const key of opts.keys) {
+            const connectionName = key["connectionName"];
+            const name = key["name"];
+            if (typeof connectionName !== "string" || connectionName.trim().length === 0
+                || typeof name !== "string" || name.trim().length === 0) {
+                throw new ClientValidationError("connections.prepareTablesImport: each key must carry non-empty string connectionName and name per the DSS tables-import contract.");
+            }
+        }
+        const pk = this.resolveProjectKey(opts.projectKey);
+        const raw = await this.client.post(`/public/api/projects/${encodeURIComponent(pk)}/datasets/tables-import/actions/prepare-from-keys`, { keys: opts.keys, });
+        return this.client.safeParse(FutureStateSchema, raw, "connections.prepareTablesImport");
+    }
+    /**
+     * Performs an import from table candidates (WRITE_CONF required). At least
+     * one of `sqlImportCandidates` or `hiveImportCandidates` must be supplied;
+     * shapes follow the DSS SQL/Hive import candidate objects. Returns a future
+     * reference; poll with `client.futures`.
+     */
+    async executeTablesImport(opts) {
+        const sql = opts?.sqlImportCandidates;
+        const hive = opts?.hiveImportCandidates;
+        if ((sql !== undefined && (!Array.isArray(sql) || sql.length === 0))
+            || (hive !== undefined && (!Array.isArray(hive) || hive.length === 0))
+            || (sql === undefined && hive === undefined)) {
+            throw new ClientValidationError("connections.executeTablesImport: sqlImportCandidates or hiveImportCandidates must be a non-empty array (at least one required).");
+        }
+        const pk = this.resolveProjectKey(opts.projectKey);
+        const body = {};
+        if (sql !== undefined)
+            body.sqlImportCandidates = sql;
+        if (hive !== undefined)
+            body.hiveImportCandidates = hive;
+        const raw = await this.client.post(`/public/api/projects/${encodeURIComponent(pk)}/datasets/tables-import/actions/execute-from-candidates`, body);
+        return this.client.safeParse(FutureStateSchema, raw, "connections.executeTablesImport");
+    }
 }

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

@@ -0,0 +1,118 @@
+import { BaseResource } from "./base.js";
+/**
+ * Data collections are instance-level curated groupings of DSS objects
+ * (datasets, saved models, agents, fine-tuned models, agent tools, semantic
+ * models) shared across projects.
+ *
+ * @see https://doc.dataiku.com/dss/api/15/rest/ (Data Collections section)
+ */
+export type DataCollectionObjectReferenceType = "DATASET" | "SAVED_MODEL" | "FINE_TUNED_MODEL" | "AGENT" | "AGENT_TOOL" | "SEMANTIC_MODEL" | (string & {});
+export interface DataCollectionPermission extends Record<string, unknown> {
+    /** Name of the user this permission applies to (exclusive with group). */
+    user?: string;
+    /** Name of the group this permission applies to (exclusive with user). */
+    group?: string;
+    /** true if the permission grants administrator access. */
+    admin?: boolean;
+    /** true if the permission grants contributor access. */
+    write?: boolean;
+    /** true if the permission grants member access. */
+    read?: boolean;
+}
+export interface DataCollectionSummary extends Record<string, unknown> {
+    /** Name of the collection. */
+    displayName?: string;
+    /** Color of the collection (#RRGBB syntax). */
+    color?: string | null;
+    /** The description of the collection (markdown). */
+    description?: string | null;
+    /** List of tags of the collection. */
+    tags?: string[] | null;
+    /** Id of the collection. */
+    id?: string;
+    /** Number of objects in the collection. */
+    itemCount?: number;
+    /** Number of datasets in the collection. */
+    datasetsCount?: number;
+    /** Number of saved models in the collection, excluding agents and fine tuned models. */
+    savedModelsCount?: number;
+    /** Number of fine tuned models in the collection. */
+    fineTunedModelsCount?: number;
+    /** Number of agents in the collection. */
+    agentsCount?: number;
+    /** Number of agent tools in the collection. */
+    agentToolsCount?: number;
+    /** Number of semantic models in the collection. */
+    semanticModelsCount?: number;
+    /** Timestamp of the last collection modification. */
+    lastModifiedOn?: number;
+}
+export interface DataCollectionSettings extends Record<string, unknown> {
+    /** Id of the collection. */
+    id?: string;
+    /** Name of the collection. */
+    displayName: string;
+    /** Color of the collection (#RRGGBB syntax). */
+    color?: string | null;
+    /** The description of the collection (markdown). */
+    description?: string | null;
+    /** List of tags of the collection. */
+    tags?: string[] | null;
+    /** List of permissions of the collection (READER, CONTRIBUTOR or ADMIN). */
+    permissions?: DataCollectionPermission[] | null;
+}
+export interface DataCollectionCreateRequest extends Omit<DataCollectionSettings, "id"> {
+    /**
+     * Id of the Collection (a random id is generated if not provided).
+     * Must match the [A-Za-z0-9]{8} server-side format when provided.
+     */
+    id?: string;
+}
+/**
+ * An object inside a collection: a reference to a DSS object hosted by a
+ * project. The documented shape covers datasets; `type` accepts the other
+ * collection member kinds the instance may report.
+ */
+export interface DataCollectionObject extends Record<string, unknown> {
+    /** The type of this object (e.g. "DATASET"). */
+    type: DataCollectionObjectReferenceType;
+    /** The key of the project hosting the object. */
+    projectKey: string;
+    /** The id (name) of the object in its project. */
+    id: string;
+}
+export declare class DataCollectionsResource extends BaseResource {
+    /** List the collections on which the API key has READ privilege. */
+    list(): Promise<DataCollectionSummary[]>;
+    /**
+     * Create a collection. The creating user is added as an administrator.
+     * Requires the mayCreateDataCollections global permission. DSS returns
+     * `{ msg, id }`; the created id is surfaced to the caller.
+     */
+    create(body: DataCollectionCreateRequest): Promise<{
+        msg?: string;
+        id?: string;
+    }>;
+    /**
+     * Get the settings of a collection. Requires READ on the collection; the
+     * permissions array is omitted unless the caller is an ADMIN.
+     */
+    get(dataCollectionId: string): Promise<DataCollectionSettings>;
+    /**
+     * Update the settings of a collection. Only set a settings object obtained
+     * through {@link get}. Requires ADMIN on the collection.
+     */
+    update(dataCollectionId: string, settings: DataCollectionSettings): Promise<DataCollectionSettings>;
+    /** Permanently delete a collection. Requires ADMIN on the collection. */
+    delete(dataCollectionId: string): Promise<void>;
+    /** List the objects in a collection. Requires READ on the collection. */
+    listObjects(dataCollectionId: string): Promise<DataCollectionObject[]>;
+    /**
+     * Add an object to a collection. Requires WRITE (Contributor) on the
+     * collection, the mayPublishToDataCollections global group permission, and
+     * publishToDataCollections on the project hosting the object (if relevant).
+     */
+    addObject(dataCollectionId: string, object: DataCollectionObject): Promise<void>;
+    /** Remove a dataset from a collection. Requires WRITE on the collection. */
+    removeDataset(dataCollectionId: string, projectKey: string, datasetName: string): Promise<void>;
+}

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

@@ -0,0 +1,49 @@
+import { BaseResource, } from "./base.js";
+export class DataCollectionsResource extends BaseResource {
+    /** List the collections on which the API key has READ privilege. */
+    async list() {
+        return this.client.get("/public/api/data-collections/");
+    }
+    /**
+     * Create a collection. The creating user is added as an administrator.
+     * Requires the mayCreateDataCollections global permission. DSS returns
+     * `{ msg, id }`; the created id is surfaced to the caller.
+     */
+    async create(body) {
+        return this.client.post("/public/api/data-collections/", body);
+    }
+    /**
+     * Get the settings of a collection. Requires READ on the collection; the
+     * permissions array is omitted unless the caller is an ADMIN.
+     */
+    async get(dataCollectionId) {
+        return this.client.get(`/public/api/data-collections/${encodeURIComponent(dataCollectionId)}`);
+    }
+    /**
+     * Update the settings of a collection. Only set a settings object obtained
+     * through {@link get}. Requires ADMIN on the collection.
+     */
+    async update(dataCollectionId, settings) {
+        return this.client.put(`/public/api/data-collections/${encodeURIComponent(dataCollectionId)}`, settings);
+    }
+    /** Permanently delete a collection. Requires ADMIN on the collection. */
+    async delete(dataCollectionId) {
+        await this.client.del(`/public/api/data-collections/${encodeURIComponent(dataCollectionId)}`);
+    }
+    /** List the objects in a collection. Requires READ on the collection. */
+    async listObjects(dataCollectionId) {
+        return this.client.get(`/public/api/data-collections/${encodeURIComponent(dataCollectionId)}/objects`);
+    }
+    /**
+     * Add an object to a collection. Requires WRITE (Contributor) on the
+     * collection, the mayPublishToDataCollections global group permission, and
+     * publishToDataCollections on the project hosting the object (if relevant).
+     */
+    async addObject(dataCollectionId, object) {
+        await this.client.post(`/public/api/data-collections/${encodeURIComponent(dataCollectionId)}/objects`, object);
+    }
+    /** Remove a dataset from a collection. Requires WRITE on the collection. */
+    async removeDataset(dataCollectionId, projectKey, datasetName) {
+        await this.client.del(`/public/api/data-collections/${encodeURIComponent(dataCollectionId)}/objects/dataset/${encodeURIComponent(projectKey)}/${encodeURIComponent(datasetName)}`);
+    }
+}

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

@@ -17,6 +17,37 @@ export interface DatasetSchemaColumnInput {
     type: string;
     comment?: string;
 }
+/** Options for creating a managed dataset through the dedicated endpoint. */
+export interface DatasetManagedCreateOptions {
+    /** Name of the new dataset (unique in the project). */
+    name: string;
+    /** Connection where the dataset is stored. */
+    connection: string;
+    /** When the connection accepts several dataset types, the type to use. */
+    typeOptionId?: string;
+    /** Optional identifier of a file format option (e.g. CSV_EXCEL_GZIP, PARQUET_HIVE). */
+    formatOptionId?: string;
+    /**
+     * Partitioning option id. Use {@link DatasetManagedCreateOptions.copyPartitioningFrom}
+     * to build one from an existing dataset or folder reference.
+     */
+    partitioningOptionId?: string;
+    /**
+     * Copy partitioning from an existing dataset or folder instead of passing a
+     * raw `partitioningOptionId`. `type` defaults to `DATASET` and may be
+     * `FOLDER`.
+     */
+    copyPartitioningFrom?: {
+        ref: string;
+        type?: "DATASET" | "FOLDER";
+    };
+}
+/** Result of creating a managed dataset (the endpoint answers 204 with no body). */
+export interface DatasetManagedCreateResult {
+    datasetName: string;
+    projectKey: string;
+    creationSettings: Record<string, unknown>;
+}
 export interface DatasetCloneOptions {
     projectKey?: string;
     path?: string;
@@ -120,6 +151,44 @@ export declare class DatasetsResource extends BaseResource {
     }>;
     /** Get dataset metadata (tags, custom fields, checklists). */
     metadata(datasetName: string, projectKey?: string): Promise<Record<string, unknown>>;
+    /**
+     * Replace dataset metadata with the given object (faithful PUT per the DSS
+     * API contract: the caller GETs the metadata, edits it, and PUTs the full
+     * object back — no partial merge is applied client-side). `label`,
+     * `description`, `tags`, and `custom` are the documented writable fields;
+     * any additional server-provided metadata fields present in the object are
+     * preserved verbatim.
+     */
+    updateMetadata(datasetName: string, metadata: Record<string, unknown>, projectKey?: string): Promise<Record<string, unknown>>;
+    /**
+     * Create a managed dataset through the dedicated
+     * `POST /projects/{projectKey}/datasets/managed` endpoint. DSS handles the
+     * format/storage details: you select the name, the connection, and optional
+     * type/format/partitioning options. The endpoint answers `204` with no
+     * body; the returned settings echo what was sent.
+     */
+    createManaged(opts: DatasetManagedCreateOptions, projectKey?: string): Promise<DatasetManagedCreateResult>;
+    /**
+     * Get the full info object for a dataset (type, parameters, last build
+     * information, schema, etc.). The server returns a complex opaque object;
+     * it is surfaced without validation.
+     */
+    info(datasetName: string, projectKey?: string): Promise<Record<string, unknown>>;
+    /**
+     * Get the full column lineage (auto-computed and manual) of a column in
+     * this dataset. Relations with datasets from both local and foreign
+     * projects are included.
+     *
+     * Route per the official Python client:
+     * `GET /projects/{projectKey}/datasets/{datasetName}/column-lineage`
+     * with query `columnName` (required) and `maxDatasetCount` (optional,
+     * positive integer — the docs page renders a merged project-scoped path,
+     * but DSS's own client and route registry use this per-dataset form).
+     */
+    getColumnLineage(datasetName: string, column: string, opts?: {
+        maxDatasetCount?: number;
+        projectKey?: string;
+    }): Promise<unknown>;
     /**
      * Download dataset rows as a gzipped (or .csv) file, capped at `limit` rows
      * (default 100k). Returns the written path, the number of data rows written,