procesio-cli 0.1.1__py3-none-any.whl

procesio_cli/tools/procesio/dto/process/normalize.py

@@ -0,0 +1,74 @@
+"""Deterministic DESIGNER-layer normalizer.
+
+Regenerates an action's `customData.configuration[].settings[].value` (the DESIGNER layer the Process
+Designer reads) from that action's RUNTIME `parameters[]` (the source of truth = what executes), for
+the ONE class where the two layers are a clean, reversible mirror: a STRING setting value that may hold
+a `<%N%>` placeholder. It substitutes each `<%N%>` for its bound variable GUID (with the attribute chain,
+`varId.attrId...`), which is exactly what the designer expects and what the runtime placeholder maps to.
+This permanently kills the "customData holds `<%N%>` instead of the variable GUID -> designer paints it
+red" class of bug: hand-place an action however, then normalize, and a string designer value can no
+longer drift from its runtime parameter.
+
+SCOPE - deliberately STRING-ONLY. LIST/dict-shaped settings (process-inputs/outputs, map-parameters,
+map-process-data, document-mapper, decisional-case, ai-decisional-case) are LEFT UNTOUCHED, because their
+runtime<->designer relationship is NOT a clean mirror: the builder's build-from-spec transforms drop the
+attribute chain on subprocess maps and emit the runtime shape for map-parameters, i.e. regenerating them
+from live runtime CORRUPTS them (verified live: process-outputs `varId.attrId` -> `varId`). Those settings
+also never carry the `<%N%>`-in-a-string bug (they store GUID-form refs), so skipping them loses nothing.
+The flowlint CUSTOMDATA_PLACEHOLDER guard remains the backstop for any residual case.
+
+REUSES `builder._config_value_from_param` (never re-implements it). Contract: mutate `flow` IN PLACE
+(matches flowpatch's _load->mutate->_save model); return a diff report. Idempotent and a NO-OP on
+already-compliant flows (a value with no `<%N%>` passes through byte-identical).
+"""
+from __future__ import annotations
+
+from tools.procesio.dto.process import builder as _b
+
+
+def _index_settings(cfg_tree: list) -> dict:
+    """{setting.id: setting}, recursing into list-valued settings (side-pannel nesting) - mirrors
+    the builder's _apply_values_to_config index()."""
+    byid: dict = {}
+
+    def walk(settings):
+        for s in settings or []:
+            if isinstance(s, dict):
+                if s.get("id"):
+                    byid[s["id"]] = s
+                if isinstance(s.get("value"), list):
+                    walk(s["value"])
+    for tab in cfg_tree or []:
+        walk(tab.get("settings") or [])
+    return byid
+
+
+def normalize_designer_layer(flow: dict) -> dict:
+    """Regenerate STRING designer setting values from their runtime parameters, in place. Returns a
+    report {changed: bool, actions: [{id,name,settings:[{id,type,label}]}], warnings: [...]}."""
+    report: dict = {"changed": False, "actions": [], "warnings": []}
+    for a in flow.get("actions") or []:
+        cfg_tree = (a.get("customData") or {}).get("configuration") or []
+        byid = _index_settings(cfg_tree)
+        changed_settings: list = []
+        for p in a.get("parameters") or []:
+            s = byid.get(p.get("tabPropertyId"))
+            if s is None:
+                # a runtime param with no designer setting to mirror into - a malformed/hand-built
+                # node smell. Never clobber; surface it so a human looks.
+                if p.get("value") not in (None, "", [], {}):
+                    report["warnings"].append({"action": a.get("actionName"),
+                                               "param": p.get("tabPropertyId"), "why": "param_without_setting"})
+                continue
+            # STRING-ONLY: only a string designer value can hold the <%N%> bug and is a clean mirror of
+            # its runtime param. Anything list/dict-shaped is left exactly as-is (see module doc).
+            if not isinstance(s.get("value"), str):
+                continue
+            new = _b._config_value_from_param(p.get("value"), p.get("variable"))
+            if new != s.get("value"):
+                s["value"] = new
+                changed_settings.append({"id": s.get("id"), "type": s.get("type"), "label": s.get("label")})
+        if changed_settings:
+            report["changed"] = True
+            report["actions"].append({"id": a.get("id"), "name": a.get("actionName"), "settings": changed_settings})
+    return report

procesio_cli/tools/procesio/dto/process/template.dto.json

