@code0-tech/pictor 0.0.0-mvp.10

package/dist/components/d-flow/DFlow.js

@@ -0,0 +1,375 @@
+import { jsx as K } from "react/jsx-runtime";
+import { c as U } from "../../_virtual/compiler-runtime.js";
+import { ReactFlowProvider as $, useNodesState as J, useEdgesState as Q, useUpdateNodeInternals as Z, ReactFlow as tt } from "@xyflow/react";
+import G from "react";
+import { mergeCode0Props as et } from "../../utils/utils.js";
+import '../../assets/components/d-flow/DFlow.style.css';import '../../assets/node_modules/@xyflow/react/dist/style.css';/* empty css                                              */
+/* empty css                 */
+import { DFlowFunctionDefaultCard as ot } from "./function/DFlowFunctionDefaultCard.js";
+import { DFlowFunctionGroupCard as st } from "./function/DFlowFunctionGroupCard.js";
+import { DFlowFunctionSuggestionCard as nt } from "./function/DFlowFunctionSuggestionCard.js";
+import { DFlowFunctionTriggerCard as it } from "./function/DFlowFunctionTriggerCard.js";
+import { DFlowEdge as rt } from "./edge/DFlowEdge.js";
+const at = (y, C) => {
+  if (!C || C.size === 0)
+    return {
+      nodes: y
+    };
+  const m = 75, Y = 75, N = 16, z = 0.25;
+  let _ = 0, F = !1;
+  const f = y.map((o) => ({
+    ...o
+  })), L = /* @__PURE__ */ new Map(), W = /* @__PURE__ */ new Map();
+  for (const o of f) {
+    const c = o.data?.linkingId;
+    if (c) {
+      let l = W.get(c);
+      l || (l = [], W.set(c, l)), l.push(o.id);
+    }
+    if (o.parentId && !c) {
+      let l = L.get(o.parentId);
+      l || (l = [], L.set(o.parentId, l)), l.push(o.id);
+    }
+  }
+  const M = /* @__PURE__ */ new Map(), E = /* @__PURE__ */ new Map(), w = new Map(f.map((o) => [o.id, o]));
+  for (const [o, c] of L) {
+    const l = new Array(c.length);
+    for (let b = 0; b < c.length; b++) l[b] = w.get(c[b]);
+    M.set(o, l);
+  }
+  for (const [o, c] of W) {
+    const l = new Array(c.length);
+    for (let b = 0; b < c.length; b++) l[b] = w.get(c[b]);
+    E.set(o, l);
+  }
+  const g = /* @__PURE__ */ new Map();
+  for (const o of f) {
+    const c = typeof o.style?.width == "number" ? o.style.width : void 0, l = typeof o.style?.height == "number" ? o.style.height : void 0, b = o.measured?.width && o.measured.width > 0 ? o.measured.width : void 0, P = o.measured?.height && o.measured.height > 0 ? o.measured.height : void 0;
+    g.set(o.id, {
+      w: c ?? b ?? 200,
+      h: l ?? P ?? 80
+    });
+  }
+  const B = /* @__PURE__ */ new Map(), x = (o) => {
+    if (B.has(o.id)) return B.get(o.id);
+    if (o.type !== "group") {
+      const T = g.get(o.id);
+      return B.set(o.id, T), T;
+    }
+    const c = typeof o.style?.width == "number" ? o.style.width : void 0, l = typeof o.style?.height == "number" ? o.style.height : void 0;
+    if (c !== void 0 && l !== void 0) {
+      const T = {
+        w: c,
+        h: l
+      };
+      return B.set(o.id, T), T;
+    }
+    const b = M.get(o.id) ?? [];
+    let P = 0, H = 0, v = 0;
+    for (const T of b) {
+      const V = x(T);
+      P += V.h, V.w > H && (H = V.w), v++;
+    }
+    P += m * Math.max(0, v - 1);
+    const D = {
+      w: H + 2 * N,
+      h: (v ? P : 0) + 2 * N
+    };
+    return B.set(o.id, D), D;
+  };
+  do {
+    F = !1, _++, B.clear();
+    for (const e of f) x(e);
+    const o = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map(), l = (e) => Math.round(e / 10), b = (e, h, p) => {
+      const d = [{
+        node: e,
+        cx: h,
+        cy: p,
+        phase: 0
+      }];
+      let I = 0;
+      for (; d.length; ) {
+        const t = d[d.length - 1];
+        switch (t.phase) {
+          case 0: {
+            o.set(t.node.id, {
+              x: t.cx,
+              y: t.cy
+            });
+            const {
+              w: s,
+              h: n
+            } = x(t.node);
+            t.w = s, t.h = n;
+            const i = E.get(t.node.id) ?? [], r = [], u = [];
+            for (const k of i)
+              k.type === "group" ? u.push(k) : r.push(k);
+            r.sort((k, a) => +k.data?.paramIndex - +a.data?.paramIndex), u.sort((k, a) => +k.data?.paramIndex - +a.data?.paramIndex), t.right = r, t.gParams = u;
+            let S = 0;
+            for (const k of r) S += x(k).h;
+            S += m * Math.max(0, r.length - 1), t.py = t.cy - S / 2, t.rightBottom = t.cy + n / 2, t.rightIndex = 0, t.phase = 1;
+            break;
+          }
+          case 1: {
+            if (t.rightIndex < t.right.length) {
+              const s = t.right[t.rightIndex], n = x(s), i = t.cx + t.w / 2 + Y + n.w / 2;
+              let r = t.py + n.h / 2;
+              const u = l(i), k = (c.get(u) ?? Number.NEGATIVE_INFINITY) + m;
+              r - n.h / 2 < k && (r = k + n.h / 2, t.py = r - n.h / 2), t.childKey = u, t.childPs = n, d.push({
+                node: s,
+                cx: i,
+                cy: r,
+                phase: 0
+              }), t.phase = 10;
+            } else
+              t.bottom = Math.max(t.cy + t.h / 2, t.rightBottom), t.phase = 2;
+            break;
+          }
+          case 10: {
+            const s = t.lastChildBottom;
+            c.set(t.childKey, Math.max(c.get(t.childKey) ?? Number.NEGATIVE_INFINITY, s)), t.rightBottom = Math.max(t.rightBottom, s), t.py = Math.max(t.py + t.childPs.h + m, s + m), t.rightIndex++, t.phase = 1;
+            break;
+          }
+          case 2: {
+            if (t.gParams && t.gParams.length) {
+              const s = [];
+              let n = 0;
+              for (const i of t.gParams) {
+                const r = x(i);
+                s.push(r), n += r.w;
+              }
+              n += Y * (t.gParams.length - 1), t.gSizes = s, t.gx = t.cx - n / 2, t.gy = t.bottom + m, t.rowBottom = t.bottom, t.gIndex = 0, t.phase = 3;
+            } else
+              t.phase = 4;
+            break;
+          }
+          case 3: {
+            if (t.gIndex < t.gParams.length) {
+              const s = t.gParams[t.gIndex], n = t.gSizes[t.gIndex], i = t.gx + n.w / 2, r = t.gy + n.h / 2;
+              t.gx += n.w + Y, d.push({
+                node: s,
+                cx: i,
+                cy: r,
+                phase: 0
+              }), t.childPs = n, t.phase = 30;
+            } else
+              t.bottom = t.rowBottom, t.phase = 4;
+            break;
+          }
+          case 30: {
+            const s = t.lastChildBottom;
+            t.rowBottom = Math.max(t.rowBottom, s), t.gIndex++, t.phase = 3;
+            break;
+          }
+          case 4: {
+            if (t.node.type === "group") {
+              const s = M.get(t.node.id) ?? [], n = [];
+              for (const i of s)
+                i.data?.linkingId || n.push(i);
+              t.kids = n, t.kidIndex = 0, t.curY = t.cy - t.h / 2 + N, t.phase = 5;
+            } else
+              t.phase = 6;
+            break;
+          }
+          case 5: {
+            if (t.kidIndex < t.kids.length) {
+              const s = t.kids[t.kidIndex], n = x(s), i = t.curY + n.h / 2;
+              d.push({
+                node: s,
+                cx: t.cx,
+                cy: i,
+                phase: 0
+              }), t.childPs = n, t.phase = 50;
+            } else {
+              const s = t.curY - m;
+              t.bottom = Math.max(t.bottom, s + N), t.phase = 6;
+            }
+            break;
+          }
+          case 50: {
+            const s = t.lastChildBottom;
+            t.curY = s + m, t.kidIndex++, t.phase = 5;
+            break;
+          }
+          case 6: {
+            const s = d.pop();
+            d.length ? d[d.length - 1].lastChildBottom = s.bottom : I = s.bottom;
+            break;
+          }
+        }
+      }
+      return I;
+    };
+    let P = 0;
+    for (const e of f)
+      !e.data?.linkingId && !e.parentId && (P = b(e, 0, P + x(e).h / 2) + m);
+    const H = /* @__PURE__ */ new Map();
+    for (const e of f) H.set(e.id, o.get(e.id));
+    const v = /* @__PURE__ */ new Map();
+    for (const e of f) {
+      const {
+        w: h,
+        h: p
+      } = x(e), {
+        x: d,
+        y: I
+      } = H.get(e.id);
+      v.set(e.id, {
+        x: d - h / 2,
+        y: I - p / 2
+      });
+    }
+    for (const e of f) {
+      const h = v.get(e.id);
+      let p = h.x, d = h.y;
+      if (e.parentId) {
+        const I = v.get(e.parentId);
+        p -= I.x, d -= I.y;
+      }
+      e.position = {
+        x: p,
+        y: d
+      };
+    }
+    const D = /* @__PURE__ */ new Map();
+    for (const e of f) D.set(e.id, e);
+    const T = (e) => {
+      let h = 0, p = e;
+      for (; p?.parentId && (h++, p = D.get(p.parentId), !!p); )
+        ;
+      return h;
+    }, V = [];
+    for (const e of f)
+      e.type === "group" && V.push(e);
+    V.sort((e, h) => T(h) - T(e));
+    for (const e of V) {
+      const h = [];
+      for (const a of f)
+        a.parentId === e.id && h.push(a);
+      if (!h.length) {
+        const a = typeof e.style?.width == "number" ? e.style.width : 2 * N, A = typeof e.style?.height == "number" ? e.style.height : 2 * N;
+        e.style = {
+          ...e.style,
+          width: a,
+          height: A
+        };
+        continue;
+      }
+      const p = (a) => {
+        const A = typeof a.style?.width == "number" ? a.style.width : void 0, j = typeof a.style?.height == "number" ? a.style.height : void 0, X = g.get(a.id);
+        return {
+          w: A ?? X.w,
+          h: j ?? X.h
+        };
+      };
+      let d = Number.POSITIVE_INFINITY, I = Number.POSITIVE_INFINITY, t = Number.NEGATIVE_INFINITY, s = Number.NEGATIVE_INFINITY;
+      for (const a of h) {
+        const A = p(a);
+        a.position.x < d && (d = a.position.x), a.position.y < I && (I = a.position.y), a.position.x + A.w > t && (t = a.position.x + A.w), a.position.y + A.h > s && (s = a.position.y + A.h);
+      }
+      const n = d - N, i = I - N;
+      if (Math.abs(n) > z || Math.abs(i) > z) {
+        for (const a of h)
+          a.position.x -= n, a.position.y -= i;
+        F = !0;
+      }
+      const r = t - d + 2 * N, u = s - I + 2 * N, S = typeof e.style?.width == "number" ? e.style.width : x(e).w, k = typeof e.style?.height == "number" ? e.style.height : x(e).h;
+      (Math.abs(r - S) > z || Math.abs(u - k) > z) && (F = !0), e.measured = {
+        width: r,
+        height: u
+      }, e.style = {
+        ...e.style,
+        width: r,
+        height: u
+      }, g.set(e.id, {
+        w: r,
+        h: u
+      });
+    }
+    B.clear();
+    for (const e of f) x(e);
+    const R = /* @__PURE__ */ new Map(), O = /* @__PURE__ */ new Map();
+    for (const e of f) {
+      const h = x(e), p = o.get(e.id);
+      O.set(e.id, p), R.set(e.id, {
+        x: p.x - h.w / 2,
+        y: p.y - h.h / 2
+      });
+    }
+    for (const e of f) {
+      const h = [], p = E.get(e.id) ?? [];
+      for (const i of p)
+        i.type === "group" && h.push(i);
+      if (!h.length) continue;
+      const d = h.slice().sort((i, r) => (+i.data?.paramIndex || 0) - (+r.data?.paramIndex || 0)), I = [];
+      for (const i of d) {
+        const r = D.get(i.id), u = typeof r.style?.width == "number" ? r.style.width : void 0;
+        I.push(u ?? x(r).w);
+      }
+      let t = 0;
+      for (const i of I) t += i;
+      t += Y * (d.length - 1);
+      let n = O.get(e.id).x - t / 2;
+      for (let i = 0; i < d.length; i++) {
+        const r = d[i], u = D.get(r.id), S = u.parentId ? R.get(u.parentId) : {
+          x: 0
+        };
+        u.position.x = n - S.x, n += I[i] + Y;
+      }
+    }
+  } while (F && _ < 5);
+  return {
+    nodes: f
+  };
+}, q = G.cache(at), bt = (y) => {
+  const C = U.c(2);
+  let m;
+  return C[0] !== y ? (m = /* @__PURE__ */ K($, { children: /* @__PURE__ */ K(dt, { ...y }) }), C[0] = y, C[1] = m) : m = C[1], m;
+}, dt = (y) => {
+  const [C, m] = J(y.nodes), [Y, N, z] = Q(y.edges), _ = Z(), F = G.useCallback((M) => {
+    requestAnimationFrame(() => {
+      M.forEach((E) => _(E));
+    });
+  }, [_]), f = {
+    default: ot,
+    group: st,
+    suggestion: nt,
+    trigger: it,
+    ...y.nodeTypes
+  }, L = {
+    default: rt,
+    ...y.edgeTypes
+  }, W = G.useCallback((M) => {
+    const E = Array.from(new Set(M.filter((g) => g.type === "dimensions" || g.type === "position").map((g) => g.id))), w = /* @__PURE__ */ new Map();
+    M.filter((g) => g.type === "dimensions").forEach((g) => w.set(g.id, g.dimensions)), m((g) => {
+      const B = g.map((o) => {
+        if (!w.has(o.id)) return o;
+        const c = w.get(o.id) || {};
+        return {
+          ...o,
+          measured: {
+            width: c.width ?? o.measured?.width ?? 0,
+            height: c.height ?? o.measured?.height ?? 0
+          }
+        };
+      });
+      return q(B, new Set(E)).nodes;
+    }), F(E);
+  }, [F]);
+  return G.useEffect(() => {
+    const M = y.nodes.map((w) => {
+      const g = w.measured ? [] : document.querySelectorAll("[data-id='" + w.id + "']");
+      return {
+        ...w,
+        measured: {
+          width: w.measured?.width ?? g[0]?.clientWidth ?? 0,
+          height: w.measured?.height ?? g[0]?.clientHeight ?? 0
+        }
+      };
+    }), E = q(M, new Set(M.map((w) => w.id)));
+    m(E.nodes), N(y.edges), F(E.nodes.map((w) => w.id));
+  }, [y.nodes, y.edges, F]), /* @__PURE__ */ K(tt, { onlyRenderVisibleElements: !0, panOnScroll: !1, nodeTypes: f, edgeTypes: L, onInit: (M) => M.fitView(), onNodesChange: W, onEdgesChange: z, ...et("flow", y), nodes: C, edges: Y });
+};
+export {
+  bt as DFlow
+};

