dataiku-sdk 3.1.0 → 3.3.0

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,

package/dist/src/resources/datasets.js

@@ -712,6 +712,104 @@ export class DatasetsResource extends BaseResource {
         const dsEnc = encodeURIComponent(datasetName);
         return this.client.get(`/public/api/projects/${this.enc(projectKey)}/datasets/${dsEnc}/metadata`);
     }
+    /**
+     * 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.
+     */
+    async updateMetadata(datasetName, metadata, projectKey) {
+        if (metadata === null || Array.isArray(metadata)) {
+            throw new ClientValidationError("metadata must be a JSON object.");
+        }
+        const dsEnc = encodeURIComponent(datasetName);
+        return this.client.put(`/public/api/projects/${this.enc(projectKey)}/datasets/${dsEnc}/metadata`, metadata);
+    }
+    /**
+     * 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.
+     */
+    async createManaged(opts, projectKey) {
+        const name = typeof opts.name === "string" ? opts.name.trim() : "";
+        if (name === "") {
+            throw new ClientValidationError("name must be a non-empty dataset name.");
+        }
+        const connection = typeof opts.connection === "string" ? opts.connection.trim() : "";
+        if (connection === "") {
+            throw new ClientValidationError("connection must be a non-empty connection name.");
+        }
+        if (opts.partitioningOptionId !== undefined && opts.copyPartitioningFrom !== undefined) {
+            throw new ClientValidationError("Pass either partitioningOptionId or copyPartitioningFrom, not both.");
+        }
+        if (opts.copyPartitioningFrom !== undefined
+            && (typeof opts.copyPartitioningFrom.ref !== "string"
+                || opts.copyPartitioningFrom.ref.trim() === "")) {
+            throw new ClientValidationError("copyPartitioningFrom.ref must be a non-empty dataset or folder name.");
+        }
+        const pk = this.resolveProjectKey(projectKey);
+        const creationSettings = { connectionId: connection, };
+        if (opts.typeOptionId !== undefined)
+            creationSettings.typeOptionId = opts.typeOptionId;
+        if (opts.formatOptionId !== undefined || opts.partitioningOptionId !== undefined
+            || opts.copyPartitioningFrom !== undefined) {
+            const specificSettings = {};
+            if (opts.formatOptionId !== undefined) {
+                specificSettings.formatOptionId = opts.formatOptionId;
+            }
+            if (opts.partitioningOptionId !== undefined) {
+                specificSettings.partitioningOptionId = opts.partitioningOptionId;
+            }
+            else if (opts.copyPartitioningFrom !== undefined) {
+                const code = opts.copyPartitioningFrom.type === "FOLDER" ? "folder" : "dataset";
+                specificSettings.partitioningOptionId = `copy:${code}:${opts.copyPartitioningFrom.ref.trim()}`;
+            }
+            creationSettings.specificSettings = specificSettings;
+        }
+        await this.client.post(`/public/api/projects/${encodeURIComponent(pk)}/datasets/managed`, { name, creationSettings, });
+        return { datasetName: name, projectKey: pk, creationSettings, };
+    }
+    /**
+     * 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.
+     */
+    async info(datasetName, projectKey) {
+        const dsEnc = encodeURIComponent(datasetName);
+        return this.client.get(`/public/api/projects/${this.enc(projectKey)}/datasets/${dsEnc}/info`);
+    }
+    /**
+     * 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).
+     */
+    async getColumnLineage(datasetName, column, opts = {}) {
+        const trimmed = typeof column === "string" ? column.trim() : "";
+        if (trimmed === "") {
+            throw new ClientValidationError("column must be a non-empty column name.");
+        }
+        const maxDatasetCount = opts.maxDatasetCount;
+        if (maxDatasetCount !== undefined
+            && (!Number.isSafeInteger(maxDatasetCount) || maxDatasetCount <= 0)) {
+            throw new ClientValidationError("maxDatasetCount must be a positive integer.");
+        }
+        const dsEnc = encodeURIComponent(datasetName);
+        const params = [`columnName=${encodeURIComponent(trimmed)}`,];
+        if (maxDatasetCount !== undefined) {
+            params.push(`maxDatasetCount=${encodeURIComponent(String(maxDatasetCount))}`);
+        }
+        return this.client.get(`/public/api/projects/${this.enc(opts?.projectKey)}/datasets/${dsEnc}/column-lineage?${params.join("&")}`);
+    }
     /**
      * 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,
@@ -746,7 +844,7 @@ export class DatasetsResource extends BaseResource {
             : undefined;
         const shouldGzip = filePath.endsWith(".gz");
         const stats = { rows: 0, truncated: false, };
-        const nodeStream = Readable.fromWeb(res.body);
+        const nodeStream = Readable.from(res.body, { objectMode: false, });
         const csvTransform = tsvToCsvTransform(limit, stats, onHeader, opts?.rawData !== true);
         fs.mkdirSync(nodePath.dirname(filePath), { recursive: true, });
         const fileOut = fs.createWriteStream(filePath);

package/dist/src/resources/folders.js

@@ -1,6 +1,7 @@
 import * as nodePath from "node:path";
 import { FolderDetailsSchema, FolderItemArraySchema, FolderSummaryArraySchema, } from "../schemas.js";
 import { deepMerge, } from "../utils/deep-merge.js";
+import { writeResponseToFile, } from "../utils/response-file.js";
 import { sanitizeFileName, } from "../utils/sanitize.js";
 import { BaseResource, } from "./base.js";
 import { resolveAdminManagedStorageConnection, } from "./connections.js";
@@ -73,7 +74,7 @@ export class FoldersResource extends BaseResource {
             throw new Error("folders.download response did not include a body");
         const dest = opts?.localPath
             ?? nodePath.resolve(process.cwd(), inferDownloadFileName(normalizedPath));
-        await Bun.write(dest, new Response(res.body), { createPath: false, });
+        await writeResponseToFile(dest, res);
         return dest;
     }
     upload(folderId, path, localPath, projectKey) {

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

@@ -5,10 +5,13 @@ export interface FutureWaitOptions {
     timeoutMs?: number;
 }
 export declare class FuturesResource extends BaseResource {
-    get(futureId: string): Promise<FutureState>;
+    get(futureId: string, opts?: {
+        timeoutMs?: number;
+    }): Promise<FutureState>;
     peek(futureId: string): Promise<FutureState>;
     state(futureId: string, opts?: {
         peek?: boolean;
+        timeoutMs?: number;
     }): Promise<FutureState>;
     abort(futureId: string): Promise<void>;
     wait(futureId: string, opts?: FutureWaitOptions): Promise<FutureWaitResult>;

package/dist/src/resources/futures.js

@@ -1,4 +1,5 @@
 import { FutureStateSchema, FutureWaitResultSchema, } from "../schemas.js";
+import { computeNextPollDelayMs, isRequestDeadlineError, } from "../utils/polling.js";
 import { BaseResource, } from "./base.js";
 const DEFAULT_POLL_INTERVAL_MS = 2_000;
 const DEFAULT_TIMEOUT_MS = 120_000;
@@ -23,8 +24,8 @@ function waitState(state) {
     return "RUNNING";
 }
 export class FuturesResource extends BaseResource {
-    async get(futureId) {
-        return this.state(futureId, { peek: false, });
+    async get(futureId, opts = {}) {
+        return this.state(futureId, { peek: false, timeoutMs: opts.timeoutMs, });
     }
     async peek(futureId) {
         return this.state(futureId, { peek: true, });
@@ -32,14 +33,18 @@ export class FuturesResource extends BaseResource {
     async state(futureId, opts = {}) {
         const params = new URLSearchParams();
         params.set("peek", String(opts.peek === true));
-        const raw = await this.client.get(`/public/api/futures/${encodeURIComponent(futureId)}?${params.toString()}`);
+        const raw = await this.client.get(`/public/api/futures/${encodeURIComponent(futureId)}?${params.toString()}`, { timeoutMs: opts.timeoutMs, });
         return this.client.safeParse(FutureStateSchema, raw, "futures.state");
     }
     async abort(futureId) {
         await this.client.del(`/public/api/futures/${encodeURIComponent(futureId)}`);
     }
     async wait(futureId, opts = {}) {
-        const baseIntervalMs = Math.max(1, opts.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
+        // Adaptive backoff is the default; an explicit pollIntervalMs is an
+        // exact contract the caller chose, so it is never adapted.
+        const explicitIntervalMs = opts.pollIntervalMs;
+        const baseIntervalMs = Math.max(1, explicitIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
+        const adaptiveEnabled = explicitIntervalMs === undefined;
         // A caller's budget is never rounded up to a whole poll interval: a 5ms
         // wait must answer in about 5ms. One state observation always happens
         // regardless, because the poll precedes the deadline check.
@@ -48,7 +53,29 @@ export class FuturesResource extends BaseResource {
         let pollCount = 0;
         while (true) {
             pollCount += 1;
-            const state = await this.get(futureId);
+            // One state observation always happens, even when the budget is
+            // already spent (the poll precedes the deadline check); only the
+            // requests issued while budget remains are bounded by the remaining
+            // time, so a stalled status endpoint can never defeat the deadline.
+            const remainingMs = timeoutMs - (Date.now() - startedAt);
+            let state;
+            try {
+                state = await this.get(futureId, remainingMs > 0 ? { timeoutMs: remainingMs, } : undefined);
+            }
+            catch (error) {
+                // The poll budget ran out mid-request: report the structured
+                // timeout instead of letting the transport deadline error escape.
+                if (!isRequestDeadlineError(error, startedAt + timeoutMs))
+                    throw error;
+                return this.client.safeParse(FutureWaitResultSchema, {
+                    futureId,
+                    state: "RUNNING",
+                    elapsedMs: Date.now() - startedAt,
+                    pollCount,
+                    success: false,
+                    timedOut: true,
+                }, "futures.wait");
+            }
             const elapsedMs = Date.now() - startedAt;
             const status = waitState(state);
             if (isFinished(state)) {
@@ -85,7 +112,12 @@ export class FuturesResource extends BaseResource {
             }
             // Only the remaining budget is slept: a longer sleep would report an
             // elapsed time the caller never authorized.
-            await sleep(Math.min(baseIntervalMs, timeoutMs - elapsedMs));
+            const nextDelayMs = computeNextPollDelayMs({
+                pollCount,
+                baseIntervalMs,
+                adaptiveEnabled,
+            });
+            await sleep(Math.min(nextDelayMs, timeoutMs - elapsedMs));
         }
     }
 }

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

@@ -0,0 +1,47 @@
+import { BaseResource } from "./base.js";
+/**
+ * A DSS group as returned by the admin Security endpoints. The documented
+ * attributes below are stable; DSS may return undocumented extra attributes
+ * (per the API docs they must not be modified on update), so they are preserved
+ * under `Record<string, unknown>` and are never stripped by this SDK.
+ */
+export interface DssGroup extends Record<string, unknown> {
+    name?: string;
+    description?: string;
+    /** Whether this group gives administrative rights on DSS. */
+    admin?: boolean;
+    sourceType?: string;
+}
+/**
+ * Body of `POST /admin/groups` (create) and the editable subset of the PUT
+ * body. DSS requires `name` on create; `admin` and `description` are optional.
+ */
+export interface GroupCreateRequest extends Record<string, unknown> {
+    name: string;
+    description?: string;
+    admin?: boolean;
+}
+export declare class GroupsResource extends BaseResource {
+    /** Retrieves the list of DSS groups (Admin required). */
+    list(): Promise<DssGroup[]>;
+    /**
+     * Retrieves a Group object describing a DSS user group, used for access
+     * control on connections and projects (Admin required).
+     */
+    get(groupName: string): Promise<DssGroup>;
+    /**
+     * Creates a group (Admin required). DSS answers with
+     * `{msg: "Created group <name>"}`; the raw server record is returned as-is.
+     */
+    create(body: GroupCreateRequest): Promise<Record<string, unknown>>;
+    /**
+     * Updates a group (Admin required). Per the docs the body MUST have been
+     * obtained from a prior GET at the same URL; undocumented attributes should
+     * be passed through unmodified. DSS answers with `{msg: "Edited group ..."}`.
+     */
+    update(groupName: string, body: DssGroup): Promise<Record<string, unknown>>;
+    /** Deletes a DSS users group (Admin required). */
+    delete(groupName: string): Promise<{
+        deleted: string;
+    }>;
+}

