dataiku-sdk 4.1.0 → 4.2.0

package/dist/src/cli/helpers/cleanup.js

@@ -345,6 +345,17 @@ export function cleanupLedgerEntry(resource, action, args, flags, result, projec
                 cleanup: { argv: ["streaming-endpoint", "delete", id, ...withProject,], },
             };
         }
+        case "messaging-channel.create": {
+            // DSS echoes the id it allocated; an explicit --id is the fallback.
+            const id = stringField(record, ["id",]) ?? flags["id"];
+            if (!id)
+                return undefined;
+            return {
+                ...base,
+                id,
+                cleanup: { argv: ["messaging-channel", "delete", id, "--if-exists",], },
+            };
+        }
         case "meaning.create": {
             const id = args[0];
             return {

package/dist/src/cli/list-shapes.js

@@ -100,6 +100,11 @@ export const COMPACT_LIST_FIELDS = {
         label: field("label", STRING),
         type: field("type", STRING),
     },
+    "messaging-channel": {
+        id: field("id", STRING),
+        type: field("type", STRING),
+        family: field("family", STRING),
+    },
 };
 /** Discovery output schemas of the compact `RESOURCE.list` defaults. */
 export function compactListOutputSchemas() {

package/dist/src/cli/plans.js

@@ -10,13 +10,16 @@ import { encodeLibraryPath, PROJECT_LIBRARY_CONCURRENCY_CONTROL, validateLibrary
 import { buildRecipeCreateRequest, } from "../resources/recipe-create.js";
 import { modelDiagnosticsBody, } from "../resources/trained-model.js";
 import { encodeGitReferencePath, validateGitReferencePath, } from "../utils/git-reference.js";
+import { sanitizeMessagingChannelSecrets, } from "../utils/messaging-channel-secrets.js";
 import { jobBuildTargetTypeFromFlags, json, jsonInput, num, parseBooleanOption, parseJsonObject, requiredJsonInput, rewritePairsFromFlags, schemaColumnsInput, sha256Hex, stableHash, stringField, textInput, unknownJsonInput, } from "./coerce.js";
 import { parseCodeRunIntegerFlag, resolveCodeInputWithSource, } from "./commands/code.js";
 import { schemaPropagationOptionsFromFlags, } from "./commands/flow.js";
+import { messagingChannelPlanShape, } from "./commands/messaging-channel.js";
 import { mlTaskFieldsFromFlags, mlTaskReguessOptionsFromFlags, } from "./commands/ml-task.js";
 import { deployRunOptionsFromFlags, experimentsDatasetOptionsFromFlags, inferenceInfoFromFlags, } from "./commands/mlflow.js";
 import { projectLibraryPutPayload, } from "./commands/project-library.js";
 import { enqueueRecipeCreateWarnings, recipeCreateOptionsFromFlags, } from "./commands/recipe.js";
+import { scenarioReporterFromFlags, scenarioRunParams, scenarioTriggerFromFlags, } from "./commands/scenario.js";
 import { resolveSqlQueryInvocation, } from "./commands/sql.js";
 import { buildRegistryEntry, splitPackageSpec, } from "./contract.js";
 import { ambientProjectKey, } from "./env.js";
@@ -1209,7 +1212,7 @@ export function commandPlanShape(resource, action, args, flags, entry, projectKe
                 method: "POST",
                 endpoint: projectEndpoint(`/scenarios/${encodeURIComponent(id)}/run/`),
                 identifiers: { id, },
-                payload: {},
+                payload: scenarioRunParams(flags) ?? {},
                 wait: action === "run-and-wait" || flags["wait"] === true,
             };
         case "scenario.delete":
@@ -1230,10 +1233,84 @@ export function commandPlanShape(resource, action, args, flags, entry, projectKe
                     name: args[1],
                     projectKey,
                     type,
-                    params: type === "step_based" ? { steps: [], triggers: [], reporters: [], } : {},
+                    ...(type === "step_based"
+                        ? { params: { steps: [], }, triggers: [], reporters: [], }
+                        : { params: {}, }),
+                    ...jsonInput(flags),
                 },
             };
         }
+        case "scenario.trigger-add":
+        case "scenario.reporter-add": {
+            const isTrigger = action === "trigger-add";
+            const field = isTrigger ? "triggers" : "reporters";
+            const item = isTrigger
+                ? scenarioTriggerFromFlags(flags)
+                : sanitizeMessagingChannelSecrets(scenarioReporterFromFlags(flags));
+            const endpoint = projectEndpoint(`/scenarios/${encodeURIComponent(id)}/`);
+            return {
+                exact: false,
+                reason: `Apply GETs the scenario, appends this element to ${field} (the others are kept), PUTs the full scenario, then GETs it back to verify; the stored element gains DSS-assigned ids.`,
+                method: "PUT",
+                endpoint,
+                identifiers: { id, },
+                payload: item,
+                requests: [
+                    { sequence: 1, method: "GET", endpoint, },
+                    { sequence: 2, method: "PUT", endpoint, payloadEdits: { [field]: { append: item, }, }, },
+                    { sequence: 3, method: "GET", endpoint, },
+                ],
+            };
+        }
+        case "scenario.trigger-remove":
+        case "scenario.reporter-remove": {
+            const field = action === "trigger-remove" ? "triggers" : "reporters";
+            const selector = flags["index"] !== undefined
+                ? { index: num(flags["index"], "--index"), }
+                : { name: flags["name"], };
+            if ((flags["index"] === undefined) === (flags["name"] === undefined)) {
+                throw new UsageError(`Pass exactly one of --index or --name. Usage: ${entry.usage}`);
+            }
+            const endpoint = projectEndpoint(`/scenarios/${encodeURIComponent(id)}/`);
+            return {
+                exact: false,
+                reason: `Apply GETs the scenario, drops the selected element from ${field} (the others are kept), PUTs the full scenario, then GETs it back to verify.`,
+                method: "PUT",
+                endpoint,
+                identifiers: { id, },
+                payload: selector,
+                requests: [
+                    { sequence: 1, method: "GET", endpoint, },
+                    { sequence: 2, method: "PUT", endpoint, payloadEdits: { [field]: { remove: selector, }, }, },
+                    { sequence: 3, method: "GET", endpoint, },
+                ],
+            };
+        }
+        case "scenario.run-as-set": {
+            const user = flags["user"];
+            if ((typeof user === "string") === (flags["clear"] === true)) {
+                throw new UsageError(`Pass exactly one of --user LOGIN or --clear. Usage: ${entry.usage}`);
+            }
+            const endpoint = projectEndpoint(`/scenarios/${encodeURIComponent(id)}/`);
+            return {
+                exact: false,
+                reason: "Apply GETs the scenario, sets (or, with --clear, removes) runAsUser, PUTs the full scenario, then GETs it back to verify.",
+                method: "PUT",
+                endpoint,
+                identifiers: { id, },
+                payload: { runAsUser: typeof user === "string" ? user : null, },
+                requests: [
+                    { sequence: 1, method: "GET", endpoint, },
+                    {
+                        sequence: 2,
+                        method: "PUT",
+                        endpoint,
+                        payloadEdits: { runAsUser: typeof user === "string" ? user : "<removed>", },
+                    },
+                    { sequence: 3, method: "GET", endpoint, },
+                ],
+            };
+        }
         case "scenario.update":
             return {
                 method: "PUT",
@@ -1345,6 +1422,21 @@ export function commandPlanShape(resource, action, args, flags, entry, projectKe
                 endpoint: `/public/api/project-deployer/infras/${encodeURIComponent(id)}`,
                 identifiers: { infraId: id, },
             };
+        case "project-deployer.run-test-scenarios": {
+            const nodeFlag = flags["automation-node-id"];
+            const automationNodeId = typeof nodeFlag === "string" && nodeFlag !== "" ? nodeFlag : undefined;
+            return {
+                method: "POST",
+                endpoint: `/public/api/project-deployer/deployments/${encodeURIComponent(id)}/run-test-scenarios${querySuffix({ automationNodeId, })}`,
+                identifiers: { deploymentId: id, },
+            };
+        }
+        case "messaging-channel.create":
+        case "messaging-channel.settings-set":
+        case "messaging-channel.permissions-set":
+        case "messaging-channel.delete":
+        case "messaging-channel.send":
+            return messagingChannelPlanShape(action, args, flags, projectKey);
         case "project-deployer.delete-project":
             return {
                 method: "DELETE",

package/dist/src/cli/read-shapes.js

@@ -54,7 +54,7 @@ export function compactReadOutputSchemas() {
         description: "Next commands to run, each as an argv array.",
         items: { type: "array", items: STRING, },
     };
-    return {
+    const schemas = {
         "job.get": {
             type: "object",
             additionalProperties: false,
@@ -201,4 +201,5 @@ export function compactReadOutputSchemas() {
             },
         },
     };
+    return { ...schemas, "scenario.runs-by-date": schemas["scenario.last-runs"], };
 }

package/dist/src/cli/result-shapes.js

@@ -442,6 +442,7 @@ const READ_SHAPERS = {
     "project.get": shapeProjectGet,
     "scenario.get-run": shapeScenarioGetRun,
     "scenario.last-runs": shapeScenarioLastRuns,
+    "scenario.runs-by-date": shapeScenarioLastRuns,
 };
 /**
  * Compact a command result for agents: `*.list` items (filter, cap, compact

package/dist/src/cli/usage.js

@@ -10,6 +10,12 @@ function commandSuggestions(resource, action) {
         const dot = key.indexOf(".");
         (actionsByResource[key.slice(0, dot)] ??= []).push(key.slice(dot + 1));
     }
+    // An unknown resource with no close name gets no suggestions: the same action under
+    // arbitrary resources (`pipelines list` -> `app list`) misleads more than it helps.
+    if (!Object.hasOwn(actionsByResource, resource)
+        && suggestSelectors(resource, actionsByResource).length === 0) {
+        return [];
+    }
     return suggestSelectors(action ? `${resource}.${action}` : resource, actionsByResource)
         .map((selector) => `dss ${selector.replace(".", " ")}`);
 }
@@ -44,6 +50,7 @@ export const RESOURCE_NAMES = [
     "statistics",
     "discussion",
     "meaning",
+    "messaging-channel",
     "workspace",
     "metrics",
     "doctor",

package/dist/src/cli/version.d.ts

@@ -49,7 +49,7 @@ export declare function buildVersionPayload(input: {
 export declare const PACKAGE_ROOT: string | undefined;
 export declare const CLI_VERSION: string;
 export declare const CLI_GIT_REVISION: string | undefined;
-export declare const AGENT_CONTRACT_VERSION = 6;
+export declare const AGENT_CONTRACT_VERSION = 7;
 export declare const JSON_SCHEMA_DRAFT = "https://json-schema.org/draft/2020-12/schema";
-export declare const AGENT_CONTRACT_SCHEMA_ID = "https://clssck.github.io/dataiku-sdk/schemas/agent-contract-v6.json";
+export declare const AGENT_CONTRACT_SCHEMA_ID = "https://clssck.github.io/dataiku-sdk/schemas/agent-contract-v7.json";
 export declare function cliVersionResult(): CliVersionPayload;

package/dist/src/cli/version.js

@@ -203,9 +203,9 @@ export function buildVersionPayload(input) {
 export const PACKAGE_ROOT = findPackageRoot();
 export const CLI_VERSION = packageVersion(PACKAGE_ROOT);
 export const CLI_GIT_REVISION = gitRevision(PACKAGE_ROOT);
-export const AGENT_CONTRACT_VERSION = 6;
+export const AGENT_CONTRACT_VERSION = 7;
 export const JSON_SCHEMA_DRAFT = "https://json-schema.org/draft/2020-12/schema";
-export const AGENT_CONTRACT_SCHEMA_ID = "https://clssck.github.io/dataiku-sdk/schemas/agent-contract-v6.json";
+export const AGENT_CONTRACT_SCHEMA_ID = "https://clssck.github.io/dataiku-sdk/schemas/agent-contract-v7.json";
 export function cliVersionResult() {
     // Only code actually loaded from dist/ may report dist provenance; an
     // inherited DSS_LOAD_SOURCE on a source run is ignored.

package/dist/src/client.d.ts

@@ -23,6 +23,7 @@ import type { KnowledgeBanksResource } from "./resources/knowledge-banks.js";
 import type { LlmsResource } from "./resources/llms.js";
 import type { MacrosResource } from "./resources/macros.js";
 import type { MeaningsResource } from "./resources/meanings.js";
+import type { MessagingChannelsResource } from "./resources/messaging-channels.js";
 import type { MetricsResource } from "./resources/metrics.js";
 import type { MlTasksResource } from "./resources/ml-tasks.js";
 import type { MlflowExtensionResource } from "./resources/mlflow-extension.js";
@@ -196,6 +197,7 @@ export declare class DataikuClient {
     private workspacesResource?;
     private metricsResource?;
     private meaningsResource?;
+    private messagingChannelsResource?;
     private analysesResource?;
     private mlTasksResource?;
     private savedModelsResource?;
@@ -242,6 +244,7 @@ export declare class DataikuClient {
     get workspaces(): WorkspacesResource;
     get metrics(): MetricsResource;
     get meanings(): MeaningsResource;
+    get messagingChannels(): MessagingChannelsResource;
     get analyses(): AnalysesResource;
     get mlTasks(): MlTasksResource;
     get savedModels(): SavedModelsResource;
@@ -346,6 +349,14 @@ export declare class DataikuClient {
      * boundary is set correctly.
      */
     uploadForm<T = unknown>(path: string, parts: UploadFormPart[], query?: URLSearchParams): Promise<T>;
+    /**
+     * POST a multipart/form-data body like {@link uploadForm} for endpoints whose
+     * success carries no JSON the caller needs (e.g. mail sends): the response
+     * body is not parsed, so a non-JSON acknowledgement cannot turn an already
+     * applied write into a client error.
+     */
+    uploadFormVoid(path: string, parts: UploadFormPart[], query?: URLSearchParams): Promise<void>;
+    private postFormData;
     private uploadResponse;
     upload(path: string, filePath: string, fileName?: string): Promise<void>;
     uploadJson<T>(path: string, filePath: string, fileName?: string): Promise<T>;

package/dist/src/client.js

@@ -256,6 +256,7 @@ export class DataikuClient {
     workspacesResource;
     metricsResource;
     meaningsResource;
+    messagingChannelsResource;
     analysesResource;
     mlTasksResource;
     savedModelsResource;
@@ -508,6 +509,13 @@ export class DataikuClient {
         }
         return this.meaningsResource;
     }
+    get messagingChannels() {
+        if (!this.messagingChannelsResource) {
+            const { MessagingChannelsResource: Resource, } = require("./resources/messaging-channels.js");
+            this.messagingChannelsResource = new Resource(this);
+        }
+        return this.messagingChannelsResource;
+    }
     get analyses() {
         if (!this.analysesResource) {
             const { AnalysesResource: Resource, } = require("./resources/analyses.js");
@@ -820,6 +828,18 @@ export class DataikuClient {
      * boundary is set correctly.
      */
     async uploadForm(path, parts, query) {
+        return this.parseJsonResponse(await this.postFormData(path, parts, query));
+    }
+    /**
+     * POST a multipart/form-data body like {@link uploadForm} for endpoints whose
+     * success carries no JSON the caller needs (e.g. mail sends): the response
+     * body is not parsed, so a non-JSON acknowledgement cannot turn an already
+     * applied write into a client error.
+     */
+    async uploadFormVoid(path, parts, query) {
+        await this.postFormData(path, parts, query);
+    }
+    async postFormData(path, parts, query) {
         const formData = new FormData();
         for (const part of parts) {
             if (part.value !== undefined) {
@@ -838,12 +858,11 @@ export class DataikuClient {
             formData.append(part.name, blob, part.fileName);
         }
         const suffix = query && [...query.keys(),].length > 0 ? `?${query.toString()}` : "";
-        const res = await this.fetchWithRetry(`${this.baseUrl}${path}${suffix}`, {
+        return this.fetchWithRetry(`${this.baseUrl}${path}${suffix}`, {
             method: "POST",
             headers: { Authorization: `Bearer ${this.apiKey}`, },
             body: formData,
         });
-        return this.parseJsonResponse(res);
     }
     async uploadResponse(path, filePath, fileName) {
         const fileBlob = Bun.file(filePath);

package/dist/src/generated/action-output-schemas.json

@@ -1300,6 +1300,33 @@
                 }
             }
         },
+        "messaging-channel.list": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "additionalProperties": false,
+                "properties": {
+                    "id": {
+                        "type": [
+                            "string",
+                            "null"
+                        ]
+                    },
+                    "type": {
+                        "type": [
+                            "string",
+                            "null"
+                        ]
+                    },
+                    "family": {
+                        "type": [
+                            "string",
+                            "null"
+                        ]
+                    }
+                }
+            }
+        },
         "notebook.get-jupyter": {
             "additionalProperties": true,
             "type": "object",
@@ -2229,6 +2256,61 @@
                 }
             }
         },
+        "scenario.runs-by-date": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "additionalProperties": false,
+                "required": [
+                    "runId"
+                ],
+                "properties": {
+                    "runId": {
+                        "type": "string"
+                    },
+                    "outcome": {
+                        "type": "string"
+                    },
+                    "start": {
+                        "type": "number"
+                    },
+                    "end": {
+                        "type": "number"
+                    },
+                    "trigger": {
+                        "type": "object",
+                        "additionalProperties": false,
+                        "properties": {
+                            "type": {
+                                "type": "string"
+                            },
+                            "name": {
+                                "type": "string"
+                            }
+                        }
+                    },
+                    "failure": {
+                        "type": "object",
+                        "additionalProperties": false,
+                        "properties": {
+                            "message": {
+                                "type": "string"
+                            }
+                        }
+                    },
+                    "next": {
+                        "type": "array",
+                        "description": "Next commands to run, each as an argv array.",
+                        "items": {
+                            "type": "array",
+                            "items": {
+                                "type": "string"
+                            }
+                        }
+                    }
+                }
+            }
+        },
         "scenario.status": {
             "additionalProperties": true,
             "type": "object",

package/dist/src/index.d.ts

@@ -27,6 +27,7 @@ export * from "./resources/knowledge-banks.js";
 export * from "./resources/llms.js";
 export { type MacroResultOptions, type MacroRunFailure, type MacroRunHandle, type MacroRunOptions, type MacroRunWaitedResult, MacrosResource, type MacroWaitOptions, } from "./resources/macros.js";
 export { MeaningsResource, } from "./resources/meanings.js";
+export * from "./resources/messaging-channels.js";
 export { MetricsResource, } from "./resources/metrics.js";
 export * from "./resources/ml-tasks.js";
 export { type MlflowDeployRunOptions, type MlflowExperimentsDatasetOptions, MlflowExtensionResource, type MlflowInferenceInfo, type MlflowPredictionType, } from "./resources/mlflow-extension.js";

package/dist/src/index.js

@@ -30,6 +30,7 @@ export * from "./resources/knowledge-banks.js";
 export * from "./resources/llms.js";
 export { MacrosResource, } from "./resources/macros.js";
 export { MeaningsResource, } from "./resources/meanings.js";
+export * from "./resources/messaging-channels.js";
 export { MetricsResource, } from "./resources/metrics.js";
 export * from "./resources/ml-tasks.js";
 export { MlflowExtensionResource, } from "./resources/mlflow-extension.js";

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

@@ -126,6 +126,24 @@ export declare class ProjectDeployerResource extends BaseResource {
     getDeploymentSettings(deploymentId: string): Promise<Record<string, unknown>>;
     /** Governance status of the deployment's bundle (or `bundleId`'s): messages on whether it may deploy. */
     getGovernanceStatus(deploymentId: string, bundleId?: string): Promise<Record<string, unknown>>;
+    /**
+     * Combined last-run outcome of the deployment's test scenarios, worst
+     * outcome wins. `bundleId` filters the runs to one bundle;
+     * `automationNodeId` is required for multi-node deployments only.
+     */
+    getTestingStatus(deploymentId: string, options?: {
+        bundleId?: string;
+        automationNodeId?: string;
+    }): Promise<Record<string, unknown>>;
+    /**
+     * Run every test scenario of the deployment on its Automation node and
+     * return the resulting testing status. The request stays open until the
+     * scenarios finish. `automationNodeId` is required for multi-node
+     * deployments only.
+     */
+    runTestScenarios(deploymentId: string, options?: {
+        automationNodeId?: string;
+    }): Promise<Record<string, unknown>>;
     /** Delete a published project no deployment uses. */
     deleteProject(publishedProjectKey: string): Promise<void>;
     /** Get a published project's settings (permissions, owner). */

package/dist/src/resources/bundles.js

@@ -186,6 +186,32 @@ export class ProjectDeployerResource extends BaseResource {
         const query = bundleId ? `?bundleId=${encodeURIComponent(bundleId)}` : "";
         return this.client.get(`/public/api/project-deployer/deployments/${encodeURIComponent(deploymentId)}/governance-status${query}`);
     }
+    /**
+     * Combined last-run outcome of the deployment's test scenarios, worst
+     * outcome wins. `bundleId` filters the runs to one bundle;
+     * `automationNodeId` is required for multi-node deployments only.
+     */
+    async getTestingStatus(deploymentId, options = {}) {
+        const query = new URLSearchParams();
+        if (options.bundleId)
+            query.set("bundleId", options.bundleId);
+        if (options.automationNodeId)
+            query.set("automationNodeId", options.automationNodeId);
+        const suffix = query.size > 0 ? `?${query.toString()}` : "";
+        return this.client.get(`/public/api/project-deployer/deployments/${encodeURIComponent(deploymentId)}/testing-status${suffix}`);
+    }
+    /**
+     * Run every test scenario of the deployment on its Automation node and
+     * return the resulting testing status. The request stays open until the
+     * scenarios finish. `automationNodeId` is required for multi-node
+     * deployments only.
+     */
+    async runTestScenarios(deploymentId, options = {}) {
+        const suffix = options.automationNodeId
+            ? `?automationNodeId=${encodeURIComponent(options.automationNodeId)}`
+            : "";
+        return this.client.post(`/public/api/project-deployer/deployments/${encodeURIComponent(deploymentId)}/run-test-scenarios${suffix}`);
+    }
     /** Delete a published project no deployment uses. */
     async deleteProject(publishedProjectKey) {
         await this.client.del(`/public/api/project-deployer/projects/${encodeURIComponent(publishedProjectKey)}`);

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

@@ -21,10 +21,13 @@ export declare class FuturesResource extends BaseResource {
     /**
      * Long tasks in progress (GET /futures/): the caller's own by default,
      * every user's with `allUsers`, running scenarios too with `withScenarios`.
+     * `scenariosOnly` lists running scenarios and nothing else, like dataikuapi's
+     * `list_running_scenarios` (`withScenarios=true&withNotScenarios=false`).
      */
     list(opts?: {
         allUsers?: boolean;
         withScenarios?: boolean;
+        scenariosOnly?: boolean;
     }): Promise<FutureState[]>;
     /** Wait for a started task; a task DSS already finished inline is returned as is. */
     waitTask(task: DssTask, opts?: FutureWaitOptions): Promise<FutureWaitResult | DssTask>;

package/dist/src/resources/futures.js

@@ -37,12 +37,16 @@ export class FuturesResource extends BaseResource {
     /**
      * Long tasks in progress (GET /futures/): the caller's own by default,
      * every user's with `allUsers`, running scenarios too with `withScenarios`.
+     * `scenariosOnly` lists running scenarios and nothing else, like dataikuapi's
+     * `list_running_scenarios` (`withScenarios=true&withNotScenarios=false`).
      */
     async list(opts = {}) {
         const query = new URLSearchParams({
             allUsers: String(opts.allUsers === true),
-            withScenarios: String(opts.withScenarios === true),
+            withScenarios: String(opts.withScenarios === true || opts.scenariosOnly === true),
         });
+        if (opts.scenariosOnly === true)
+            query.set("withNotScenarios", "false");
         return this.client.get(`/public/api/futures/?${query}`);
     }
     /** Wait for a started task; a task DSS already finished inline is returned as is. */

package/dist/src/resources/messaging-channels.d.ts

@@ -0,0 +1,83 @@
+import { BaseResource } from "./base.js";
+/** One entry of a channel's permission list: a group or a user, and whether it may use the channel. */
+export interface MessagingChannelPermission extends Record<string, unknown> {
+    group?: string;
+    user?: string;
+    canUse?: boolean;
+}
+/** A channel as DSS lists or returns it. Configuration fields (credentials included) arrive unredacted. */
+export interface MessagingChannel extends Record<string, unknown> {
+    id?: string;
+    type?: string;
+    family?: string;
+}
+export interface MessagingChannelListOptions {
+    /** Channel type to filter by, e.g. `smtp`, `aws-ses-mail`, `slack`. */
+    channelType?: string;
+    /** Channel family to filter by; `mail` selects every channel that sends email-like messages. */
+    channelFamily?: string;
+}
+export interface MessagingChannelCreateRequest {
+    type: string;
+    /** Channel id; DSS allocates one when omitted. */
+    id?: string;
+    /** Type-specific configuration (host, sender, webhookUrl, ...). */
+    configuration?: Record<string, unknown>;
+    /** Usage permissions; `null`/omitted lets DSS grant every user. */
+    permissions?: MessagingChannelPermission[] | null;
+}
+export interface MailAttachment {
+    /** Local file to attach. */
+    path: string;
+    /** Name the recipient sees; defaults to the file's base name. */
+    fileName?: string;
+}
+export interface MailMessageRequest {
+    to: string[];
+    subject: string;
+    body: string;
+    cc?: string[];
+    bcc?: string[];
+    /** Sender address; defaults to the sender configured on the channel. */
+    from?: string;
+    /** Send `body` as plain text instead of HTML. */
+    plainText?: boolean;
+}
+export interface MailSendOptions {
+    /** Project issuing the email; the caller needs "Write content" on it. Defaults to the client's project. */
+    projectKey?: string;
+    /** One message to every `to` address (true) or one message per address (false, DSS default). */
+    sendAsSingleMessage?: boolean;
+    attachments?: MailAttachment[];
+}
+/** The JSON `message` part of the send request, shaped like the official Python client's payload. */
+export declare function mailMessagePayload(message: MailMessageRequest): Record<string, unknown>;
+/** Query string of the send request. */
+export declare function mailSendQuery(projectKey: string, sendAsSingleMessage: boolean | undefined): URLSearchParams;
+/** The POST body of a channel creation, as the official Python client sends it. */
+export declare function messagingChannelCreateBody(request: MessagingChannelCreateRequest): Record<string, unknown>;
+export declare class MessagingChannelsResource extends BaseResource {
+    /** List messaging channels visible to the caller, optionally filtered by type or family. */
+    list(options?: MessagingChannelListOptions): Promise<MessagingChannel[]>;
+    /** Get one channel (type, family, and for mail channels the sender). */
+    get(channelId: string): Promise<MessagingChannel>;
+    /** Create a channel (admin). DSS returns the created channel. */
+    create(request: MessagingChannelCreateRequest): Promise<MessagingChannel>;
+    /** Get a channel's settings, i.e. its configuration (admin). */
+    getSettings(channelId: string): Promise<Record<string, unknown>>;
+    /** Replace a channel's settings (admin); pass the object obtained from {@link getSettings}. */
+    saveSettings(channelId: string, settings: Record<string, unknown>): Promise<void>;
+    /** Get the users and groups allowed to use a channel. */
+    getPermissions(channelId: string): Promise<MessagingChannelPermission[]>;
+    /** Replace a channel's permission list. */
+    setPermissions(channelId: string, permissions: MessagingChannelPermission[]): Promise<void>;
+    /** Delete a channel (admin). */
+    delete(channelId: string): Promise<void>;
+    /**
+     * Send an email through a mail-family channel, as a multipart request: a JSON
+     * `message` part plus one `attachments` part per file. This sends real mail
+     * and is never retried.
+     */
+    send(channelId: string, message: MailMessageRequest, options?: MailSendOptions): Promise<void>;
+    private channelPath;
+}