@tenonhq/dovetail-servicenow 0.0.6 → 0.0.8

package/README.md

@@ -154,8 +154,40 @@ npx dove-sn set-related-lists \
   --table x_cadso_automate_audience \
   --related-lists "x_cadso_automate_audience_member.audience" \
   --update-set 0083c3bb33d003507b18bc534d5c7b6d
+
+# View a flow / subflow's compiled step graph (read-only, headless)
+npx dove-sn view-flow --sys-id 327c53bfc33e3250d4ddf1db05013135
+npx dove-sn view-flow --sys-id <sys_id> --json --raw   # structured + full model
+
+# View a Custom Action Type's model (inputs/outputs)
+npx dove-sn view-action --sys-id <action_type_sys_id> --scope <scope_sys_id>
+
+# Publish (compile the snapshot of) a flow / subflow after editing in the Designer
+npx dove-sn publish-flow --sys-id <sys_id>             # scope defaults to the flow's
+
+# Test a flow: validate (default, read-only) or actually run it
+npx dove-sn test-flow --sys-id <sys_id> --inputs '{"phone":"+1555..."}'
+npx dove-sn test-flow --sys-id <sys_id> --execute --confirm --inputs '{...}'  # runs it
+
+# Edit a flow in place (rename / description / step inputs), then publish
+echo '{"rename":{"name":"New Name"},"patchStepInputs":[{"step":"Calculate SMS Send At","input":"send_rate","value":"5"}]}' > ops.json
+npx dove-sn edit-flow --sys-id <sys_id> --from-json ops.json            # dry-run (diff)
+npx dove-sn edit-flow --sys-id <sys_id> --from-json ops.json --apply    # publish the edit
 ```
 
+`test-flow` defaults to **validate** — a safe pre-flight (published? inputs match
+declared variables?) that never runs the flow. `--execute --confirm` runs it via
+the server-side FlowAPI runner (deploy `resources/runFlow.md` first); running a
+flow can cause real side effects. `edit-flow` defaults to a **dry-run** diff;
+`--apply` re-publishes the patched model via the snapshot endpoint.
+
+`view-flow` reads `GET /api/now/processflow/flow/{id}` — the Designer's own model
+endpoint — and prints the ordered, nesting-aware action + flow-logic step graph
+plus the flow variables. This works for the integration user with plain basic
+auth; the raw `sys_hub_flow_snapshot` Table API 404 is a row-level restriction on
+the working snapshot, not a barrier. `publish-flow` POSTs the model back to
+`.../flow/{id}/snapshot`, recompiling the current design (a write).
+
 `set-form-layout` JSON payload shape:
 
 ```json
@@ -193,10 +225,13 @@ console.log(formatLayoutResult("form layout", result));
 
 ## MCP server
 
-`dove-sn mcp` runs a self-contained MCP stdio server exposing the write tools to
+`dove-sn mcp` runs a self-contained MCP stdio server exposing the tools to
 Claude Code and agents: `create_view`, `set_list_layout`, `set_form_layout`,