@@ -0,0 +1,32 @@
+{
+  "_note": "Golden FlowRequestDto shape (POST /api/Projects body), PascalCase. The client supplies Id (the gateway persists it and returns empty on success). Variables -> VariableDto; Actions -> ActionDto with CustomData (designer/position) + Parameters (TabPropertyId binding); Ports are edges held on the SOURCE action (plus a null->Start entry edge). Verified live 2026-06-24: validates, persists, runs to STATUS_FINISH. Most fields below are filled by builder.py.",
+  "Id": "<uuid: flow>",
+  "ParentId": null,
+  "Status": 1,
+  "Title": "<title>",
+  "Description": "",
+  "IsValid": true,
+  "Active": true,
+  "Timeout": 0,
+  "CurrentActionId": null,
+  "DebugMode": false,
+  "IsNotification": false,
+  "Variables": [
+    {"Id": "<uuid: var>", "ContextId": null, "DataType": "0317bfee-b2f5-4bde-bfe8-121212121222", "Type": 30, "Name": "result", "DefaultValue": null, "IsList": false, "IsError": false, "IsRequired": false}
+  ],
+  "Actions": [
+    {
+      "Id": "<uuid: action>", "FlowId": "<uuid: flow>", "TemplateId": "<actionId>",
+      "ParentId": null, "VariableErrorId": null, "Status": 1, "Category": "",
+      "ActionName": "Generate GUID", "ActionTemplateName": "Generate GUID",
+      "Ports": [{"Id": "<uuid: port>", "FlowId": "<uuid: flow>", "SourceId": "<src action>", "DestinationId": "<dst action>", "Type": 0, "State": 1, "Data": {}, "Errors": {}, "Config": {}}],
+      "Parameters": [{"TabPropertyId": "<template property id>", "Variable": [{"id": 0, "variableId": "<uuid: var>", "attribute": null}], "Value": "<%0%>"}],
+      "CustomData": {"type": "square", "name": "Generate GUID", "icon": "vpn_key", "position": {"x": 400, "y": 300}, "configuration": [], "inputPorts": 1, "outputPorts": 1, "wasDropped": true, "areaSize": {"width": 48, "height": 48, "x": 0, "y": 0}},
+      "IsTestable": true, "IsDisabled": false, "BreakPoint": null, "TestValues": null, "ErrorMessage": "", "Events": null
+    }
+  ],
+  "Webhooks": [],
+  "CustomResponse": null,
+  "DataRetention": null,
+  "CanvasData": null
+}

procesio_cli/tools/procesio/dto/refdata.py

@@ -0,0 +1,87 @@
+"""Bundled platform reference data + lookups for the DTO builders.
+
+The builders are PURE (config -> DTO, no network). Anything they need from the
+platform that is *stable* (primitive data-type ids, procesio built-in models)
+ships bundled in data/platform_types.json so a build needs no live calls. Live,
+workspace-specific ids (a credential template, an existing data model referenced
+by a webhook, an action template's properties) are resolved by the handler and
+passed into the builder as `ctx`, keeping the builder side-effect free.
+"""
+from __future__ import annotations
+
+import json
+from functools import lru_cache
+from pathlib import Path
+
+_DATA = Path(__file__).resolve().parent / "data" / "platform_types.json"
+
+# PrimaryDataType enum (Domain/Enums) — the value carried as CsharpCorrespondent.
+CSHARP = {
+    "boolean": 10, "integer": 20, "float": 30, "double": 40, "string": 50,
+    "date": 60, "relationship": 70, "time": 80, "datetime": 90, "guid": 100,
+    "uri": 110, "json": 120, "credentials": 130, "object": 140,
+}
+
+
+@lru_cache(maxsize=1)
+def platform_types() -> dict:
+    return json.loads(_DATA.read_text(encoding="utf-8"))
+
+
+@lru_cache(maxsize=1)
+def _primitive_by_name() -> dict[str, dict]:
+    out: dict[str, dict] = {}
+    for d in platform_types().get("primary", []):
+        if d.get("name"):
+            out[d["name"].strip().lower()] = d
+    return out
+
+
+@lru_cache(maxsize=1)
+def _procesio_by_name() -> dict[str, dict]:
+    out: dict[str, dict] = {}
+    for d in platform_types().get("procesio", []):
+        if d.get("name"):
+            out[d["name"].strip().lower()] = d
+    return out
+
+
+# Friendly aliases -> the platform's primitive type name.
+_ALIAS = {
+    "bool": "boolean", "int": "integer", "long": "integer", "number": "double",
+    "text": "string", "str": "string", "datetime": "datetime", "date-time": "datetime",
+    "uuid": "guid",
+}
+
+
+def primitive_type_id(name: str) -> str:
+    """Map a primitive type name (case-insensitive, with aliases) to its stable
+    platform DataType id. Raises KeyError for an unknown type."""
+    key = (name or "").strip().lower()
+    key = _ALIAS.get(key, key)
+    prim = _primitive_by_name()
+    if key in prim:
+        return prim[key]["id"]
+    raise KeyError(
+        f"unknown primitive type {name!r}; known: {sorted(prim)} (aliases: {sorted(_ALIAS)})"
+    )
+
+
+def primitive_names() -> list[str]:
+    """The accepted primitive type names (for schema enums)."""
+    return sorted(set(_primitive_by_name()) | set(_ALIAS))
+
+
+def csharp_correspondent(name: str) -> int:
+    key = (name or "").strip().lower()
+    key = _ALIAS.get(key, key)
+    return CSHARP.get(key, 0)
+
+
+def procesio_model_id(name: str) -> str:
+    """Id of a procesio built-in data model (e.g. 'FileDataModel')."""
+    by = _procesio_by_name()
+    key = (name or "").strip().lower()
+    if key in by:
+        return by[key]["id"]
+    raise KeyError(f"unknown procesio model {name!r}; known: {sorted(by)}")