package/dist/src/resources/groups.js

@@ -0,0 +1,56 @@
+import { ClientValidationError, } from "../errors.js";
+import { BaseResource, requireArrayResponse, requireNonEmpty, } from "./base.js";
+function validateGroupBody(body, method) {
+    if (body === null || body === undefined || typeof body !== "object" || Array.isArray(body)) {
+        throw new ClientValidationError(`${method}: body must be a Group object.`);
+    }
+    const record = body;
+    if (record.admin !== undefined && typeof record.admin !== "boolean") {
+        throw new ClientValidationError(`${method}: admin must be a boolean.`);
+    }
+    return record;
+}
+export class GroupsResource extends BaseResource {
+    /** Retrieves the list of DSS groups (Admin required). */
+    async list() {
+        const raw = await this.client.get("/public/api/admin/groups");
+        return requireArrayResponse(raw, "groups.list");
+    }
+    /**
+     * Retrieves a Group object describing a DSS user group, used for access
+     * control on connections and projects (Admin required).
+     */
+    async get(groupName) {
+        const enc = requireNonEmpty(groupName, "groupName").trim();
+        return this.client.get(`/public/api/admin/groups/${encodeURIComponent(enc)}`);
+    }
+    /**
+     * Creates a group (Admin required). DSS answers with
+     * `{msg: "Created group <name>"}`; the raw server record is returned as-is.
+     */
+    async create(body) {
+        if (body === null || body === undefined || typeof body !== "object" || Array.isArray(body)
+            || typeof body.name !== "string"
+            || body.name.trim().length === 0) {
+            throw new ClientValidationError("groups.create: body.name is required.");
+        }
+        validateGroupBody(body, "groups.create");
+        return this.client.post("/public/api/admin/groups", body);
+    }
+    /**
+     * Updates a group (Admin required). Per the docs the body MUST have been
+     * obtained from a prior GET at the same URL; undocumented attributes should
+     * be passed through unmodified. DSS answers with `{msg: "Edited group ..."}`.
+     */
+    async update(groupName, body) {
+        const enc = requireNonEmpty(groupName, "groupName").trim();
+        const validated = validateGroupBody(body, "groups.update");
+        return this.client.put(`/public/api/admin/groups/${encodeURIComponent(enc)}`, validated);
+    }
+    /** Deletes a DSS users group (Admin required). */
+    async delete(groupName) {
+        const enc = requireNonEmpty(groupName, "groupName").trim();
+        await this.client.del(`/public/api/admin/groups/${encodeURIComponent(enc)}`);
+        return { deleted: enc, };
+    }
+}

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