-`set_related_lists`, and `add_choices_to_field`. It reads ServiceNow credentials
-from the same env vars as the CLI.
+`set_related_lists`, `add_choices_to_field`, plus the Flow Designer tools
+`flow_view` (read a flow/subflow's step graph), `action_view` (read an action
+type's model), `flow_publish` (compile a flow/subflow snapshot), `flow_test`
+(validate or run a flow), and `flow_edit` (patch a flow + publish). It reads
+ServiceNow credentials from the same env vars as the CLI.
 
 ```bash
 npx dove-sn mcp --smoke   # list the registered tools and exit
@@ -212,6 +247,53 @@ npx dove-sn mcp           # run the stdio server (wire into .mcp.json)
 This server is separate from `@tenonhq/dovetail-mcp` (the read-only cross-system
 aggregator) — `dovetail-servicenow`'s server is the ServiceNow **write** surface.
 
+## Publishing a Custom Action Type
+
+`publishActionType` compiles the `sys_hub_flow_snapshot` for a Custom Action Type
+— the step that makes it draggable in the Flow Designer palette. This replays the
+Designer's **Publish** button, which is a plain REST call that **works with basic
+auth** (no session cookie, CSRF token, or `sn_build_agent` role):
+
+```
+GET  /api/now/processflow/action/action_types/{sysId}?sysparm_transaction_scope={scope}
+       -> 200, the full action-type model EXCEPT `steps` (always returns null)
+POST /api/now/processflow/action/action_types/{sysId}/snapshot?sysparm_transaction_scope={scope}
+       body = the model with a `steps` array grafted in
+       -> 201 Created (compiles the snapshot; also persists step input values
+          back to sys_variable_value)
+```
+
+This is the **real** snapshot compiler and supersedes `triggerPublication` for
+action types — that function ships in degraded mode (it only sets
+`status="published"` and polls, because the snapshot trigger was unknown when it
+was written). `triggerPublication` is retained for back-compat and the subflow path.
+
+```ts
+import { createClient, publishActionType } from "@tenonhq/dovetail-servicenow";
+
+var client = createClient({});
+var result = await publishActionType({
+  client: client,
+  sysId: "60e6743e33814bd07b18bc534d5c7b9e",      // sys_hub_action_type_definition
+  scopeSysId: "cd61acbbc3c85a1085b196c4e40131bd",  // sysparm_transaction_scope
+  steps: require("./fixtures/my-action.steps.json") // see caveat below
+});
+// { status: "published", httpStatus: 201, snapshotSysId?: "..." }
+```
+
+### Steps-fixture caveat (required)
+
+The GET returns **`steps: null`** even for an already-published action — the
+Designer assembles `steps` client-side from the step records. So to publish you
+**must supply a `steps` fixture** via `params.steps`. Each step's `action` field
+is remapped to the target `sysId` automatically. If you omit `steps` and the
+fetched model has no usable `steps` array, `publishActionType` throws with a clear
+message. For a faithful clone, capture the source action's `steps` from a HAR of
+the Publish call and store it as a fixture beside your driver.
+
+Full recipe and the 6-record action-type graph:
+`docs/servicenow-flow-designer-headless-authoring.md` in the CTO repo.
+
 ## Roadmap
 
 The same query-to-diff pattern will continue across the rest of the

package/dist/cli.js

@@ -68,6 +68,12 @@ const formatter_2 = require("./layout/formatter");
 const server_1 = require("./mcp/server");
 const buildFlowOrchestrator_1 = require("./flowDesigner/buildFlowOrchestrator");
 const flowDesigner_formatter_1 = require("./flowDesigner-formatter");
+const readFlow_1 = require("./flowDesigner/readFlow");
+const readActionType_1 = require("./flowDesigner/readActionType");
+const publishFlow_1 = require("./flowDesigner/publishFlow");
+const editFlow_1 = require("./flowDesigner/editFlow");
+const testFlow_1 = require("./flowDesigner/testFlow");
+const flowDesigner_formatter_2 = require("./flowDesigner-formatter");
 function parseArgs(argv) {
     var command = argv[0] || "";
     var flags = {};
@@ -299,6 +305,183 @@ async function runSetRelatedLists(flags) {
  * dove-sn mcp — run the MCP stdio server. With --smoke, list the registered
  * tools and exit. Otherwise the process stays alive until the transport closes.
  */
+/**
+ * dove-sn view-flow:
+ *   --sys-id <sys_id>   Required. sys_hub_flow sys_id (flow or subflow).
+ *   --json              Optional. Emit the structured ReadFlowResult.
+ *   --raw               Optional (with --json). Include the full processflow model.
+ *
+ * Reads the compiled flow headlessly via GET /api/now/processflow/flow/{id} and
+ * prints the ordered, nesting-aware step graph + flow variables. Read-only.
+ */
+async function runViewFlow(flags) {
+    var sysId = flags["sys-id"] || flags.sysId;
+    if (!sysId) {
+        process.stderr.write("view-flow: --sys-id <sys_id> is required\n");
+        return 1;
+    }
+    var client = (0, client_1.createClient)({});
+    var result = await (0, readFlow_1.readFlow)({ client: client, sysId: sysId, raw: flags.raw === "true" });
+    if (flags.json === "true") {
+        process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+        return 0;
+    }
+    process.stdout.write((0, flowDesigner_formatter_2.formatReadFlowResult)(result) + "\n");
+    return 0;
+}
+/**
+ * dove-sn view-action:
+ *   --sys-id <sys_id>   Required. sys_hub_action_type_definition sys_id.
+ *   --scope <sys_id>    Required. Application scope (sysparm_transaction_scope).
+ *   --json [--raw]      Optional. Structured ReadActionTypeResult / full model.
+ *
+ * Reads a Custom Action Type's compiled model (identity, inputs, outputs). Read-only.
+ */
+async function runViewAction(flags) {
+    var sysId = flags["sys-id"] || flags.sysId;
+    var scope = flags.scope || flags.scopeSysId;
+    if (!sysId || !scope) {
+        process.stderr.write("view-action: --sys-id <sys_id> and --scope <sys_id> are required\n");
+        return 1;
+    }
+    var client = (0, client_1.createClient)({});
+    var result = await (0, readActionType_1.readActionType)({
+        client: client,
+        sysId: sysId,
+        scopeSysId: scope,
+        raw: flags.raw === "true"
+    });
+    if (flags.json === "true") {
+        process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+        return 0;
+    }
+    process.stdout.write((0, flowDesigner_formatter_2.formatReadActionTypeResult)(result) + "\n");
+    return 0;
+}
+/**
+ * dove-sn publish-flow:
+ *   --sys-id <sys_id>   Required. sys_hub_flow sys_id (flow or subflow) to publish.
+ *   --scope <sys_id>    Optional. sysparm_transaction_scope (defaults to the model's scope).
+ *   --json              Optional. Emit the structured PublishFlowResult.
+ *
+ * Compiles the flow's snapshot via POST /api/now/processflow/flow/{id}/snapshot —
+ * a WRITE that recompiles the current design. Use the Designer to edit, then this
+ * to publish. (For edited content, the library publishFlow accepts a model.)
+ */
+async function runPublishFlow(flags) {
+    var sysId = flags["sys-id"] || flags.sysId;
+    if (!sysId) {
+        process.stderr.write("publish-flow: --sys-id <sys_id> is required\n");
+        return 1;
+    }
+    var params = {
+        client: (0, client_1.createClient)({}),
+        sysId: sysId
+    };
+    if (flags.scope || flags.scopeSysId) {
+        params.scopeSysId = flags.scope || flags.scopeSysId;
+    }
+    var result = await (0, publishFlow_1.publishFlow)(params);
+    if (flags.json === "true") {
+        process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+        return 0;
+    }
+    process.stdout.write("Published flow " + sysId + " (HTTP " + result.httpStatus + ")"
+        + (result.snapshotSysId ? " — snapshot " + result.snapshotSysId : "") + "\n");
+    return 0;
+}
+/**
+ * dove-sn test-flow:
+ *   --sys-id <sys_id>   Required. sys_hub_flow sys_id (flow or subflow).
+ *   --execute           Optional. Actually run it (default is validate-only).
+ *   --confirm           Required with --execute. A deliberate run-for-real gate.
+ *   --inputs <json>     Optional. JSON object of inputs (or --inputs-json <path>).
+ *   --json              Optional. Emit the structured TestFlowResult.
+ *
+ * Default (no --execute) is a safe pre-flight: published? readable? inputs match
+ * declared variables? --execute POSTs the FlowAPI runner endpoint (see
+ * resources/runFlow.md). Executing a flow can cause real side effects.
+ */
+async function runTestFlow(flags) {
+    var sysId = flags["sys-id"] || flags.sysId;
+    if (!sysId) {
+        process.stderr.write("test-flow: --sys-id <sys_id> is required\n");
+        return 1;
+    }
+    var inputs = {};
+    if (flags["inputs-json"]) {
+        inputs = JSON.parse(fs.readFileSync(flags["inputs-json"], "utf8"));
+    }
+    else if (flags.inputs) {
+        inputs = JSON.parse(flags.inputs);
+    }
+    var params = {
+        client: (0, client_1.createClient)({}),
+        sysId: sysId,
+        mode: flags.execute === "true" ? "execute" : "validate",
+        inputs: inputs,
+        confirm: flags.confirm === "true"
+    };
+    if (flags.runner) {
+        params.runnerPath = flags.runner;
+    }
+    var result = await (0, testFlow_1.testFlow)(params);
+    if (flags.json === "true") {
+        process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+        return 0;
+    }
+    process.stdout.write("[" + result.mode + "] ok=" + result.ok + "\n");
+    for (var i = 0; i < result.notes.length; i += 1) {
+        process.stdout.write("  " + result.notes[i] + "\n");
+    }
+    return result.ok ? 0 : 2;
+}
+/**
+ * dove-sn edit-flow:
+ *   --sys-id <sys_id>     Required. sys_hub_flow sys_id (flow or subflow).
+ *   --from-json <path>    Required. JSON EditFlowOps { rename?, description?, patchStepInputs? }.
+ *   --apply               Optional. Publish the edit (default is a dry-run diff).
+ *   --scope <sys_id>      Optional. sysparm_transaction_scope for the publish.
+ *   --json                Optional. Emit the structured EditFlowResult.
+ *
+ * Reads the model, applies the declarative edits, and (with --apply) re-publishes
+ * via the snapshot endpoint. Without --apply it prints the would-be changes.
+ */
+async function runEditFlow(flags) {
+    var sysId = flags["sys-id"] || flags.sysId;
+    if (!sysId) {
+        process.stderr.write("edit-flow: --sys-id <sys_id> is required\n");
+        return 1;
+    }
+    if (!flags["from-json"]) {
+        process.stderr.write("edit-flow: --from-json <path> (EditFlowOps) is required\n");
+        return 1;
+    }
+    var ops = JSON.parse(fs.readFileSync(flags["from-json"], "utf8"));
+    var params = {
+        client: (0, client_1.createClient)({}),
+        sysId: sysId,
+        ops: ops,
+        apply: flags.apply === "true"
+    };
+    if (flags.scope || flags.scopeSysId) {
+        params.scopeSysId = flags.scope || flags.scopeSysId;
+    }
+    var result = await (0, editFlow_1.editFlow)(params);
+    if (flags.json === "true") {
+        process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+        return 0;
+    }
+    process.stdout.write("[" + result.status + "] " + result.changes.length + " change(s)"
+        + (result.snapshotSysId ? " — snapshot " + result.snapshotSysId : "") + "\n");
+    for (var i = 0; i < result.changes.length; i += 1) {
+        process.stdout.write("  + " + result.changes[i] + "\n");
+    }
+    for (var w = 0; w < result.warnings.length; w += 1) {
+        process.stdout.write("  ! " + result.warnings[w] + "\n");
+    }
+    return 0;
+}
 async function runMcp(flags) {
     if (flags.smoke === "true") {
         await (0, server_1.runSmoke)();
@@ -324,6 +507,16 @@ function printHelp() {
         "                      [--view <v>] [--scope <s>] [--prune false] [--dry-run] [--json])\n" +
         "  build-flow         Author Custom Action Types and Subflows from a JSON spec\n" +
         "                     (--from-json <path> [--update-set <sys_id>] [--dry-run] [--skip-publish] [--json])\n" +
+        "  view-flow          Read a flow/subflow's compiled step graph (read-only)\n" +
+        "                     (--sys-id <sys_id> [--json] [--raw])\n" +
+        "  view-action        Read a Custom Action Type's model — inputs/outputs (read-only)\n" +
+        "                     (--sys-id <sys_id> --scope <sys_id> [--json] [--raw])\n" +
+        "  publish-flow       Compile a flow/subflow snapshot (write)\n" +
+        "                     (--sys-id <sys_id> [--scope <sys_id>] [--json])\n" +
+        "  test-flow          Validate (default) or run a flow/subflow\n" +
+        "                     (--sys-id <sys_id> [--execute --confirm] [--inputs <json>] [--json])\n" +
+        "  edit-flow          Patch a flow/subflow (rename, description, step inputs) + publish\n" +
+        "                     (--sys-id <sys_id> --from-json <ops.json> [--apply] [--scope <sys_id>] [--json])\n" +
         "  mcp                Run the MCP stdio server (--smoke lists tools and exits)\n");
 }
 async function main() {
@@ -335,6 +528,21 @@ async function main() {
     if (parsed.command === "build-flow") {
         return await runBuildFlowCmd(parsed.flags);
     }
+    if (parsed.command === "view-flow") {
+        return await runViewFlow(parsed.flags);
+    }
+    if (parsed.command === "view-action") {
+        return await runViewAction(parsed.flags);
+    }
+    if (parsed.command === "publish-flow") {
+        return await runPublishFlow(parsed.flags);
+    }
+    if (parsed.command === "test-flow") {
+        return await runTestFlow(parsed.flags);
+    }
+    if (parsed.command === "edit-flow") {
+        return await runEditFlow(parsed.flags);
+    }
     if (parsed.command === "create-view") {
         await runCreateView(parsed.flags);
         return 0;

package/dist/client.d.ts

@@ -102,5 +102,16 @@ export interface ServiceNowClient {
             [k: string]: any;
         }>;
     };
+    now: {
+        /**
+         * GET an arbitrary native ServiceNow REST path (e.g. /api/now/processflow/...).
+         * Basic auth, same credentials/retry/throttle as the rest of the client.
+         * Use for endpoints that aren't the Table API or the Dovetail Scripted REST API
+         * — currently the Flow Designer processflow endpoints. Returns the raw response body.
+         */
+        get: <T = any>(path: string) => Promise<T>;
+        /** POST an arbitrary native ServiceNow REST path with a JSON body. See `get`. */
+        post: <T = any>(path: string, body: any) => Promise<T>;
+    };
 }
 export declare function createClient(config?: ServiceNowClientConfig): ServiceNowClient;

package/dist/client.js

@@ -296,6 +296,14 @@ function createClient(config = {}) {
                 var data = await dovetailRequest("POST", "deleteRecord", { table: params.table, sys_id: params.sys_id }, null, "claude.deleteRecord(" + params.table + ")");
                 return data.result || data;
             }
+        },
+        now: {
+            get: function (path) {
+                return request({ method: "GET", url: path }, "now.get(" + path + ")");
+            },
+            post: function (path, body) {
+                return request({ method: "POST", url: path, data: body }, "now.post(" + path + ")");
+            }
         }
     };
 }

package/dist/flowDesigner/buildFlowOrchestrator.d.ts

@@ -29,6 +29,15 @@ export interface BuildFlowOptions {
     skipPublish?: boolean;
     /** Forwarded to triggerPublication. Useful for tight tests; defaults to its own 15s. */
     snapshotTimeoutMs?: number;
+    /**
+     * Steps fixture for publishing an action-type clone. The action-type model GET
+     * returns `steps: null`, so the real publisher (publishActionType) needs a
+     * steps array. When provided for kind="actionType", the orchestrator uses the
+     * real processflow publisher; without it, action-type publish falls back to
+     * the degraded triggerPublication. Ignored for subflows (publishFlow re-posts
+     * the full model, which already carries the instance graph).
+     */
+    steps?: Array<Record<string, any>>;
 }
 /**
  * Outcome categories. Maps directly to CLI exit codes:

package/dist/flowDesigner/buildFlowOrchestrator.js

@@ -14,6 +14,8 @@ const cloneSubflow_1 = require("./cloneSubflow");
 const cloneActionType_1 = require("./cloneActionType");
 const verifyArtifact_1 = require("./verifyArtifact");
 const triggerPublication_1 = require("./triggerPublication");
+const publishFlow_1 = require("./publishFlow");
+const publishActionType_1 = require("./publishActionType");
 const RX_SYS_ID = /^[0-9a-f]{32}$/;
 function unrecoverable(spec, stage, message) {
     return {
@@ -23,6 +25,50 @@ function unrecoverable(spec, stage, message) {
         error: { stage: stage, message: message },
     };
 }
+/**
+ * Publish a freshly cloned artifact. Tries the real processflow publisher first
+ * (publishFlow for subflows, publishActionType for action types when a steps
+ * fixture is supplied), and falls back to the degraded triggerPublication if the
+ * real path is unavailable or throws. Never throws — always returns a
+ * TriggerPublicationResult-compatible object so the caller's outcome mapping is
+ * unchanged (status "published" => done; anything else => needs-ui-publish).
+ */
+async function publishArtifact(client, spec, sysId, opts) {
+    try {
+        if (spec.kind === "subflow") {
+            var pf = await (0, publishFlow_1.publishFlow)({ client: client, sysId: sysId, scopeSysId: spec.newScope });
+            return { status: "published", snapshotSysId: pf.snapshotSysId, pushSucceeded: true };
+        }
+        // actionType: the real publisher needs a steps fixture (model GET => steps:null).
+        if (spec.kind === "actionType" && opts.steps && opts.steps.length > 0) {
+            var pa = await (0, publishActionType_1.publishActionType)({
+                client: client,
+                sysId: sysId,
+                scopeSysId: spec.newScope,
+                steps: opts.steps,
+            });
+            return { status: "published", snapshotSysId: pa.snapshotSysId, pushSucceeded: true };
+        }
+    }
+    catch (err) {
+        // Real publish failed — fall through to the degraded path below, which is
+        // engineered to surface a UI publish URL rather than throw.
+    }
+    try {
+        return await (0, triggerPublication_1.triggerPublication)({
+            client: client,
+            sysId: sysId,
+            kind: spec.kind,
+            updateSetSysId: spec.updateSetSysId,
+            snapshotTimeoutMs: opts.snapshotTimeoutMs,
+        });
+    }
+    catch (err) {
+        // triggerPublication is engineered to never throw on the happy path, but
+        // defensive: treat unexpected throws as needs-ui-publish.
+        return { status: "needs-ui-publish", pushSucceeded: false, uiPublishUrl: undefined };
+    }
+}
 function validateSpec(spec) {
     if (!spec || typeof spec !== "object")
         throw new Error("spec must be a JSON object");
@@ -163,27 +209,14 @@ async function runBuildFlow(client, rawSpec, opts = {}) {
             verify: verify,
         };
     }
-    // Phase 4: publication (best-effort, degraded mode until Phase 0 lands).
+    // Phase 4: publication. Try the real processflow publisher first (compiles
+    // the snapshot via the Designer's own Publish endpoint — basic auth, 2xx),
+    // and fall back to the degraded triggerPublication (status flip + poll, UI
+    // fallback) only if the real path throws. This is what replaces the long-
+    // standing "needs-ui-publish" default for the common case.
     var publish;
     if (!opts.skipPublish) {
-        try {
-            publish = await (0, triggerPublication_1.triggerPublication)({
-                client: client,
-                sysId: cloneResult.sysId,
-                kind: spec.kind,
-                updateSetSysId: spec.updateSetSysId,
-                snapshotTimeoutMs: opts.snapshotTimeoutMs,
-            });
-        }
-        catch (err) {
-            // triggerPublication is engineered to never throw on the happy path,
-            // but defensive: treat unexpected throws as needs-ui-publish.
-            publish = {
-                status: "needs-ui-publish",
-                pushSucceeded: false,
-                uiPublishUrl: undefined,
-            };
-        }
+        publish = await publishArtifact(client, spec, cloneResult.sysId, opts);
     }
     var artifact = {
         sysId: cloneResult.sysId,

package/dist/flowDesigner/editFlow.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Edit a Flow Designer flow or subflow in place, headless.
+ *
+ * Strategy: read the compiled model (GET /processflow/flow/{id}), apply a small
+ * set of declarative mutations to it, then re-publish it (POST .../snapshot via
+ * publishFlow). The publish POST persists step input values back to the design
+ * records — the same mechanism the Designer's Publish button uses — so a patched
+ * model lands in both the running snapshot and the records the Designer reads.
+ *
+ * Supported edits (intentionally narrow + safe — no structural step add/remove,
+ * which requires the V2 instance graph and is out of scope here):
+ *   - rename:          set name / internalName on the flow
+ *   - description:     set the flow description
+ *   - patchStepInputs: set named input values on specific steps (by uiId or label)
+ *
+ * Anything unmatched is reported in `result.warnings` rather than silently
+ * dropped, so a typo'd step label or input name is visible.
+ *
+ * By default this is a DRY RUN — it computes and returns the diff WITHOUT
+ * publishing. Pass `apply: true` to actually publish the edited model (a write).
+ */
+import type { ServiceNowClient } from "../client";
+export interface StepInputPatch {
+    /** Identify the step by its uiUniqueIdentifier OR its label (name). */
+    step: string;
+    /** The input's `name` on the action instance. */
+    input: string;
+    /** New value to set (may be any JSON value, including the empty string). */
+    value?: any;
+}
+export interface EditFlowOps {
+    rename?: {
+        name?: string;
+        internalName?: string;
+    };
+    description?: string;
+    patchStepInputs?: Array<StepInputPatch>;
+}
+export interface EditFlowParams {
+    client: ServiceNowClient;
+    /** sys_id of the sys_hub_flow (flow or subflow) to edit. */
+    sysId: string;
+    ops: EditFlowOps;
+    /** When true, publish the edited model. When false/omitted, dry-run (no write). */
+    apply?: boolean;
+    /** Override sysparm_transaction_scope for the publish; defaults to the model's scope. */
+    scopeSysId?: string;
+}
+export interface EditFlowResult {
+    /** "dry-run" (computed, not published) or "published". */
+    status: "dry-run" | "published";
+    /** Human-readable list of changes that were applied to the model. */
+    changes: Array<string>;
+    /** Requested edits that could not be matched (e.g. unknown step or input). */
+    warnings: Array<string>;
+    /** Present when status="published". */
+    snapshotSysId?: string;
+}
+export declare function editFlow(params: EditFlowParams): Promise<EditFlowResult>;