procesio_cli/tools/procesio/dto/registry.py

@@ -0,0 +1,27 @@
+"""Registry of DTO components. Explicit (no import magic) for reliability —
+add a component's COMPONENT here and it gets <name>-create / <name>-edit actions.
+"""
+from __future__ import annotations
+
+from functools import lru_cache
+
+from tools.procesio.dto.framework import Component
+
+
+@lru_cache(maxsize=1)
+def all_components() -> dict[str, Component]:
+    from tools.procesio.dto.credential import builder as credential
+    from tools.procesio.dto.datatype import builder as datatype
+    from tools.procesio.dto.document import builder as document
+    from tools.procesio.dto.form import builder as form
+    from tools.procesio.dto.process import builder as process
+    from tools.procesio.dto.webhook import builder as webhook
+    comps = [
+        datatype.COMPONENT,
+        process.COMPONENT,
+        credential.COMPONENT,
+        document.COMPONENT,
+        webhook.COMPONENT,
+        form.COMPONENT,
+    ]
+    return {c.name: c for c in comps}

procesio_cli/tools/procesio/dto/webhook/builder.py

@@ -0,0 +1,142 @@
+"""Webhook builder — PURE config -> WebhookDto.
+
+A webhook ties an inbound HTTP request to a process flow. Its payload shape is a
+*webhook-type* data model (DataModelTypeParam.Webhook = 2) generated from a sample
+payload via POST /api/Webhooks/generate-data (done in prepare_ctx).
+
+Working create recipe (cracked live 2026-06-24): POST /api/Webhooks with the
+generated DataModel embedded + DataModelId + the sample Definition + IsEdited=true
+(PascalCase). Without the generated webhook-type DataModel the gateway returns a
+generic 502 "resource is not able to be created or modified".
+
+API:
+  - generate model: POST /api/Webhooks/generate-data {Definition: "<json>"} -> {dataModel, payloadIsList}
+  - Create: POST /api/Webhooks (WebhookDto) -> created webhook
+  - Get:    GET  /api/Webhooks/{id}
+  - Edit:   PUT  /api/Webhooks
+  - Trigger (anonymous): GET|POST /api/Webhooks/launch/{id}
+"""
+from __future__ import annotations
+
+import json
+import uuid
+from pathlib import Path
+
+from tools.procesio import config
+from tools.procesio.dto.framework import Component
+from tools.procesio.errors import UsageError
+
+DIR = Path(__file__).resolve().parent
+
+_TYPE = {"auto": 0, "manual": 1}
+_RESP_TYPE = {"staticjson": 1, "static": 1, "javascript": 2, "js": 2, "jsonpath": 3}
+
+
+def _new_id(ctx) -> str:
+    return (ctx.get("new_id") or (lambda: str(uuid.uuid4())))()
+
+
+def _custom_response(cfg):
+    if not cfg:
+        return None
+    ct = cfg.get("type", "staticjson")
+    return {"ConfigType": _RESP_TYPE.get(str(ct).strip().lower(), ct),
+            "Config": cfg.get("config", "")}
+
+
+def build(config: dict, ctx: dict) -> dict:
+    dm = ctx.get("data_model")
+    if dm is None:
+        raise UsageError("webhook build needs a generated data model in ctx "
+                         "(prepare_ctx calls /api/Webhooks/generate-data on the sample)")
+    sample = config.get("sample", {})
+    definition = config.get("definition") or json.dumps(sample)
+    wtype = config.get("type", "manual")
+    return {
+        "Id": ctx.get("webhook_id") or _new_id(ctx),
+        "Name": config["name"],
+        "PayloadIsList": bool(config.get("payloadIsList", ctx.get("payload_is_list", False))),
+        "HasHeader": bool(config.get("hasHeader", False)),
+        "HasQuery": bool(config.get("hasQuery", False)),
+        "DataModelId": dm.get("id"),
+        "Type": _TYPE.get(str(wtype).strip().lower(), wtype),
+        "Definition": definition,
+        "IsEdited": True,
+        "DataModel": dm,
+        "CustomResponseConfig": _custom_response(config.get("customResponse")),
+    }
+
+
+def prepare_ctx(client, config: dict) -> dict:
+    """Generate the webhook-type data model from the sample payload."""
+    sample = config.get("sample")
+    definition = config.get("definition") or (json.dumps(sample) if sample is not None else None)
+    if not definition:
+        raise UsageError("provide config.sample (a representative payload object) "
+                         "so the webhook data model can be generated")
+    gen = client.post("/api/Webhooks/generate-data", {"Definition": definition})
+    return {"data_model": gen.get("dataModel"), "payload_is_list": gen.get("payloadIsList", False)}
+
+
+def _extract_id(resp, dto):
+    if isinstance(resp, dict):
+        return resp.get("id") or resp.get("Id") or dto.get("Id")
+    return dto.get("Id") if isinstance(dto, dict) else None
+
+
+def _edit(client, resource_id, config, ctx):
+    ctx = dict(ctx)
+    ctx["webhook_id"] = resource_id
+    dto = build(config, ctx)
+    client.put("/api/Webhooks", dto)
+    return client.get(f"/api/Webhooks/{resource_id}")
+
+
+def _create(client, dto, ctx):
+    """Create the webhook. For an AUTO webhook (Type=0) run the listen+capture flow
+    the designer uses: create -> get URL -> start listening -> send a request to the
+    URL -> capture the data -> stop. (The gateway won't persist Type=0 via REST, so
+    the stored webhook is Type=1; AUTO is the capture *method*.) The capture log is
+    returned under `_capture`."""
+    auto = dto.get("Type") == 0
+    body = dict(dto)
+    if auto:
+        body["Type"] = 1
+    resp = client.post("/api/Webhooks", body)
+    rid = resp.get("id") if isinstance(resp, dict) and resp.get("id") else dto.get("Id")
+    if not auto:
+        return resp
+    capture = {"method": "AUTO listen+capture", "webhookId": rid,
+               "url": f"{config.web_base(client.profile)}/api/Webhooks/launch/{rid}"}
+    conn = str(uuid.uuid4())
+    listen = {"ConnectionId": conn, "Listen": True, "ListenType": 1, "WebhookId": rid,
+              "WebhookName": dto.get("Name"), "HasQuery": dto.get("HasQuery", False),
+              "HasHeader": dto.get("HasHeader", False), "HandshakeConfig": None}
+    try:
+        client.post("/api/Webhooks/listen", listen)        # start listening
+        capture["listening"] = True
+        sample = dto.get("Definition")                     # send a request to the URL
+        client.post(f"/api/Webhooks/launch/{rid}", json.loads(sample) if sample else {})
+        capture["sent_sample"] = True
+        client.post("/api/Webhooks/listen", {**listen, "Listen": False})  # stop
+        capture["captured"] = True
+    except Exception as e:  # noqa: BLE001 - the webhook exists either way
+        capture["error"] = str(e)[:200]
+    out = client.get(f"/api/Webhooks/{rid}")
+    if isinstance(out, dict):
+        out["_capture"] = capture
+    return out
+
+
+COMPONENT = Component(
+    name="webhook",
+    description="PROCESIO webhook: an inbound HTTP trigger whose payload is a generated data model.",
+    dir=DIR,
+    build=build,
+    create_endpoint=("POST", "/api/Webhooks"),
+    get_path="/api/Webhooks/{id}",
+    extract_id=_extract_id,
+    prepare_ctx=prepare_ctx,
+    create=_create,
+    edit=_edit,
+)

