@code0-tech/pictor 0.0.0-mvp.10

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

@@ -0,0 +1,213 @@
+function e(s, t, i) {
+  return (t = n(t)) in s ? Object.defineProperty(s, t, { value: i, enumerable: !0, configurable: !0, writable: !0 }) : s[t] = i, s;
+}
+function n(s) {
+  var t = a(s, "string");
+  return typeof t == "symbol" ? t : t + "";
+}
+function a(s, t) {
+  if (typeof s != "object" || !s) return s;
+  var i = s[Symbol.toPrimitive];
+  if (i !== void 0) {
+    var r = i.call(s, t);
+    if (typeof r != "object") return r;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (t === "string" ? String : Number)(s);
+}
+class h {
+  constructor(t) {
+    e(this, "_createdAt", void 0), e(this, "_id", void 0), e(this, "_inputType", void 0), e(this, "_nodes", void 0), e(this, "_returnType", void 0), e(this, "_settings", void 0), e(this, "_startingNodeId", void 0), e(this, "_type", void 0), e(this, "_updatedAt", void 0), e(this, "_name", void 0), this._createdAt = t.createdAt, this._id = t.id, this._inputType = t.inputType, this._nodes = t.nodes?.nodes?.map((i) => new d(i)), this._returnType = t.returnType, this._settings = t.settings?.nodes?.map((i) => new u(i)), this._startingNodeId = t.startingNodeId, this._type = t.type, this._updatedAt = t.updatedAt, this._name = t.name;
+  }
+  get createdAt() {
+    return this._createdAt;
+  }
+  get id() {
+    return this._id;
+  }
+  get inputType() {
+    return this._inputType;
+  }
+  get nodes() {
+    return this._nodes;
+  }
+  get returnType() {
+    return this._returnType;
+  }
+  get settings() {
+    return this._settings;
+  }
+  get startingNodeId() {
+    return this._startingNodeId;
+  }
+  get type() {
+    return this._type;
+  }
+  get updatedAt() {
+    return this._updatedAt;
+  }
+  get name() {
+    return this._name;
+  }
+  set inputType(t) {
+    this._inputType = t;
+  }
+  set startingNodeId(t) {
+    this._startingNodeId = t;
+  }
+  set name(t) {
+    this._name = t;
+  }
+  addNode(t) {
+    this._nodes || (this._nodes = []), this._nodes.push(t);
+  }
+  updateNode(t) {
+    this._nodes && (this._nodes = this._nodes.map((i) => i.id === t.id ? t : i));
+  }
+  removeNode(t) {
+    this._nodes && (this._nodes = this._nodes.filter((i) => i.id !== t));
+  }
+  getNodeById(t) {
+    if (this._nodes)
+      return this._nodes.find((i) => i.id === t);
+  }
+  json() {
+    return {
+      __typename: "Flow",
+      createdAt: this._createdAt,
+      id: this._id,
+      inputType: this._inputType,
+      nodes: this._nodes ? {
+        nodes: this._nodes.map((t) => t.json())
+      } : void 0,
+      returnType: this._returnType,
+      settings: this._settings ? {
+        nodes: this._settings.map((t) => t.json())
+      } : void 0,
+      startingNodeId: this._startingNodeId,
+      type: this._type,
+      updatedAt: this._updatedAt,
+      name: this._name
+    };
+  }
+}
+class d {
+  constructor(t) {
+    e(this, "_createdAt", void 0), e(this, "_id", void 0), e(this, "_nextNodeId", void 0), e(this, "_parameters", void 0), e(this, "_functionDefinition", void 0), e(this, "_updatedAt", void 0), this._createdAt = t.createdAt, this._id = t.id, this._nextNodeId = t.nextNodeId, this._functionDefinition = t.functionDefinition, this._updatedAt = t.updatedAt, this._parameters = t.parameters ? t.parameters.nodes?.map((i) => new _(i)) : void 0;
+  }
+  get createdAt() {
+    return this._createdAt;
+  }
+  get id() {
+    return this._id;
+  }
+  get nextNodeId() {
+    return this._nextNodeId;
+  }
+  get parameters() {
+    return this._parameters;
+  }
+  get functionDefinition() {
+    return this._functionDefinition;
+  }
+  get updatedAt() {
+    return this._updatedAt;
+  }
+  set nextNodeId(t) {
+    this._nextNodeId = t;
+  }
+  deleteNextNode() {
+    this._nextNodeId = void 0;
+  }
+  json() {
+    return {
+      __typename: "NodeFunction",
+      createdAt: this._createdAt,
+      id: this._id,
+      nextNodeId: this._nextNodeId,
+      parameters: this._parameters ? {
+        nodes: this._parameters.map((t) => t.json())
+      } : void 0,
+      functionDefinition: this._functionDefinition,
+      updatedAt: this._updatedAt
+    };
+  }
+}
+class _ {
+  constructor(t) {
+    e(this, "_createdAt", void 0), e(this, "_id", void 0), e(this, "_runtimeParameter", void 0), e(this, "_updatedAt", void 0), e(this, "_value", void 0), e(this, "_validationResults", void 0), this._createdAt = t.createdAt, this._id = t.id, this._runtimeParameter = t.runtimeParameter, this._updatedAt = t.updatedAt, t.value?.__typename === "NodeFunction" ? this._value = new d(t.value) : this._value = t.value, this._validationResults = [];
+  }
+  get createdAt() {
+    return this._createdAt;
+  }
+  get id() {
+    return this._id;
+  }
+  get runtimeParameter() {
+    return this._runtimeParameter;
+  }
+  get updatedAt() {
+    return this._updatedAt;
+  }
+  get value() {
+    return this._value;
+  }
+  get validationResults() {
+    return this._validationResults;
+  }
+  set validationResults(t) {
+    this._validationResults = t;
+  }
+  set value(t) {
+    t?.__typename === "NodeFunction" ? this._value = new d(t) : this._value = t;
+  }
+  json() {
+    return {
+      __typename: "NodeParameter",
+      createdAt: this._createdAt,
+      id: this._id,
+      runtimeParameter: this._runtimeParameter,
+      updatedAt: this._updatedAt,
+      value: this._value instanceof d ? this._value.json() : this._value
+    };
+  }
+}
+class u {
+  constructor(t) {
+    e(this, "_createdAt", void 0), e(this, "_flowSettingIdentifier", void 0), e(this, "_id", void 0), e(this, "_updatedAt", void 0), e(this, "_value", void 0), this._createdAt = t.createdAt, this._flowSettingIdentifier = t.flowSettingIdentifier, this._id = t.id, this._value = t.value, this._updatedAt = t.updatedAt;
+  }
+  get createdAt() {
+    return this._createdAt;
+  }
+  get flowSettingIdentifier() {
+    return this._flowSettingIdentifier;
+  }
+  get id() {
+    return this._id;
+  }
+  get value() {
+    return this._value;
+  }
+  get updatedAt() {
+    return this._updatedAt;
+  }
+  set value(t) {
+    this._value = t;
+  }
+  json() {
+    return {
+      __typename: "FlowSetting",
+      createdAt: this._createdAt,
+      flowSettingIdentifier: this._flowSettingIdentifier,
+      id: this._id,
+      value: this._value,
+      updatedAt: this._updatedAt
+    };
+  }
+}
+export {
+  u as FlowSettingView,
+  h as FlowView,
+  d as NodeFunctionView,
+  _ as NodeParameterView
+};

package/dist/components/d-flow/control/DFlowControl.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const DFlowControl: React.FC;

package/dist/components/d-flow/control/DFlowControl.js

@@ -0,0 +1,77 @@
+import { jsx as o, jsxs as k } from "react/jsx-runtime";
+import { c as j } from "../../../_virtual/compiler-runtime.js";
+import { useViewport as D, useReactFlow as M, Panel as O } from "@xyflow/react";
+import { ButtonGroup as R } from "../../button-group/ButtonGroup.js";
+import { Button as B } from "../../button/Button.js";
+import { IconPlus as V, IconMinus as v, IconFocusCentered as E } from "@tabler/icons-react";
+import { Badge as G } from "../../badge/Badge.js";
+import { Flex as P } from "../../flex/Flex.js";
+const N = () => {
+  const e = j.c(36), C = D(), t = M();
+  let p;
+  e[0] !== t ? (p = () => {
+    t.zoomIn();
+  }, e[0] = t, e[1] = p) : p = e[1];
+  const I = p;
+  let d;
+  e[2] !== t ? (d = () => {
+    t.zoomOut();
+  }, e[2] = t, e[3] = d) : d = e[3];
+  const g = d;
+  let h;
+  e[4] !== t ? (h = () => {
+    t.fitView();
+  }, e[4] = t, e[5] = h) : h = e[5];
+  const F = h;
+  let u;
+  e[6] !== C.zoom ? (u = () => Math.round(C.zoom * 100), e[6] = C.zoom, e[7] = u) : u = e[7];
+  const S = u;
+  let y;
+  e[8] === Symbol.for("react.memo_cache_sentinel") ? (y = {
+    flexDirection: "column",
+    gap: "1rem"
+  }, e[8] = y) : y = e[8];
+  let z;
+  e[9] === Symbol.for("react.memo_cache_sentinel") ? (z = {
+    gap: ".35rem"
+  }, e[9] = z) : z = e[9];
+  let l;
+  e[10] !== I ? (l = () => I(), e[10] = I, e[11] = l) : l = e[11];
+  let _;
+  e[12] === Symbol.for("react.memo_cache_sentinel") ? (_ = /* @__PURE__ */ o(V, { size: 15 }), e[12] = _) : _ = e[12];
+  let r;
+  e[13] !== l ? (r = /* @__PURE__ */ o(B, { color: "secondary", onClick: l, children: _ }), e[13] = l, e[14] = r) : r = e[14];
+  let i;
+  e[15] !== g ? (i = () => g(), e[15] = g, e[16] = i) : i = e[16];
+  let b;
+  e[17] === Symbol.for("react.memo_cache_sentinel") ? (b = /* @__PURE__ */ o(v, { size: 15 }), e[17] = b) : b = e[17];
+  let c;
+  e[18] !== i ? (c = /* @__PURE__ */ o(B, { color: "secondary", onClick: i, children: b }), e[18] = i, e[19] = c) : c = e[19];
+  let n;
+  e[20] !== F ? (n = () => F(), e[20] = F, e[21] = n) : n = e[21];
+  let w;
+  e[22] === Symbol.for("react.memo_cache_sentinel") ? (w = /* @__PURE__ */ o(E, { size: 15 }), e[22] = w) : w = e[22];
+  let s;
+  e[23] !== n ? (s = /* @__PURE__ */ o(B, { color: "secondary", onClick: n, children: w }), e[23] = n, e[24] = s) : s = e[24];
+  let m;
+  e[25] !== c || e[26] !== s || e[27] !== r ? (m = /* @__PURE__ */ k(R, { children: [
+    r,
+    c,
+    s
+  ] }), e[25] = c, e[26] = s, e[27] = r, e[28] = m) : m = e[28];
+  let f;
+  e[29] !== S ? (f = S(), e[29] = S, e[30] = f) : f = e[30];
+  let a;
+  e[31] !== f ? (a = /* @__PURE__ */ k(G, { color: "secondary", children: [
+    f,
+    "%"
+  ] }), e[31] = f, e[32] = a) : a = e[32];
+  let x;
+  return e[33] !== m || e[34] !== a ? (x = /* @__PURE__ */ o(O, { position: "bottom-left", children: /* @__PURE__ */ o(P, { style: y, children: /* @__PURE__ */ k(P, { align: "stretch", style: z, children: [
+    m,
+    a
+  ] }) }) }), e[33] = m, e[34] = a, e[35] = x) : x = e[35], x;
+};
+export {
+  N as DFlowControl
+};

package/dist/components/d-flow/control/index.d.ts

@@ -0,0 +1 @@
+export * from './DFlowControl';

package/dist/components/d-flow/control/index.js

@@ -0,0 +1,4 @@
+import { DFlowControl as l } from "./DFlowControl.js";
+export {
+  l as DFlowControl
+};

package/dist/components/d-flow/data-type/DFlowDataType.service.d.ts

@@ -0,0 +1,10 @@
+import { ReactiveArrayService } from '../../../utils/reactiveArrayService';
+import { DataTypeView } from './DFlowDataType.view';
+import { DataTypeIdentifier, Maybe, NodeParameterValue } from '@code0-tech/sagittarius-graphql-types';
+import { FlowView } from '../DFlow.view';
+export declare abstract class DFlowDataTypeReactiveService extends ReactiveArrayService<DataTypeView> {
+    getDataType(type: DataTypeIdentifier): DataTypeView | undefined;
+    getDataTypeFromValue(value: NodeParameterValue, flow?: FlowView): DataTypeView | undefined;
+    getTypeFromValue(value: NodeParameterValue, flow?: FlowView): Maybe<DataTypeIdentifier> | undefined;
+    hasDataTypes(types: DataTypeIdentifier[]): boolean;
+}

package/dist/components/d-flow/data-type/DFlowDataType.service.js

@@ -0,0 +1,91 @@
+import { ReactiveArrayService as s } from "../../../utils/reactiveArrayService.js";
+import { resolveType as y } from "../../../utils/generics.js";
+import { useValidateValue as f } from "./DFlowDataType.validation.value.js";
+class l extends s {
+  //TODO: remove string because of sagittarius types update
+  getDataType(e) {
+    if (!e || e.genericKey) return;
+    const i = e.dataType?.identifier ?? e.genericType?.dataType?.identifier, t = e.dataType?.id ?? e.genericType?.dataType?.id;
+    return this.values().find((r) => r.identifier == i || r.id == t);
+  }
+  getDataTypeFromValue(e, i) {
+    if (!e) return;
+    if (e.__typename == "LiteralValue") {
+      if (Array.isArray(e.value) && Array.from(e.value).length > 0) return this.getDataType({
+        dataType: {
+          identifier: "ARRAY"
+        }
+      });
+      if (typeof e.value == "string") return this.getDataType({
+        dataType: {
+          identifier: "TEXT"
+        }
+      });
+      if (typeof e.value == "number") return this.getDataType({
+        dataType: {
+          identifier: "NUMBER"
+        }
+      });
+      if (typeof e.value == "boolean") return this.getDataType({
+        dataType: {
+          identifier: "BOOLEAN"
+        }
+      });
+    }
+    const t = this.values().filter((r) => r.identifier === "OBJECT" || e.__typename === "NodeFunction" && (r.variant != "NODE" || !i) ? !1 : f(e, r, i));
+    return t[t.length - 1];
+  }
+  getTypeFromValue(e, i) {
+    if (!e) return;
+    if (e.__typename === "ReferenceValue") return e.dataTypeIdentifier;
+    const t = this.getDataTypeFromValue(e, i);
+    if ((t?.genericKeys?.length ?? 0) <= 0 || !t?.genericKeys) return {
+      dataType: {
+        id: t?.id
+      }
+    };
+    const r = t.genericKeys.map((a) => {
+      const n = t.rules?.nodes?.find((d) => "dataTypeIdentifier" in (d?.config ?? {}) && d?.config?.dataTypeIdentifier?.genericKey == a || "inputTypes" in (d?.config ?? {}) && d.config.inputTypes?.some((p) => p.dataTypeIdentifier?.genericKey == a));
+      return n && n.variant == "CONTAINS_TYPE" && "value" in e && e?.value && t.variant === "ARRAY" ? {
+        sourceDataTypeIdentifiers: [this.getTypeFromValue({
+          __typename: "LiteralValue",
+          value: e.value[0]
+        }, i)],
+        target: a
+      } : n && n.variant == "CONTAINS_KEY" && "value" in e && e?.value && t.variant === "OBJECT" ? {
+        sourceDataTypeIdentifiers: [this.getTypeFromValue({
+          __typename: "LiteralValue",
+          /* @ts-ignore */
+          value: e.value[n.config?.key ?? ""]
+        }, i)],
+        target: a
+      } : n && n.variant == "RETURN_TYPE" && t.variant === "NODE" ? {
+        sourceDataTypeIdentifiers: [this.getTypeFromValue(e, i)],
+        target: a
+      } : n && n.variant == "INPUT_TYPE" && t.variant === "NODE" ? {
+        sourceDataTypeIdentifiers: [{
+          genericKey: a
+        }],
+        target: a
+      } : null;
+    }).filter((a) => !!a), T = r.length > 0 ? {
+      genericType: {
+        dataType: {
+          id: t.id
+        },
+        genericMappers: r
+      }
+    } : {
+      dataType: {
+        id: t.id
+      }
+    };
+    return y(T, this);
+  }
+  hasDataTypes(e) {
+    return e.every((i) => this.values().find((t) => t.id === (i.genericType?.dataType?.id ?? i.dataType?.id)));
+  }
+}
+export {
+  l as DFlowDataTypeReactiveService
+};

package/dist/components/d-flow/data-type/DFlowDataType.validation.type.d.ts

@@ -0,0 +1,2 @@
+import { DataTypeView } from './DFlowDataType.view';
+export declare const useValidateDataType: (firstDataType: DataTypeView, secondDataType: DataTypeView) => boolean;

package/dist/components/d-flow/data-type/DFlowDataType.validation.type.js

@@ -0,0 +1,18 @@
+const g = ["id", "__typename", "createdAt", "updatedAt"], h = (c, u) => {
+  if (c.variant !== u.variant) return !1;
+  const l = (r) => r !== null && typeof r == "object", i = (r, e) => {
+    if (r === e) return !0;
+    const y = Array.isArray(r), a = Array.isArray(e);
+    if (y || a)
+      return !y || !a || r.length !== e.length ? !1 : r.every((s, f) => i(s, e[f]));
+    if (l(r) && l(e)) {
+      const s = Object.keys(r), f = Object.keys(e);
+      return s.length !== f.length ? !1 : s.every((o) => g.includes(o) ? !0 : i(r[o], e[o]));
+    }
+    return !1;
+  }, t = c.rules?.nodes ?? [], n = u.rules?.nodes ?? [];
+  return !t.length && !n.length ? !0 : !t.length || !n.length || t.length !== n.length ? !1 : t.every((r, e) => i(r, n[e]));
+};
+export {
+  h as useValidateDataType
+};

package/dist/components/d-flow/data-type/DFlowDataType.validation.value.d.ts

@@ -0,0 +1,4 @@
+import { GenericMapper, NodeParameterValue } from '@code0-tech/sagittarius-graphql-types';
+import { DataTypeView } from './DFlowDataType.view';
+import { FlowView } from '../DFlow.view';
+export declare const useValidateValue: (value: NodeParameterValue, dataType: DataTypeView, flow?: FlowView, generics?: GenericMapper[]) => boolean;

package/dist/components/d-flow/data-type/DFlowDataType.validation.value.js

@@ -0,0 +1,20 @@
+import { c } from "../../../_virtual/compiler-runtime.js";
+import { RuleMap as m } from "./rules/DFlowDataTypeRules.js";
+import { useService as f } from "../../../utils/contextStore.js";
+import { DFlowDataTypeReactiveService as u } from "./DFlowDataType.service.js";
+const g = (e, i, n, a) => {
+  const t = c.c(6), s = f(u);
+  let o;
+  if (t[0] !== i.rules?.nodes || t[1] !== s || t[2] !== n || t[3] !== a || t[4] !== e) {
+    const p = new Map(a?.map(v));
+    o = i.rules?.nodes?.every((r) => !r || !r.variant || !r.config ? !1 : m.get(r.variant) ? m.get(r.variant)?.validate(e, r.config, p, s, n) : !0) ?? !0, t[0] = i.rules?.nodes, t[1] = s, t[2] = n, t[3] = a, t[4] = e, t[5] = o;
+  } else
+    o = t[5];
+  return o;
+};
+function v(e) {
+  return [e.target, e];
+}
+export {
+  g as useValidateValue
+};

package/dist/components/d-flow/data-type/DFlowDataType.view.d.ts

@@ -0,0 +1,32 @@
+import { DataType, DataTypeRuleConnection, DataTypeVariant, Maybe, Runtime, Scalars, TranslationConnection } from '@code0-tech/sagittarius-graphql-types';
+export declare class DataTypeView {
+    /** Time when this DataType was created */
+    private readonly _createdAt?;
+    /** Generic keys of the datatype */
+    private readonly _genericKeys?;
+    /** Global ID of this DataType */
+    private readonly _id?;
+    /** The identifier scoped to the namespace */
+    private readonly _identifier?;
+    /** Names of the flow type setting */
+    private readonly _name?;
+    /** The namespace where this datatype belongs to */
+    private readonly _runtime?;
+    /** Rules of the datatype */
+    private readonly _rules?;
+    /** Time when this DataType was last updated */
+    private readonly _updatedAt?;
+    /** The type of the datatype */
+    private readonly _variant?;
+    constructor(dataType: DataType);
+    get createdAt(): Maybe<Scalars["Time"]["output"]> | undefined;
+    get genericKeys(): Maybe<Array<Scalars["String"]["output"]>> | undefined;
+    get id(): Maybe<Scalars["DataTypeID"]["output"]> | undefined;
+    get identifier(): Maybe<Scalars["String"]["output"]> | undefined;
+    get name(): Maybe<TranslationConnection> | undefined;
+    get runtime(): Maybe<Runtime> | undefined;
+    get rules(): Maybe<DataTypeRuleConnection> | undefined;
+    get updatedAt(): Maybe<Scalars["Time"]["output"]> | undefined;
+    get variant(): Maybe<DataTypeVariant> | undefined;
+    get json(): DataType;
+}

package/dist/components/d-flow/data-type/DFlowDataType.view.js

@@ -0,0 +1,65 @@
+function i(e, t, r) {
+  return (t = s(t)) in e ? Object.defineProperty(e, t, { value: r, enumerable: !0, configurable: !0, writable: !0 }) : e[t] = r, e;
+}
+function s(e) {
+  var t = u(e, "string");
+  return typeof t == "symbol" ? t : t + "";
+}
+function u(e, t) {
+  if (typeof e != "object" || !e) return e;
+  var r = e[Symbol.toPrimitive];
+  if (r !== void 0) {
+    var n = r.call(e, t);
+    if (typeof n != "object") return n;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (t === "string" ? String : Number)(e);
+}
+class d {
+  constructor(t) {
+    i(this, "_createdAt", void 0), i(this, "_genericKeys", void 0), i(this, "_id", void 0), i(this, "_identifier", void 0), i(this, "_name", void 0), i(this, "_runtime", void 0), i(this, "_rules", void 0), i(this, "_updatedAt", void 0), i(this, "_variant", void 0), this._id = t.id, this._createdAt = t.createdAt, this._updatedAt = t.updatedAt, this._identifier = t.identifier, this._name = t.name ?? void 0, this._runtime = t.runtime ?? void 0, this._variant = t.variant, this._genericKeys = t.genericKeys ?? void 0, this._rules = t.rules ?? void 0;
+  }
+  get createdAt() {
+    return this._createdAt;
+  }
+  get genericKeys() {
+    return this._genericKeys;
+  }
+  get id() {
+    return this._id;
+  }
+  get identifier() {
+    return this._identifier;
+  }
+  get name() {
+    return this._name;
+  }
+  get runtime() {
+    return this._runtime;
+  }
+  get rules() {
+    return this._rules;
+  }
+  get updatedAt() {
+    return this._updatedAt;
+  }
+  get variant() {
+    return this._variant;
+  }
+  get json() {
+    return {
+      id: this._id,
+      createdAt: this._createdAt,
+      updatedAt: this._updatedAt,
+      identifier: this._identifier,
+      name: this._name,
+      runtime: this._runtime,
+      variant: this._variant,
+      genericKeys: this._genericKeys,
+      rules: this._rules
+    };
+  }
+}
+export {
+  d as DataTypeView
+};

package/dist/components/d-flow/data-type/index.d.ts

@@ -0,0 +1,2 @@
+export * from './DFlowDataType.service';
+export * from './DFlowDataType.view';

package/dist/components/d-flow/data-type/index.js

@@ -0,0 +1,6 @@
+import { DFlowDataTypeReactiveService as o } from "./DFlowDataType.service.js";
+import { DataTypeView as t } from "./DFlowDataType.view.js";
+export {
+  o as DFlowDataTypeReactiveService,
+  t as DataTypeView
+};

package/dist/components/d-flow/data-type/rules/DFlowDataTypeContainsKeyRule.d.ts

@@ -0,0 +1,6 @@
+import { DFlowDataTypeReactiveService } from '../DFlowDataType.service';
+import { DataTypeRulesContainsKeyConfig, GenericMapper, NodeParameterValue } from '@code0-tech/sagittarius-graphql-types';
+import { FlowView } from '../../DFlow.view';
+export declare class DFlowDataTypeContainsKeyRule {
+    static validate(value: NodeParameterValue, config: DataTypeRulesContainsKeyConfig, generics?: Map<string, GenericMapper>, service?: DFlowDataTypeReactiveService, flow?: FlowView): boolean;
+}