package/dist/components/d-flow/DFlow.nodes.hook.d.ts

@@ -0,0 +1,3 @@
+import { Node } from '@xyflow/react';
+import { Flow } from '@code0-tech/sagittarius-graphql-types';
+export declare const useFlowNodes: (flowId: Flow["id"]) => Node[];

package/dist/components/d-flow/DFlow.nodes.hook.js

@@ -0,0 +1,139 @@
+import { useService as F } from "../../utils/contextStore.js";
+import { DFlowReactiveService as A } from "./DFlow.service.js";
+import { NodeFunctionView as $ } from "./DFlow.view.js";
+import { DFlowFunctionReactiveService as M } from "./function/DFlowFunction.service.js";
+import { DFlowDataTypeReactiveService as E } from "./data-type/DFlowDataType.service.js";
+const R = /* @__PURE__ */ new Map([["std", "default"]]), K = (s, x) => {
+  if (!x || s.size === 0) return "";
+  const f = /[:._\-\/\s]+/, d = x.trim().toLowerCase();
+  let t = null, i = -1 / 0;
+  for (const [l, v] of s.entries()) {
+    const n = l.trim().toLowerCase();
+    if (d === n)
+      return v;
+    let a = 0;
+    if (d.startsWith(n)) {
+      a = 2e3 + n.length * 2;
+      const u = d.charAt(n.length);
+      (u === "" || f.test(u)) && (a += 200);
+    } else {
+      const u = Math.min(d.length, n.length);
+      let r = 0;
+      for (; r < u && d.charCodeAt(r) === n.charCodeAt(r); )
+        r++;
+      if (r > 0) {
+        a = 1e3 + r;
+        const h = d.charAt(r), I = n.charAt(r);
+        (h === "" || f.test(h) || I === "" || f.test(I)) && (a += 50);
+      }
+    }
+    a > i ? (i = a, t = l) : (a === i && t !== null && l.length > t.length || a === i && t === null) && (t = l);
+  }
+  return t !== null ? s.get(t) : "";
+}, q = (s) => {
+  const x = F(A), f = F(M), d = F(E), t = x.getById(s);
+  if (!t) return [];
+  const i = [];
+  let l = 0;
+  const v = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), a = (e, o = v) => (o.has(e) || o.set(e, f.getById(e)), o.get(e)), u = (e, o = n) => (o.has(e) || o.set(e, d.getDataType(e)), o.get(e));
+  let r = 0;
+  const h = () => ++r;
+  let I = 0;
+  i.push({
+    id: `${t.id}`,
+    type: "trigger",
+    position: {
+      x: 0,
+      y: 0
+    },
+    draggable: !1,
+    data: {
+      instance: t,
+      flowId: s
+    }
+  });
+  const m = (e, o = !1, B, y = 0, D = [0], c, N = v, S = n) => {
+    const p = `${e.id}-${l++}`, C = ++I;
+    i.push({
+      id: p,
+      type: K(R, e.functionDefinition?.identifier),
+      position: {
+        x: 0,
+        y: 0
+      },
+      draggable: !1,
+      parentId: c,
+      extent: c ? "parent" : void 0,
+      data: {
+        instance: e,
+        isParameter: o,
+        flowId: s,
+        linkingId: o ? B : void 0,
+        scope: D,
+        // scope is now a PATH (number[])
+        depth: y,
+        // structural depth (0 at root, +1 per group)
+        index: C
+        // global node level
+      }
+    }), !e.nextNodeId && !o && i.push({
+      id: `${p}-suggestion`,
+      type: "suggestion",
+      position: {
+        x: 0,
+        y: 0
+      },
+      draggable: !1,
+      extent: c ? "parent" : void 0,
+      parentId: c,
+      data: {
+        flowId: s,
+        parentFunction: e
+      }
+    });
+    const k = a(e.functionDefinition?.id, N);
+    e.parameters?.forEach((g) => {
+      const T = k?.parameterDefinitions.find((b) => b.id == g.runtimeParameter?.id)?.dataTypeIdentifier;
+      if ((T ? u(T, S) : void 0)?.variant === "NODE") {
+        if (g.value && g.value instanceof $) {
+          const b = `${p}-group-${l++}`, w = [...D, h()];
+          i.push({
+            id: b,
+            type: "group",
+            position: {
+              x: 0,
+              y: 0
+            },
+            draggable: !1,
+            parentId: c,
+            extent: c ? "parent" : void 0,
+            data: {
+              isParameter: !0,
+              linkingId: p,
+              flowId: s,
+              depth: y + 1,
+              scope: w
+            }
+          }), m(g.value, !1, void 0, y + 1, w, b, N, S);
+        }
+      } else g.value && g.value instanceof $ && m(g.value, !0, p, y, D, c, N, S);
+    }), e.nextNodeId && m(t.getNodeById(e.nextNodeId), !1, void 0, y, D, c, N, S);
+  };
+  return t.startingNodeId ? m(t.getNodeById(t.startingNodeId), !1, void 0, 0, [0], void 0, v, n) : i.push({
+    id: `${t.id}-suggestion`,
+    type: "suggestion",
+    position: {
+      x: 0,
+      y: 0
+    },
+    draggable: !1,
+    extent: void 0,
+    data: {
+      flowId: s,
+      parentFunction: void 0
+    }
+  }), i;
+};
+export {
+  q as useFlowNodes
+};