procesio_cli/tools/procesio/dto/webhook/config.schema.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "PROCESIO Webhook config",
+  "description": "Create/edit a webhook. The payload data model is generated from 'sample' (a representative payload). Attach the webhook to a process to trigger it.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["name", "sample"],
+  "properties": {
+    "name": {"type": "string", "minLength": 1},
+    "sample": {"description": "a representative inbound payload object/array; its shape becomes the webhook data model"},
+    "definition": {"type": "string", "description": "raw JSON definition (alternative to sample)"},
+    "type": {"type": "string", "enum": ["auto", "manual"], "default": "manual"},
+    "hasHeader": {"type": "boolean", "default": false},
+    "hasQuery": {"type": "boolean", "default": false},
+    "payloadIsList": {"type": "boolean"},
+    "customResponse": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "type": {"type": "string", "enum": ["staticjson", "static", "javascript", "js", "jsonpath"]},
+        "config": {"type": "string"}
+      }
+    }
+  }
+}

procesio_cli/tools/procesio/dto/webhook/description.md

@@ -0,0 +1,92 @@
+# Webhook sub-tool
+
+Create/edit a PROCESIO **webhook** — an inbound HTTP trigger. Its payload shape is
+a webhook-type data model generated from a sample; attach the webhook to a process
+to fire the flow when the URL is called.
+
+## Config
+
+```json
+{
+  "name": "Order webhook",
+  "sample": {"orderId": "abc", "amount": 12.5, "items": ["a", "b"]},
+  "type": "manual",
+  "hasHeader": false,
+  "hasQuery": false,
+  "customResponse": {"type": "staticjson", "config": "{\"ok\":true}"}
+}
+```
+
+- **sample** — a representative payload; the builder calls `generate-data` to infer
+  the webhook data model from it (or pass a raw `definition` string).
+- **type** — `manual` (1, fires on call — verified) or `auto` (0).
+- **customResponse** — optional synchronous response: `staticjson` / `javascript` / `jsonpath`.
+
+## API contract (verified live 2026-06-24)
+
+- **Generate model:** `POST /api/Webhooks/generate-data {Definition}` → `{dataModel, payloadIsList}`
+  (the `dataModel` is a webhook-type model, `type:2`).
+- **Create:** `POST /api/Webhooks` (`WebhookDto`) — must embed the generated
+  `DataModel` + `DataModelId` + `Definition` + `IsEdited:true`, else a generic 502.
+- **Get:** `GET /api/Webhooks/{id}`. **Edit:** `PUT /api/Webhooks`. **Delete:** `DELETE /api/Webhooks/{id}`.
+- **Trigger (anonymous):** `GET|POST|PUT|PATCH|DELETE /api/Webhooks/launch/{id}`
+  (body = payload; `?respondOk=true` for a bare 200). Verified: returns 200.
+
+## Triggering a process
+
+Attach the webhook to a flow via the flow's `Webhooks[]` (`WebhookInstanceDto`) and
+bind the generated webhook payload as **one model object** to a compatible model-typed
+process input. The current `WebhookVariableDto` attachment carries the process
+`variableId` and `variableType`; it does not provide a field-by-field mapping table
+that fans the body into several primitive inputs.
+
+For a retained process whose public contract is primitive inputs, use a bounded adapter
+process:
+
+1. accept one input typed to the generated webhook model;
+2. extract its attributes deterministically into plain process variables;
+3. synchronously call the retained process through those plain variables;
+4. bind all scripting/action errors;
+5. detach/delete a temporary adapter together with the webhook when the drill ends.
+
+A webhook attached directly to several primitive inputs can create a never-started
+instance even though the webhook DTO and process validation look correct. Prove one
+real launch by reconciling the target/child instance tree and the final business-key
+side effect; do not infer mapping success from attachment alone.
+
+## AUTO vs MANUAL (verified live 2026-06-24)
+
+Per the docs, **AUTO is the listen/capture method**, MANUAL is paste-the-payload:
+- **`type:"manual"`** — you supply `sample`; the builder generates the model from it.
+- **`type:"auto"`** — the builder runs the designer's flow: create the webhook →
+  get its URL → **start listening** → **send the sample to the URL** → capture →
+  stop. The `capture` log (`listening/sent_sample/captured`) is returned. The
+  webhook is functional (triggers processes) either way.
+  - The gateway does **not persist `Type:0`** via REST (`POST` → 502), so the
+    stored webhook is `Type:1`; AUTO is the capture *method*, not a stored type.
+    The capture step is real (listen + a live request to the URL).
+
+## Custom webhook responses
+
+The custom response is configured **on the process** (per the docs: "Custom
+Response: configured within a process; settings persist"): set the flow's
+`customResponse` (in `process-create`) to a process variable —
+`"customResponse": {"var": "responseVar"}`. **A synchronous run returns this value
+directly** (verified: `POST /api/Projects/{id}/run?runSynchronous=true` returns
+the `customResponse` value, not the status object), and so does a form's
+RUN_PROCESS trigger with `syncRun:true`. It's also stored on the instance
+(`GET …/instances/{iid}/customResponse`).
+- The webhook **definition**'s `CustomResponseConfig` (static/JS/JSON-path) is
+  designer-only (not persisted by REST). The anonymous webhook **launch** fires the
+  flow asynchronously, so it doesn't block on the response — that webhook-side
+  "respond synchronously" toggle isn't exposed over REST. The custom-response
+  *value* mechanism itself is fully working via synchronous run / form trigger.
+
+## Gotchas
+
+- `HasHeader`/`HasQuery` only persist if the data model includes header/query
+  sub-models — a body-only sample resets them to false.
+- One webhook launch can create an adapter instance, a retained child-process instance,
+  and further nested instances. Count the complete causal tree in execution budgets.
+- After an ambiguous launch response, reconcile by webhook ID, stable business key,
+  and launch window; never resend blindly.

procesio_cli/tools/procesio/dto/webhook/fixtures/order.config.json

@@ -0,0 +1,10 @@
+{
+  "name": "OrderHook",
+  "sample": {
+    "orderId": "abc",
+    "amount": 12.5
+  },
+  "type": "manual",
+  "hasHeader": false,
+  "hasQuery": false
+}

procesio_cli/tools/procesio/dto/webhook/fixtures/order.dto.json

@@ -0,0 +1,25 @@
+{
+  "Id": "00000000-0000-0000-0000-000000000001",
+  "Name": "OrderHook",
+  "PayloadIsList": false,
+  "HasHeader": false,
+  "HasQuery": false,
+  "DataModelId": "dm-1",
+  "Type": 1,
+  "Definition": "{\"orderId\": \"abc\", \"amount\": 12.5}",
+  "IsEdited": true,
+  "DataModel": {
+    "id": "dm-1",
+    "name": "InternalWebhookDto",
+    "isDataModel": true,
+    "type": 2,
+    "attributes": [
+      {
+        "id": "a1",
+        "name": "orderId",
+        "dataTypeId": "0317bfee-b2f5-4bde-bfe8-121212121214"
+      }
+    ]
+  },
+  "CustomResponseConfig": null
+}

procesio_cli/tools/procesio/dto/webhook/template.dto.json

@@ -0,0 +1,14 @@
+{
+  "_note": "Golden WebhookDto (POST /api/Webhooks body), PascalCase. The DataModel MUST be a webhook-type model (DataModelTypeParam.Webhook=2) from POST /api/Webhooks/generate-data; IsEdited:true and Definition (the sample JSON) are required, else the gateway returns a generic 502. Type: AUTO=0, MANUAL=1 (MANUAL verified live 2026-06-24; AUTO needs different handling). HasHeader/HasQuery only stick if the data model includes header/query sub-models. The server persists a fresh DataModelId on save.",
+  "Id": "<uuid: webhook>",
+  "Name": "<name>",
+  "PayloadIsList": false,
+  "HasHeader": false,
+  "HasQuery": false,
+  "DataModelId": "<generated data model id>",
+  "Type": 1,
+  "Definition": "<sample payload as JSON string>",
+  "IsEdited": true,
+  "DataModel": {"_": "the full webhook-type DataModelDto from generate-data"},
+  "CustomResponseConfig": null
+}