dataiku-sdk 0.4.0 → 0.5.1

package/dist/src/client.d.ts

@@ -1,8 +1,13 @@
 import { type Static, type TSchema } from "@sinclair/typebox";
 import { CodeEnvsResource } from "./resources/code-envs.js";
 import { ConnectionsResource } from "./resources/connections.js";
+import { DashboardsResource } from "./resources/dashboards.js";
+import { DataQualityResource } from "./resources/data-quality.js";
 import { DatasetsResource } from "./resources/datasets.js";
+import { FlowZonesResource } from "./resources/flow-zones.js";
 import { FoldersResource } from "./resources/folders.js";
+import { FuturesResource } from "./resources/futures.js";
+import { InsightsResource } from "./resources/insights.js";
 import { JobsResource } from "./resources/jobs.js";
 import { NotebooksResource } from "./resources/notebooks.js";
 import { ProjectsResource } from "./resources/projects.js";
@@ -10,6 +15,7 @@ import { RecipesResource } from "./resources/recipes.js";
 import { ScenariosResource } from "./resources/scenarios.js";
 import { SqlResource } from "./resources/sql.js";
 import { VariablesResource } from "./resources/variables.js";
+import { WikiResource } from "./resources/wiki.js";
 export interface DataikuClientConfig {
     /** DSS base URL (e.g. https://dss.example.com) */
     url: string;
@@ -47,25 +53,37 @@ export declare class DataikuClient {
     private _projects?;
     private _datasets?;
     private _recipes?;
+    private _dashboards?;
+    private _dataQuality?;
     private _jobs?;
+    private futuresResource?;
     private _scenarios?;
     private _folders?;
+    private _flowZones?;
     private _variables?;
     private _connections?;
     private _codeEnvs?;
+    private _insights?;
     private _sql?;
     private _notebooks?;
+    private _wiki?;
     get projects(): ProjectsResource;
     get datasets(): DatasetsResource;
+    get dashboards(): DashboardsResource;
+    get dataQuality(): DataQualityResource;
     get recipes(): RecipesResource;
     get jobs(): JobsResource;
+    get futures(): FuturesResource;
     get scenarios(): ScenariosResource;
     get folders(): FoldersResource;
+    get flowZones(): FlowZonesResource;
     get variables(): VariablesResource;
     get connections(): ConnectionsResource;
     get codeEnvs(): CodeEnvsResource;
+    get insights(): InsightsResource;
     get sql(): SqlResource;
     get notebooks(): NotebooksResource;
+    get wiki(): WikiResource;
     constructor(config: DataikuClientConfig);
     getRequestTimeoutMs(): number;
     resolveProjectKey(paramValue?: string): string;

package/dist/src/client.js

@@ -5,8 +5,13 @@ import { safeParseSchema, } from "./schemas.js";
 import { classifyDataikuError, DataikuError, } from "./errors.js";
 import { CodeEnvsResource, } from "./resources/code-envs.js";
 import { ConnectionsResource, } from "./resources/connections.js";
+import { DashboardsResource, } from "./resources/dashboards.js";
+import { DataQualityResource, } from "./resources/data-quality.js";
 import { DatasetsResource, } from "./resources/datasets.js";
+import { FlowZonesResource, } from "./resources/flow-zones.js";
 import { FoldersResource, } from "./resources/folders.js";
+import { FuturesResource, } from "./resources/futures.js";
+import { InsightsResource, } from "./resources/insights.js";
 import { JobsResource, } from "./resources/jobs.js";
 import { NotebooksResource, } from "./resources/notebooks.js";
 import { ProjectsResource, } from "./resources/projects.js";
@@ -14,6 +19,7 @@ import { RecipesResource, } from "./resources/recipes.js";
 import { ScenariosResource, } from "./resources/scenarios.js";
 import { SqlResource, } from "./resources/sql.js";
 import { VariablesResource, } from "./resources/variables.js";
+import { WikiResource, } from "./resources/wiki.js";
 /* ------------------------------------------------------------------ */
 /*  Constants                                                          */
 /* ------------------------------------------------------------------ */
@@ -89,32 +95,50 @@ export class DataikuClient {
     _projects;
     _datasets;
     _recipes;
+    _dashboards;
+    _dataQuality;
     _jobs;
+    futuresResource;
     _scenarios;
     _folders;
+    _flowZones;
     _variables;
     _connections;
     _codeEnvs;
+    _insights;
     _sql;
     _notebooks;
+    _wiki;
     get projects() {
         return (this._projects ??= new ProjectsResource(this));
     }
     get datasets() {
         return (this._datasets ??= new DatasetsResource(this));
     }
+    get dashboards() {
+        return (this._dashboards ??= new DashboardsResource(this));
+    }
+    get dataQuality() {
+        return (this._dataQuality ??= new DataQualityResource(this));
+    }
     get recipes() {
         return (this._recipes ??= new RecipesResource(this));
     }
     get jobs() {
         return (this._jobs ??= new JobsResource(this));
     }
+    get futures() {
+        return (this.futuresResource ??= new FuturesResource(this));
+    }
     get scenarios() {
         return (this._scenarios ??= new ScenariosResource(this));
     }
     get folders() {
         return (this._folders ??= new FoldersResource(this));
     }
+    get flowZones() {
+        return (this._flowZones ??= new FlowZonesResource(this));
+    }
     get variables() {
         return (this._variables ??= new VariablesResource(this));
     }
@@ -124,12 +148,18 @@ export class DataikuClient {
     get codeEnvs() {
         return (this._codeEnvs ??= new CodeEnvsResource(this));
     }
+    get insights() {
+        return (this._insights ??= new InsightsResource(this));
+    }
     get sql() {
         return (this._sql ??= new SqlResource(this));
     }
     get notebooks() {
         return (this._notebooks ??= new NotebooksResource(this));
     }
+    get wiki() {
+        return (this._wiki ??= new WikiResource(this));
+    }
     constructor(config) {
         const url = config.url?.trim();
         if (!url)

package/dist/src/errors.d.ts

@@ -1,4 +1,6 @@
 export type DataikuErrorCategory = "not_found" | "forbidden" | "validation" | "transient" | "unknown";
+export type StableErrorCode = "usage_error" | "unknown_flag" | "missing_required_arg" | "missing_required_flag" | "invalid_enum" | "not_found" | "permission_denied" | "validation_failed" | "transient" | "long_running_failure" | "internal_error";
+export declare function dataikuErrorCode(category: DataikuErrorCategory): StableErrorCode;
 export interface DataikuErrorTaxonomy {
     category: DataikuErrorCategory;
     retryable: boolean;

package/dist/src/errors.js

@@ -1,12 +1,56 @@
+export function dataikuErrorCode(category) {
+    switch (category) {
+        case "not_found":
+            return "not_found";
+        case "forbidden":
+            return "permission_denied";
+        case "validation":
+            return "validation_failed";
+        case "transient":
+            return "transient";
+        case "unknown":
+            return "internal_error";
+    }
+}
+const TLS_CERTIFICATE_HINT = "TLS certificate verification failed. Trust the DSS/corporate CA with --ca-cert PATH or NODE_EXTRA_CA_CERTS; use --insecure only for temporary troubleshooting.";
+function isCertificateTrustFailure(lowerBody) {
+    return lowerBody.includes("unable to verify the first certificate")
+        || lowerBody.includes("unable to get local issuer certificate")
+        || lowerBody.includes("unable to verify leaf signature")
+        || lowerBody.includes("self-signed certificate")
+        || lowerBody.includes("certificate has expired")
+        || lowerBody.includes("cert_has_expired")
+        || lowerBody.includes("self_signed_cert_in_chain")
+        || lowerBody.includes("unable_to_verify_leaf_signature")
+        || lowerBody.includes("err_tls_cert_altname_invalid")
+        || (lowerBody.includes("certificate") && lowerBody.includes("verify"));
+}
 export function classifyDataikuError(status, body) {
+    const lowerBody = body.toLowerCase();
     if (status === 0) {
+        if (isCertificateTrustFailure(lowerBody)) {
+            return {
+                category: "validation",
+                retryable: false,
+                retryHint: TLS_CERTIFICATE_HINT,
+            };
+        }
         return {
             category: "transient",
             retryable: true,
             retryHint: "Network/transport failure. Retry with backoff and verify DSS URL reachability.",
         };
     }
-    const lowerBody = body.toLowerCase();
+    const isSqlInputConnectionMismatch = (status === 400 || status >= 500)
+        && lowerBody.includes("s3 dataset")
+        && lowerBody.includes("athena connection");
+    if (isSqlInputConnectionMismatch) {
+        return {
+            category: "validation",
+            retryable: false,
+            retryHint: "SQL recipes require SQL/Athena-backed input datasets. Use a SQL-compatible input, associate the S3 dataset with Athena, or create a Python recipe for file/S3 inputs.",
+        };
+    }
     const isMissingDatasetRootPath = status === 500
         && lowerBody.includes("root path of the dataset")
         && lowerBody.includes("does not exist");

package/dist/src/index.d.ts

@@ -4,18 +4,24 @@ export { deleteCredentials, type DssCredentials, getConfigDir, getCredentialsPat
 export { DataikuError, type DataikuErrorCategory, type DataikuErrorTaxonomy, type DataikuRetryMetadata, } from "./errors.js";
 export { CodeEnvsResource, } from "./resources/code-envs.js";
 export { ConnectionsResource, } from "./resources/connections.js";
+export { DashboardsResource, } from "./resources/dashboards.js";
+export { DataQualityResource, } from "./resources/data-quality.js";
 export { DatasetsResource, } from "./resources/datasets.js";
+export { type FlowZoneItemInput, FlowZonesResource, } from "./resources/flow-zones.js";
 export { FoldersResource, } from "./resources/folders.js";
-export { computeNextPollDelayMs, JobsResource, } from "./resources/jobs.js";
+export { FuturesResource, } from "./resources/futures.js";
+export { InsightsResource, } from "./resources/insights.js";
+export { computeNextPollDelayMs, type JobBuildTargetType, JobsResource, } from "./resources/jobs.js";
 export { NotebooksResource, } from "./resources/notebooks.js";
 export { type FlowMapResult, ProjectsResource, } from "./resources/projects.js";
 export { RecipesResource, } from "./resources/recipes.js";
 export { ScenariosResource, } from "./resources/scenarios.js";
 export { SqlResource, } from "./resources/sql.js";
 export { VariablesResource, } from "./resources/variables.js";
-export { BuildModeSchema, CodeEnvDetailsSchema, CodeEnvSummaryArraySchema, CodeEnvSummarySchema, ConnectionSummarySchema, DatasetCreateOptionsSchema, DatasetDetailsSchema, DatasetSchemaSchema, DatasetSummaryArraySchema, DatasetSummarySchema, FlowMapOptionsSchema, FolderDetailsSchema, FolderItemArraySchema, FolderItemSchema, FolderSummaryArraySchema, FolderSummarySchema, JobSummaryArraySchema, JobSummarySchema, JobWaitResultSchema, JupyterCellSchema, JupyterNotebookContentSchema, JupyterNotebookSummaryArraySchema, JupyterNotebookSummarySchema, NotebookSessionArraySchema, NotebookSessionSchema, parseSchema, ProjectDetailsSchema, ProjectMetadataSchema, ProjectSummaryArraySchema, ProjectSummarySchema, ProjectVariablesSchema, RecipeCreateOptionsSchema, RecipeCreateResultSchema, RecipeDetailsSchema, RecipeSummaryArraySchema, RecipeSummarySchema, safeParseSchema, ScenarioDetailsSchema, ScenarioStatusSchema, ScenarioSummaryArraySchema, ScenarioSummarySchema, SqlNotebookCellSchema, SqlNotebookContentSchema, SqlNotebookSummaryArraySchema, SqlNotebookSummarySchema, SqlQueryResponseSchema, SqlQueryResultSchema, SqlQuerySchemaSchema, } from "./schemas.js";
+export { WikiResource, } from "./resources/wiki.js";
+export { BuildModeSchema, CodeEnvActionResultSchema, CodeEnvCreateOptionsSchema, CodeEnvDetailsSchema, CodeEnvPackageListSchema, CodeEnvSetPackagesOptionsSchema, CodeEnvSummaryArraySchema, CodeEnvSummarySchema, CodeEnvUpdatePackagesOptionsSchema, CodeEnvUsageArraySchema, CodeEnvWaitOptionsSchema, ConnectionSummarySchema, DashboardDetailsSchema, DashboardSummaryArraySchema, DashboardSummarySchema, DataQualityComputeResultSchema, DataQualityProjectStatusSchema, DataQualityRuleArraySchema, DataQualityRuleResultArraySchema, DataQualityRuleResultSchema, DataQualityRuleSchema, DataQualityRulesSchema, DataQualityStatusByPartitionSchema, DataQualityStatusSchema, DataQualityTimelineEntrySchema, DataQualityTimelineSchema, DatasetCreateOptionsSchema, DatasetDetailsSchema, DatasetSchemaSchema, DatasetSummaryArraySchema, DatasetSummarySchema, FlowMapOptionsSchema, FlowZoneArraySchema, FlowZoneCreateOptionsSchema, FlowZoneItemSchema, FlowZoneObjectTypeSchema, FlowZoneSchema, FlowZoneUpdateOptionsSchema, FolderCreateOptionsSchema, FolderDetailsSchema, FolderItemArraySchema, FolderItemSchema, FolderSummaryArraySchema, FolderSummarySchema, FutureStateSchema, FutureWaitResultSchema, InsightDetailsSchema, InsightSummaryArraySchema, InsightSummarySchema, JobSummaryArraySchema, JobSummarySchema, JobWaitResultSchema, JupyterCellSchema, JupyterNotebookContentSchema, JupyterNotebookSummaryArraySchema, JupyterNotebookSummarySchema, NotebookSessionArraySchema, NotebookSessionSchema, parseSchema, ProjectDetailsSchema, ProjectMetadataSchema, ProjectSummaryArraySchema, ProjectSummarySchema, ProjectVariablesSchema, RecipeCreateOptionsSchema, RecipeCreateResultSchema, RecipeDetailsSchema, RecipeSummaryArraySchema, RecipeSummarySchema, safeParseSchema, ScenarioDetailsSchema, ScenarioStatusSchema, ScenarioSummaryArraySchema, ScenarioSummarySchema, SqlNotebookCellSchema, SqlNotebookContentSchema, SqlNotebookSummaryArraySchema, SqlNotebookSummarySchema, SqlQueryResponseSchema, SqlQueryResultSchema, SqlQuerySchemaSchema, WikiArticleDataArraySchema, WikiArticleDataSchema, WikiArticleMetadataSchema, WikiSettingsSchema, WikiTaxonomyNodeSchema, } from "./schemas.js";
 export type { SafeParseResult, } from "./schemas.js";
-export type { BuildMode, CodeEnvDetails, CodeEnvSummary, ConnectionSummary, DatasetCreateOptions, DatasetDetails, DatasetSchema, DatasetSummary, FlowMapOptions, FolderDetails, FolderItem, FolderSummary, JobSummary, JobWaitResult, JupyterCell, JupyterNotebookContent, JupyterNotebookSummary, NotebookSession, ProjectDetails, ProjectMetadata, ProjectSummary, ProjectVariables, RecipeCreateOptions, RecipeCreateResult, RecipeDetails, RecipeSummary, ScenarioDetails, ScenarioStatus, ScenarioSummary, SqlNotebookCell, SqlNotebookContent, SqlNotebookSummary, SqlQueryResponse, SqlQueryResult, SqlQuerySchema, } 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, FlowZoneUpdateOptions, FolderCreateOptions, FolderDetails, FolderItem, FolderSummary, FutureState, FutureWaitResult, InsightDetails, InsightSummary, JobSummary, JobWaitResult, JupyterCell, JupyterNotebookContent, JupyterNotebookSummary, NotebookSession, ProjectDetails, ProjectMetadata, ProjectSummary, ProjectVariables, RecipeCreateOptions, RecipeCreateResult, RecipeDetails, RecipeSummary, ScenarioDetails, ScenarioStatus, ScenarioSummary, 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 { sanitizeFileName, } from "./utils/sanitize.js";

package/dist/src/index.js

@@ -8,8 +8,13 @@ export { DataikuError, } from "./errors.js";
 // Resources (for advanced use / extension)
 export { CodeEnvsResource, } from "./resources/code-envs.js";
 export { ConnectionsResource, } from "./resources/connections.js";
+export { DashboardsResource, } from "./resources/dashboards.js";
+export { DataQualityResource, } from "./resources/data-quality.js";
 export { DatasetsResource, } from "./resources/datasets.js";
+export { FlowZonesResource, } from "./resources/flow-zones.js";
 export { FoldersResource, } from "./resources/folders.js";
+export { FuturesResource, } from "./resources/futures.js";
+export { InsightsResource, } from "./resources/insights.js";
 export { computeNextPollDelayMs, JobsResource, } from "./resources/jobs.js";
 export { NotebooksResource, } from "./resources/notebooks.js";
 export { ProjectsResource, } from "./resources/projects.js";
@@ -17,8 +22,9 @@ export { RecipesResource, } from "./resources/recipes.js";
 export { ScenariosResource, } from "./resources/scenarios.js";
 export { SqlResource, } from "./resources/sql.js";
 export { VariablesResource, } from "./resources/variables.js";
+export { WikiResource, } from "./resources/wiki.js";
 // Schemas (TypeBox schema objects for runtime validation)
-export { BuildModeSchema, CodeEnvDetailsSchema, CodeEnvSummaryArraySchema, CodeEnvSummarySchema, ConnectionSummarySchema, DatasetCreateOptionsSchema, DatasetDetailsSchema, DatasetSchemaSchema, DatasetSummaryArraySchema, DatasetSummarySchema, FlowMapOptionsSchema, FolderDetailsSchema, FolderItemArraySchema, FolderItemSchema, FolderSummaryArraySchema, FolderSummarySchema, JobSummaryArraySchema, JobSummarySchema, JobWaitResultSchema, JupyterCellSchema, JupyterNotebookContentSchema, JupyterNotebookSummaryArraySchema, JupyterNotebookSummarySchema, NotebookSessionArraySchema, NotebookSessionSchema, parseSchema, ProjectDetailsSchema, ProjectMetadataSchema, ProjectSummaryArraySchema, ProjectSummarySchema, ProjectVariablesSchema, RecipeCreateOptionsSchema, RecipeCreateResultSchema, RecipeDetailsSchema, RecipeSummaryArraySchema, RecipeSummarySchema, safeParseSchema, ScenarioDetailsSchema, ScenarioStatusSchema, ScenarioSummaryArraySchema, ScenarioSummarySchema, SqlNotebookCellSchema, SqlNotebookContentSchema, SqlNotebookSummaryArraySchema, SqlNotebookSummarySchema, SqlQueryResponseSchema, SqlQueryResultSchema, SqlQuerySchemaSchema, } from "./schemas.js";
+export { BuildModeSchema, CodeEnvActionResultSchema, CodeEnvCreateOptionsSchema, CodeEnvDetailsSchema, CodeEnvPackageListSchema, CodeEnvSetPackagesOptionsSchema, CodeEnvSummaryArraySchema, CodeEnvSummarySchema, CodeEnvUpdatePackagesOptionsSchema, CodeEnvUsageArraySchema, CodeEnvWaitOptionsSchema, ConnectionSummarySchema, DashboardDetailsSchema, DashboardSummaryArraySchema, DashboardSummarySchema, DataQualityComputeResultSchema, DataQualityProjectStatusSchema, DataQualityRuleArraySchema, DataQualityRuleResultArraySchema, DataQualityRuleResultSchema, DataQualityRuleSchema, DataQualityRulesSchema, DataQualityStatusByPartitionSchema, DataQualityStatusSchema, DataQualityTimelineEntrySchema, DataQualityTimelineSchema, DatasetCreateOptionsSchema, DatasetDetailsSchema, DatasetSchemaSchema, DatasetSummaryArraySchema, DatasetSummarySchema, FlowMapOptionsSchema, FlowZoneArraySchema, FlowZoneCreateOptionsSchema, FlowZoneItemSchema, FlowZoneObjectTypeSchema, FlowZoneSchema, FlowZoneUpdateOptionsSchema, FolderCreateOptionsSchema, FolderDetailsSchema, FolderItemArraySchema, FolderItemSchema, FolderSummaryArraySchema, FolderSummarySchema, FutureStateSchema, FutureWaitResultSchema, InsightDetailsSchema, InsightSummaryArraySchema, InsightSummarySchema, JobSummaryArraySchema, JobSummarySchema, JobWaitResultSchema, JupyterCellSchema, JupyterNotebookContentSchema, JupyterNotebookSummaryArraySchema, JupyterNotebookSummarySchema, NotebookSessionArraySchema, NotebookSessionSchema, parseSchema, ProjectDetailsSchema, ProjectMetadataSchema, ProjectSummaryArraySchema, ProjectSummarySchema, ProjectVariablesSchema, RecipeCreateOptionsSchema, RecipeCreateResultSchema, RecipeDetailsSchema, RecipeSummaryArraySchema, RecipeSummarySchema, safeParseSchema, ScenarioDetailsSchema, ScenarioStatusSchema, ScenarioSummaryArraySchema, ScenarioSummarySchema, SqlNotebookCellSchema, SqlNotebookContentSchema, SqlNotebookSummaryArraySchema, SqlNotebookSummarySchema, SqlQueryResponseSchema, SqlQueryResultSchema, SqlQuerySchemaSchema, WikiArticleDataArraySchema, WikiArticleDataSchema, WikiArticleMetadataSchema, WikiSettingsSchema, WikiTaxonomyNodeSchema, } from "./schemas.js";
 // Utilities
 export { deepMerge, } from "./utils/deep-merge.js";
 export { normalizeFlowGraph, } from "./utils/flow-map.js";

package/dist/src/resources/code-envs.d.ts

@@ -1,8 +1,16 @@
-import type { CodeEnvDetails, CodeEnvSummary } from "../schemas.js";
+import type { CodeEnvActionResult, CodeEnvCreateOptions, CodeEnvDetails, CodeEnvPackageList, CodeEnvSetPackagesOptions, CodeEnvSummary, CodeEnvUpdatePackagesOptions, CodeEnvWaitOptions } from "../schemas.js";
 import { BaseResource } from "./base.js";
 export declare class CodeEnvsResource extends BaseResource {
     list(opts?: {
         envLang?: "PYTHON" | "R";
     }): Promise<CodeEnvSummary[]>;
     get(envLang: string, envName: string): Promise<CodeEnvDetails>;
+    getDefinition(envLang: string, envName: string): Promise<Record<string, unknown>>;
+    create(opts: CodeEnvCreateOptions): Promise<CodeEnvActionResult>;
+    setDefinition(envLang: string, envName: string, definition: Record<string, unknown>): Promise<CodeEnvActionResult>;
+    setPackages(envLang: string, envName: string, packages: CodeEnvPackageList, opts?: Pick<CodeEnvSetPackagesOptions, "installCorePackages">): Promise<CodeEnvActionResult>;
+    updatePackages(envLang: string, envName: string, opts?: CodeEnvUpdatePackagesOptions): Promise<CodeEnvActionResult>;
+    setJupyterSupport(envLang: string, envName: string, active: boolean, opts?: CodeEnvWaitOptions): Promise<CodeEnvActionResult>;
+    delete(envLang: string, envName: string, opts?: CodeEnvWaitOptions): Promise<CodeEnvActionResult>;
+    listUsages(envLang?: string, envName?: string): Promise<Record<string, unknown>[]>;
 }

package/dist/src/resources/code-envs.js

@@ -1,4 +1,4 @@
-import { CodeEnvSummaryArraySchema, } from "../schemas.js";
+import { CodeEnvSummaryArraySchema, CodeEnvUsageArraySchema, } from "../schemas.js";
 import { BaseResource, } from "./base.js";
 export class CodeEnvsResource extends BaseResource {
     async list(opts) {
@@ -25,6 +25,78 @@ export class CodeEnvsResource extends BaseResource {
             installedPackages,
         };
     }
+    async getDefinition(envLang, envName) {
+        const langEnc = encodeURIComponent(envLang);
+        const nameEnc = encodeURIComponent(envName);
+        return this.client.get(`/public/api/admin/code-envs/${langEnc}/${nameEnc}`);
+    }
+    async create(opts) {
+        const langEnc = encodeURIComponent(opts.envLang);
+        const nameEnc = encodeURIComponent(opts.envName);
+        const body = {
+            ...opts.params,
+            deploymentMode: opts.deploymentMode,
+        };
+        return this.client.post(`/public/api/admin/code-envs/${langEnc}/${nameEnc}?wait=${opts.wait !== false}`, body);
+    }
+    async setDefinition(envLang, envName, definition) {
+        const langEnc = encodeURIComponent(envLang);
+        const nameEnc = encodeURIComponent(envName);
+        return this.client.put(`/public/api/admin/code-envs/${langEnc}/${nameEnc}`, definition);
+    }
+    async setPackages(envLang, envName, packages, opts) {
+        const current = await this.getDefinition(envLang, envName);
+        const next = {
+            ...current,
+            specPackageList: normalizePackageList(packages),
+        };
+        if (opts?.installCorePackages !== undefined) {
+            const currentDesc = current.desc;
+            const desc = isRecord(currentDesc) ? { ...currentDesc, } : {};
+            desc.installCorePackages = opts.installCorePackages;
+            next.desc = desc;
+        }
+        return this.setDefinition(envLang, envName, next);
+    }
+    async updatePackages(envLang, envName, opts) {
+        const langEnc = encodeURIComponent(envLang);
+        const nameEnc = encodeURIComponent(envName);
+        const query = new URLSearchParams();
+        query.set("forceRebuildEnv", String(opts?.forceRebuildEnv === true));
+        if (opts?.versionToUpdate !== undefined)
+            query.set("versionToUpdate", opts.versionToUpdate);
+        query.set("wait", String(opts?.wait !== false));
+        return this.client.post(`/public/api/admin/code-envs/${langEnc}/${nameEnc}/packages?${query.toString()}`);
+    }
+    async setJupyterSupport(envLang, envName, active, opts) {
+        const langEnc = encodeURIComponent(envLang);
+        const nameEnc = encodeURIComponent(envName);
+        const query = new URLSearchParams();
+        query.set("active", String(active));
+        query.set("wait", String(opts?.wait !== false));
+        return this.client.post(`/public/api/admin/code-envs/${langEnc}/${nameEnc}/jupyter?${query.toString()}`);
+    }
+    async delete(envLang, envName, opts) {
+        const langEnc = encodeURIComponent(envLang);
+        const nameEnc = encodeURIComponent(envName);
+        await this.client.del(`/public/api/admin/code-envs/${langEnc}/${nameEnc}?wait=${opts?.wait !== false}`);
+        return { deleted: envName, envLang, };
+    }
+    async listUsages(envLang, envName) {
+        let raw;
+        if (envLang !== undefined || envName !== undefined) {
+            if (!envLang || !envName) {
+                throw new Error("codeEnvs.listUsages requires both envLang and envName when either is provided");
+            }
+            const langEnc = encodeURIComponent(envLang);
+            const nameEnc = encodeURIComponent(envName);
+            raw = await this.client.get(`/public/api/admin/code-envs/${langEnc}/${nameEnc}/usages`);
+        }
+        else {
+            raw = await this.client.get("/public/api/admin/code-envs/usages");
+        }
+        return this.client.safeParse(CodeEnvUsageArraySchema, raw, "codeEnvs.listUsages");
+    }
 }
 function splitPackageList(raw) {
     if (!raw)
@@ -34,3 +106,10 @@ function splitPackageList(raw) {
         .map((line) => line.trim())
         .filter((line) => line.length > 0);
 }
+function normalizePackageList(packages) {
+    const lines = Array.isArray(packages) ? packages : packages.split(/\r?\n/);
+    return lines.map((line) => line.trim()).filter((line) => line.length > 0).join("\n");
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}

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

@@ -4,7 +4,9 @@ export declare class ConnectionsResource extends BaseResource {
     /**
      * Returns sorted list of all connection names visible to the current user.
      */
-    list(): Promise<string[]>;
+    list(opts?: {
+        type?: string;
+    }): Promise<string[]>;
     /**
      * Infers available connections.
      *

package/dist/src/resources/connections.js

@@ -47,8 +47,10 @@ export class ConnectionsResource extends BaseResource {
     /**
      * Returns sorted list of all connection names visible to the current user.
      */
-    async list() {
-        const raw = await this.client.get(`/public/api/connections/get-names/`);
+    async list(opts) {
+        const type = opts?.type?.trim();
+        const query = type ? `?type=${encodeURIComponent(type)}` : "";
+        const raw = await this.client.get(`/public/api/connections/get-names/${query}`);
         return normalizeConnectionNames(raw);
     }
     /**

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

@@ -0,0 +1,19 @@
+import type { DashboardDetails, DashboardSummary } from "../schemas.js";
+import { BaseResource } from "./base.js";
+export interface DashboardCreateOptions {
+    name: string;
+    settings?: Record<string, unknown>;
+    projectKey?: string;
+}
+export interface DashboardUpdateOptions {
+    name?: string;
+    data?: Record<string, unknown>;
+    projectKey?: string;
+}
+export declare class DashboardsResource extends BaseResource {
+    list(projectKey?: string): Promise<DashboardSummary[]>;
+    get(dashboardId: string, projectKey?: string): Promise<DashboardDetails>;
+    create(opts: DashboardCreateOptions): Promise<DashboardDetails>;
+    update(dashboardId: string, opts: DashboardUpdateOptions): Promise<DashboardDetails>;
+    delete(dashboardId: string, projectKey?: string): Promise<void>;
+}

package/dist/src/resources/dashboards.js

@@ -0,0 +1,30 @@
+import { DashboardDetailsSchema, DashboardSummaryArraySchema, } from "../schemas.js";
+import { deepMerge, } from "../utils/deep-merge.js";
+import { BaseResource, } from "./base.js";
+export class DashboardsResource extends BaseResource {
+    async list(projectKey) {
+        const raw = await this.client.get(`/public/api/projects/${this.enc(projectKey)}/dashboards/`);
+        return this.client.safeParse(DashboardSummaryArraySchema, raw, "dashboards.list");
+    }
+    async get(dashboardId, projectKey) {
+        const raw = await this.client.get(`/public/api/projects/${this.enc(projectKey)}/dashboards/${encodeURIComponent(dashboardId)}/`);
+        return this.client.safeParse(DashboardDetailsSchema, raw, "dashboards.get");
+    }
+    async create(opts) {
+        const pk = this.resolveProjectKey(opts.projectKey);
+        const body = { ...(opts.settings ?? { pages: [], }), name: opts.name, };
+        const created = await this.client.post(`/public/api/projects/${encodeURIComponent(pk)}/dashboards/`, body);
+        return this.get(created.id, pk);
+    }
+    async update(dashboardId, opts) {
+        const current = await this.get(dashboardId, opts.projectKey);
+        const next = deepMerge(current, opts.data ?? {});
+        if (opts.name !== undefined)
+            next.name = opts.name;
+        const raw = await this.client.put(`/public/api/projects/${this.enc(opts.projectKey)}/dashboards/${encodeURIComponent(dashboardId)}/`, next);
+        return this.client.safeParse(DashboardDetailsSchema, raw, "dashboards.update");
+    }
+    async delete(dashboardId, projectKey) {
+        await this.client.del(`/public/api/projects/${this.enc(projectKey)}/dashboards/${encodeURIComponent(dashboardId)}/`);
+    }
+}

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

@@ -0,0 +1,54 @@
+import type { DataQualityComputeResult, DataQualityProjectStatus, DataQualityRule, DataQualityRuleResult, DataQualityRules, DataQualityStatus, DataQualityStatusByPartition, DataQualityTimeline, FutureWaitResult } from "../schemas.js";
+import { BaseResource } from "./base.js";
+export interface DataQualityProjectOptions {
+    projectKey?: string;
+}
+export interface DataQualityPartitionOptions extends DataQualityProjectOptions {
+    partition?: string;
+}
+export interface DataQualityStatusByPartitionOptions extends DataQualityProjectOptions {
+    includeAllPartitions?: boolean;
+}
+export interface DataQualityHistoryOptions extends DataQualityPartitionOptions {
+    minTimestamp?: number;
+    maxTimestamp?: number;
+    resultsPerPage?: number;
+    page?: number;
+    ruleId?: string;
+}
+export interface DataQualityRuleCreateOptions extends DataQualityProjectOptions {
+    config: Record<string, unknown>;
+}
+export interface DataQualityRuleUpdateOptions extends DataQualityProjectOptions {
+    data: Record<string, unknown>;
+}
+export interface DataQualityComputeOptions extends DataQualityPartitionOptions {
+    ruleId?: string;
+}
+export interface DataQualityComputeAndWaitOptions extends DataQualityComputeOptions {
+    pollIntervalMs?: number;
+    timeoutMs?: number;
+}
+export interface DataQualityProjectStatusOptions extends DataQualityProjectOptions {
+    onlyMonitored?: boolean;
+}
+export interface DataQualityProjectTimelineOptions extends DataQualityProjectOptions {
+    minTimestamp?: number;
+    maxTimestamp?: number;
+}
+export declare class DataQualityResource extends BaseResource {
+    rules(datasetName: string, projectKey?: string): Promise<DataQualityRules>;
+    listRules(datasetName: string, projectKey?: string): Promise<DataQualityRule[]>;
+    createRule(datasetName: string, opts: DataQualityRuleCreateOptions): Promise<DataQualityRule>;
+    updateRule(datasetName: string, ruleId: string, opts: DataQualityRuleUpdateOptions): Promise<DataQualityRule>;
+    deleteRule(datasetName: string, ruleId: string, projectKey?: string): Promise<void>;
+    getRule(datasetName: string, ruleId: string, projectKey?: string): Promise<DataQualityRule>;
+    status(datasetName: string, projectKey?: string): Promise<DataQualityStatus>;
+    statusByPartition(datasetName: string, opts?: DataQualityStatusByPartitionOptions): Promise<DataQualityStatusByPartition>;
+    lastResults(datasetName: string, opts?: DataQualityHistoryOptions): Promise<DataQualityRuleResult[]>;
+    history(datasetName: string, opts?: DataQualityHistoryOptions): Promise<DataQualityRuleResult[]>;
+    computeRules(datasetName: string, opts?: DataQualityComputeOptions): Promise<DataQualityComputeResult>;
+    computeRulesAndWait(datasetName: string, opts?: DataQualityComputeAndWaitOptions): Promise<FutureWaitResult>;
+    projectStatus(opts?: DataQualityProjectStatusOptions): Promise<DataQualityProjectStatus>;
+    projectTimeline(opts?: DataQualityProjectTimelineOptions): Promise<DataQualityTimeline>;
+}