package/dist/components/d-flow/DFlow.service.d.ts

@@ -0,0 +1,10 @@
+import { FlowView } from './DFlow.view';
+import { ReactiveArrayService } from '../../utils/reactiveArrayService';
+import { Flow, NamespacesProjectsFlowsCreateInput, NamespacesProjectsFlowsCreatePayload, NamespacesProjectsFlowsDeleteInput, NamespacesProjectsFlowsDeletePayload } from '@code0-tech/sagittarius-graphql-types';
+export declare abstract class DFlowReactiveService extends ReactiveArrayService<FlowView> {
+    getById(id: Flow['id']): FlowView | undefined;
+    /** Creates a new flow. */
+    abstract flowCreate(payload: NamespacesProjectsFlowsCreateInput): Promise<NamespacesProjectsFlowsCreatePayload | undefined>;
+    /** Deletes a namespace project. */
+    abstract flowDelete(payload: NamespacesProjectsFlowsDeleteInput): Promise<NamespacesProjectsFlowsDeletePayload | undefined>;
+}

package/dist/components/d-flow/DFlow.service.js

@@ -0,0 +1,11 @@
+import { ReactiveArrayService as i } from "../../utils/reactiveArrayService.js";
+class c extends i {
+  //TODO: inject UI error handler for toasts
+  //inject: namespaceId and projectId because the runtimes query needs it
+  getById(e) {
+    return this.values().find((r) => r.id === e);
+  }
+}
+export {
+  c as DFlowReactiveService
+};