@@ -1,6 +1,13 @@
 import type { BuildMode, JobSummary, JobWaitResult } from "../schemas.js";
 import { BaseResource } from "./base.js";
-export type JobBuildTargetType = "DATASET" | "MANAGED_FOLDER";
+/**
+ * Buildable target kinds. DATASET and MANAGED_FOLDER are user-selectable;
+ * MODEL_EVALUATION_STORE appears as a recipe output role and is a valid job
+ * target per the official client (recipe.run object_type_map maps
+ * COMPUTABLE_MODEL_EVALUATION_STORE to MODEL_EVALUATION_STORE before
+ * JobDefinition.with_output).
+ */
+export type JobBuildTargetType = "DATASET" | "MANAGED_FOLDER" | "MODEL_EVALUATION_STORE";
 export type JobLogFilter = "stdout" | "stderr" | "user" | "errors";
 export interface JobLogProgress {
     lastProgressLine?: string;
@@ -46,17 +53,6 @@ export interface JobBuildAndWaitOptions extends JobBuildOptions {
     logId?: string;
     summary?: boolean;
 }
-interface ComputeNextPollDelayMsOptions {
-    pollCount: number;
-    baseIntervalMs: number;
-    adaptiveEnabled: boolean;
-}
-/**
- * Compute the next poll delay.
- * When adaptive polling is enabled, the interval doubles every 3 polls,
- * capped at MAX_POLL_INTERVAL_MS (or baseIntervalMs if it's larger).
- */
-export declare function computeNextPollDelayMs({ pollCount, baseIntervalMs, adaptiveEnabled, }: ComputeNextPollDelayMsOptions): number;
 export declare function parseJobLogProgress(log: string, elapsedMs?: number): JobLogProgress | undefined;
 export declare class JobsResource extends BaseResource {
     /** List jobs in a project. */
@@ -146,4 +142,3 @@ export declare class JobsResource extends BaseResource {
     /** Request a job abort. */
     abort(jobId: string, projectKey?: string): Promise<void>;
 }
-export {};