package/dist/components/d-flow/DFlow.view.d.ts

@@ -0,0 +1,109 @@
+import { DataType, Flow, FlowSetting, FlowType, FunctionDefinition, LiteralValue, Maybe, NodeFunction, NodeParameter, NodeParameterValue, ReferenceValue, RuntimeParameterDefinition, Scalars } from '@code0-tech/sagittarius-graphql-types';
+import { ValidationResult } from '../../utils/inspection';
+export declare class FlowView {
+    /** Time when this Flow was created */
+    private readonly _createdAt?;
+    /** Global ID of this Flow */
+    private readonly _id?;
+    /** The input data type of the flow */
+    private _inputType?;
+    /** Nodes of the flow */
+    private _nodes?;
+    /** The return data type of the flow */
+    private readonly _returnType?;
+    /** The settings of the flow */
+    private readonly _settings?;
+    /** The ID of the starting node of the flow */
+    private _startingNodeId?;
+    /** The flow type of the flow */
+    private readonly _type?;
+    /** Time when this Flow was last updated */
+    private readonly _updatedAt?;
+    /** Name of the flow */
+    private _name?;
+    constructor(flow: Flow);
+    get createdAt(): Maybe<Scalars["Time"]["output"]> | undefined;
+    get id(): Maybe<Scalars["FlowID"]["output"]> | undefined;
+    get inputType(): Maybe<DataType> | undefined;
+    get nodes(): NodeFunctionView[] | undefined;
+    get returnType(): Maybe<DataType> | undefined;
+    get settings(): FlowSettingView[] | undefined;
+    get startingNodeId(): Maybe<Scalars["NodeFunctionID"]["output"]> | undefined;
+    get type(): Maybe<FlowType> | undefined;
+    get updatedAt(): Maybe<Scalars["Time"]["output"]> | undefined;
+    get name(): Maybe<Scalars["String"]["output"]> | undefined;
+    set inputType(value: Maybe<DataType>);
+    set startingNodeId(value: Maybe<Scalars["NodeFunctionID"]["output"]>);
+    set name(value: Maybe<Scalars["String"]["output"]>);
+    addNode(node: NodeFunctionView): void;
+    updateNode(updatedNode: NodeFunctionView): void;
+    removeNode(nodeId: Scalars['NodeFunctionID']['output']): void;
+    getNodeById(nodeId: Scalars['NodeFunctionID']['output']): NodeFunctionView | undefined;
+    json(): Flow;
+}
+export declare class NodeFunctionView {
+    /** Time when this NodeFunction was created */
+    private readonly _createdAt?;
+    /** Global ID of this NodeFunction */
+    private readonly _id?;
+    /** The ID of the next Node Function in the flow */
+    private _nextNodeId?;
+    /** The parameters of the Node Function */
+    private readonly _parameters?;
+    /** The definition of the Node Function */
+    private readonly _functionDefinition?;
+    /** Time when this NodeFunction was last updated */
+    private readonly _updatedAt?;
+    constructor(nodeFunction: NodeFunction);
+    get createdAt(): Maybe<Scalars["Time"]["output"]> | undefined;
+    get id(): Maybe<Scalars["NodeFunctionID"]["output"]> | undefined;
+    get nextNodeId(): Maybe<Scalars["NodeFunctionID"]["output"]> | undefined;
+    get parameters(): NodeParameterView[] | undefined;
+    get functionDefinition(): Maybe<FunctionDefinition> | undefined;
+    get updatedAt(): Maybe<Scalars["Time"]["output"]> | undefined;
+    set nextNodeId(value: Maybe<Scalars["NodeFunctionID"]["output"]>);
+    deleteNextNode(): void;
+    json(): NodeFunction | undefined;
+}
+export declare class NodeParameterView {
+    /** Time when this NodeParameter was created */
+    private readonly _createdAt?;
+    /** Global ID of this NodeParameter */
+    private readonly _id?;
+    /** The definition of the parameter */
+    private readonly _runtimeParameter?;
+    /** Time when this NodeParameter was last updated */
+    private readonly _updatedAt?;
+    /** The value of the parameter */
+    private _value?;
+    private _validationResults;
+    constructor(nodeParameter: NodeParameter);
+    get createdAt(): Maybe<Scalars["Time"]["output"]> | undefined;
+    get id(): Maybe<Scalars["NodeParameterID"]["output"]> | undefined;
+    get runtimeParameter(): Maybe<RuntimeParameterDefinition> | undefined;
+    get updatedAt(): Maybe<Scalars["Time"]["output"]> | undefined;
+    get value(): LiteralValue | ReferenceValue | NodeFunctionView | undefined;
+    get validationResults(): ValidationResult[];
+    set validationResults(value: ValidationResult[]);
+    set value(value: NodeParameterValue | undefined);
+    json(): NodeParameter | undefined;
+}
+export declare class FlowSettingView {
+    private readonly _createdAt?;
+    /** The identifier of the flow setting */
+    private readonly _flowSettingIdentifier?;
+    /** Global ID of this FlowSetting */
+    private readonly _id?;
+    /** Time when this FlowSetting was last updated */
+    private readonly _updatedAt?;
+    /** The value of the flow setting */
+    private _value?;
+    constructor(flowSetting: FlowSetting);
+    get createdAt(): Maybe<Scalars["Time"]["output"]> | undefined;
+    get flowSettingIdentifier(): Maybe<Scalars["String"]["output"]> | undefined;
+    get id(): Maybe<Scalars["FlowSettingID"]["output"]> | undefined;
+    get value(): Maybe<Scalars["String"]["output"]> | undefined;
+    get updatedAt(): Maybe<Scalars["Time"]["output"]> | undefined;
+    set value(value: Maybe<Scalars["JSON"]["output"]>);
+    json(): FlowSetting;
+}