@bonsae/nrg 0.12.1 → 0.13.0

package/README.md

@@ -5,6 +5,7 @@
 <p align="center">
   <a href="https://www.npmjs.com/package/@bonsae/nrg"><img src="https://img.shields.io/npm/v/@bonsae/nrg.svg" alt="npm package"></a>
   <a href="https://github.com/bonsaedev/nrg/actions/workflows/ci.yaml"><img src="https://github.com/bonsaedev/nrg/actions/workflows/ci.yaml/badge.svg?branch=main" alt="build status"></a>
+  <a href="https://codecov.io/gh/bonsaedev/nrg"><img src="https://codecov.io/gh/bonsaedev/nrg/graph/badge.svg" alt="codecov"/></a>
   <a href="https://socket.dev/npm/package/@bonsae/nrg"><img src="https://badge.socket.dev/npm/package/@bonsae/nrg?v=1" alt="Socket Badge"></a>
 </p>
 
@@ -73,15 +74,15 @@ NRG supports two ways to define nodes:
 <tr><td>
 
 ```typescript
-import { defineIONode } from "@bonsae/nrg/server";
-import { ConfigsSchema } from "../schemas/my-node";
+import { defineIONode, SchemaType } from "@bonsae/nrg/server";
+import { ConfigsSchema, InputSchema, OutputSchema } from "../schemas/my-node";
 
 export default defineIONode({
   type: "my-node",
   color: "#ffffff",
-  inputs: 1,
-  outputs: 1,
   configSchema: ConfigsSchema,
+  inputSchema: InputSchema,
+  outputsSchema: OutputSchema,
 
   async input(msg) {
     msg.payload = `${this.config.prefix}: ${msg.payload}`;
@@ -94,21 +95,22 @@ export default defineIONode({
 
 ```typescript
 import { IONode, type Schema, type Infer } from "@bonsae/nrg/server";
-import { ConfigsSchema } from "../schemas/my-node";
+import { ConfigsSchema, InputSchema, OutputSchema } from "../schemas/my-node";
 
 type Config = Infer<typeof ConfigsSchema>;
+type Input = Infer<typeof InputSchema>;
+type Output = Infer<typeof OutputSchema>;
 
-export default class MyNode extends IONode<Config> {
+export default class MyNode extends IONode<Config, any, Input, Output> {
   static readonly type = "my-node";
   static readonly category = "function";
   static readonly color: `#${string}` = "#ffffff";
-  static readonly inputs = 1;
-  static readonly outputs = 1;
   static readonly configSchema: Schema = ConfigsSchema;
+  static readonly inputSchema: Schema = InputSchema;
+  static readonly outputsSchema: Schema = OutputSchema;
 
-  async input(msg: any) {
-    msg.payload = `${this.config.prefix}: ${msg.payload}`;
-    this.send(msg);
+  async input(msg: Input) {
+    this.send({ payload: `${this.config.prefix}: ${msg.payload}` });
   }
 }
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bonsae/nrg",
-  "version": "0.12.1",
+  "version": "0.13.0",
   "description": "NRG framework — build Node-RED nodes with Vue 3, TypeScript, and JSON Schema",
   "author": "Allan Oricil <allanoricil@duck.com>",
   "license": "MIT",
@@ -13,7 +13,7 @@
     "access": "public"
   },
   "engines": {
-    "node": ">=22",
+    "node": ">=20.19",
     "pnpm": ">=10.11.0"
   },
   "exports": {

package/server/index.cjs

@@ -531,12 +531,18 @@ var Node = class {
 var IONode = class extends Node {
   static align;
   static color;
-  static inputs = 0;
-  static outputs = 0;
   static inputSchema;
   static outputsSchema;
   static validateInput = false;
   static validateOutput = false;
+  static get inputs() {
+    return this.inputSchema ? 1 : 0;
+  }
+  static get outputs() {
+    const s = this.outputsSchema;
+    if (!s) return 0;
+    return Array.isArray(s) ? s.length : 1;
+  }
   _send;
   context;
   // NOTE: used by the registered function. Had to be a different one to avoid calling the parent's input again
@@ -557,6 +563,8 @@ var IONode = class extends Node {
     fn.global = setupContext(context.global);
     this.context = fn;
   }
+  input(msg) {
+  }
   // NOTE: used by the registered function. Had to be a different one to avoid calling the parent's input again
   /** @internal */
   async _input(msg, send) {
@@ -749,8 +757,6 @@ function defineIONode(def) {
     static type = def.type;
     static category = def.category ?? "function";
     static color = def.color ?? "#a6bbcf";
-    static inputs = def.inputs ?? 1;
-    static outputs = def.outputs ?? 1;
     static align = def.align;
     static configSchema = def.configSchema;
     static credentialsSchema = def.credentialsSchema;
@@ -990,16 +996,6 @@ async function registerType(RED, NodeClass) {
       `Invalid color for ${NodeClass.type}: ${NC.color} color must be in hex format`
     );
   }
-  if (NC.inputs !== void 0 && (!Number.isInteger(NC.inputs) || NC.inputs !== 0 && NC.inputs !== 1)) {
-    throw new NrgError(
-      `Invalid number of inputs for ${NodeClass.type}: inputs must be 0 or 1`
-    );
-  }
-  if (NC.outputs !== void 0 && (!Number.isInteger(NC.outputs) || NC.outputs < 0)) {
-    throw new NrgError(
-      `Invalid number of outputs for ${NodeClass.type}: outputs must be a positive integer`
-    );
-  }
   RED.nodes.registerType(
     NC.type,
     function(config) {

package/server/resources/nrg-client.js

@@ -1,4 +1,4 @@
-(function(){var s=document.createElement("style");s.textContent=".nrg-toggles-grid[data-v-8394a8d1]{display:grid;grid-template-columns:1fr 1fr 1fr;gap:8px 16px}[data-v-8394a8d1] .node-red-vue-input-error-message{color:var(--red-ui-text-color-error)}[data-v-8394a8d1] .form-row input[type=text],[data-v-8394a8d1] .form-row input[type=number],[data-v-8394a8d1] .form-row input[type=password]{height:34px;padding:0 8px;box-sizing:border-box}.nrg-label[data-v-9ffd05ad]{display:inline-block;width:100%;cursor:default}.nrg-label i[data-v-9ffd05ad]{margin-right:5px}.nrg-required[data-v-9ffd05ad]{color:var(--red-ui-text-color-error);margin-left:2px}.editor-wrapper[data-v-4077a6c2]{position:relative}.expand-button[data-v-4077a6c2]{position:absolute;top:-23px;right:0;z-index:10;transition:color .3s ease;cursor:pointer}.nrg-toggle-wrapper[data-v-36b098e4]{display:inline-flex;align-items:center}.nrg-toggle[data-v-36b098e4]{position:relative;display:inline-flex!important;flex-direction:column;align-items:flex-start;cursor:pointer;gap:4px;-webkit-user-select:none;user-select:none}.nrg-toggle__input[data-v-36b098e4]{position:absolute;opacity:0;width:0;height:0}.nrg-toggle__slider[data-v-36b098e4]{position:relative;display:inline-block;width:36px;min-width:36px;height:20px;background-color:var(--red-ui-secondary-border-color, #ccc);border-radius:10px;transition:background-color .2s ease}.nrg-toggle__slider[data-v-36b098e4]:after{content:\"\";position:absolute;top:2px;left:2px;width:16px;height:16px;background-color:#fff;border-radius:50%;transition:transform .2s ease}.nrg-toggle--checked .nrg-toggle__slider[data-v-36b098e4]{background-color:var(--red-ui-text-color-link, #0070d2)}.nrg-toggle--checked .nrg-toggle__slider[data-v-36b098e4]:after{transform:translate(16px)}.nrg-toggle__label[data-v-36b098e4]{cursor:default;white-space:nowrap}.nrg-toggle__label i[data-v-36b098e4]{margin-right:2px}\n";document.head.appendChild(s);})();
+(function(){var s=document.createElement("style");s.textContent=".nrg-toggles-grid[data-v-6a594f7a]{display:grid;grid-template-columns:1fr 1fr 1fr;gap:8px 16px}[data-v-6a594f7a] .node-red-vue-input-error-message{color:var(--red-ui-text-color-error)}[data-v-6a594f7a] .form-row input[type=text],[data-v-6a594f7a] .form-row input[type=number],[data-v-6a594f7a] .form-row input[type=password]{height:34px;padding:0 8px;box-sizing:border-box}.nrg-label[data-v-8b9bd83b]{display:inline-block;width:100%;cursor:default}.nrg-label i[data-v-8b9bd83b]{margin-right:5px}.nrg-required[data-v-8b9bd83b]{color:var(--red-ui-text-color-error);margin-left:2px}.editor-wrapper[data-v-2205b8dc]{position:relative}.expand-button[data-v-2205b8dc]{position:absolute;top:-23px;right:0;z-index:10;transition:color .3s ease;cursor:pointer}.nrg-toggle-wrapper[data-v-724dcae4]{display:inline-flex;align-items:center}.nrg-toggle[data-v-724dcae4]{position:relative;display:inline-flex!important;flex-direction:column;align-items:flex-start;cursor:pointer;gap:4px;-webkit-user-select:none;user-select:none}.nrg-toggle__input[data-v-724dcae4]{position:absolute;opacity:0;width:0;height:0}.nrg-toggle__slider[data-v-724dcae4]{position:relative;display:inline-block;width:36px;min-width:36px;height:20px;background-color:var(--red-ui-secondary-border-color, #ccc);border-radius:10px;transition:background-color .2s ease}.nrg-toggle__slider[data-v-724dcae4]:after{content:\"\";position:absolute;top:2px;left:2px;width:16px;height:16px;background-color:#fff;border-radius:50%;transition:transform .2s ease}.nrg-toggle--checked .nrg-toggle__slider[data-v-724dcae4]{background-color:var(--red-ui-text-color-link, #0070d2)}.nrg-toggle--checked .nrg-toggle__slider[data-v-724dcae4]:after{transform:translate(16px)}.nrg-toggle__label[data-v-724dcae4]{cursor:default;white-space:nowrap}.nrg-toggle__label i[data-v-724dcae4]{margin-right:2px}\n";document.head.appendChild(s);})();
 import { defineComponent as Pe, resolveComponent as he, openBlock as W, createElementBlock as ee, Fragment as nr, createVNode as $e, createCommentVNode as ne, createElementVNode as ce, normalizeClass as sr, renderSlot as ze, createTextVNode as Ln, toDisplayString as je, createBlock as be, withDirectives as Rs, vShow as Is, renderList as yr, createApp as js } from "/nrg/assets/vue.esm-browser.prod.js";
 function ks(e, t, { signal: r, edges: s } = {}) {
   let l, o = null;
@@ -5597,7 +5597,7 @@ function $o(e, t, r, s, l, o) {
     /* STABLE_FRAGMENT */
   );
 }
-const bo = /* @__PURE__ */ Oe(lo, [["render", $o], ["__scopeId", "data-v-8394a8d1"]]), wo = Pe({
+const bo = /* @__PURE__ */ Oe(lo, [["render", $o], ["__scopeId", "data-v-6a594f7a"]]), wo = Pe({
   name: "NodeRedInputLabel",
   props: {
     label: {
@@ -5644,7 +5644,7 @@ function Po(e, t, r, s, l, o) {
     e.required ? (W(), ee("span", So, "*")) : ne("v-if", !0)
   ]);
 }
-const Ae = /* @__PURE__ */ Oe(wo, [["render", Po], ["__scopeId", "data-v-9ffd05ad"]]), Vn = "*************", No = Pe({
+const Ae = /* @__PURE__ */ Oe(wo, [["render", Po], ["__scopeId", "data-v-8b9bd83b"]]), Vn = "*************", No = Pe({
   components: { NodeRedInputLabel: Ae },
   props: {
     value: {
@@ -6337,7 +6337,7 @@ function Qo(e, t, r, s, l, o) {
     /* NEED_PATCH */
   );
 }
-const bs = /* @__PURE__ */ Oe(Jo, [["render", Qo], ["__scopeId", "data-v-4077a6c2"]]), Xo = Pe({
+const bs = /* @__PURE__ */ Oe(Jo, [["render", Qo], ["__scopeId", "data-v-2205b8dc"]]), Xo = Pe({
   name: "NodeRedToggle",
   props: {
     modelValue: {
@@ -6410,7 +6410,7 @@ function ri(e, t, r, s, l, o) {
     )
   ]);
 }
-const ws = /* @__PURE__ */ Oe(Xo, [["render", ri], ["__scopeId", "data-v-36b098e4"]]), ni = /* @__PURE__ */ new Set([
+const ws = /* @__PURE__ */ Oe(Xo, [["render", ri], ["__scopeId", "data-v-724dcae4"]]), ni = /* @__PURE__ */ new Set([
   "id",
   "type",
   "x",
@@ -6772,13 +6772,7 @@ function pi(e, t, r, s, l, o) {
     ))
   ]);
 }
-const zn = /* @__PURE__ */ Oe(oi, [["render", pi]]), Ss = {}, ur = {};
-function vi(e) {
-  Object.assign(Ss, e);
-}
-function _i(e) {
-  Object.assign(ur, e);
-}
+const zn = /* @__PURE__ */ Oe(oi, [["render", pi]]);
 function hi(e, t, r, s) {
   const l = js(bo, {
     node: e,
@@ -6793,6 +6787,13 @@ function mi(e, t, r, s, l) {
 function rr(e) {
   e._app && (e._app.unmount(), e._app = null);
 }
+const Ss = {}, ur = {};
+function vi(e) {
+  Object.assign(Ss, e);
+}
+function _i(e) {
+  Object.assign(ur, e);
+}
 function Fn(e) {
   const t = {
     credentials: {}
@@ -6914,8 +6915,6 @@ async function yi(e) {
       const u = Object.keys(P)[0];
       u && (P[u] = {
         ...P[u],
-        // 2-arg signature (value, opt) tells Node-RED 3.x to accept
-        // string/array returns as error messages for the tooltip.
         validate: function(n, f) {
           return uo(this, v);
         }
@@ -6972,7 +6971,7 @@ async function yi(e) {
         if (f && f !== `${t}.outputLabels`) return f;
       },
       align: m.align || "left",
-      button: m.button,
+      button: m.button ? { ...m.button, onclick: m.button.onClick } : void 0,
       oneditprepare: a,
       oneditsave: i,
       oneditcancel: y,

package/test/index.js

@@ -145,8 +145,175 @@ function createMockNodeRedNode(options = {}) {
   };
 }
 
+// src/core/validator.ts
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+import addErrors from "ajv-errors";
+var Validator = class {
+  ajv;
+  constructor(options) {
+    const { customKeywords, customFormats, ...ajvOptions } = options || {};
+    this.ajv = new Ajv({
+      allErrors: true,
+      code: {
+        source: false
+      },
+      coerceTypes: true,
+      removeAdditional: false,
+      strict: false,
+      strictSchema: false,
+      useDefaults: true,
+      validateFormats: true,
+      // NOTE: typebox handles validation via typescript
+      // NOTE: if true, types that are not serializable JSON, like Function, would not work
+      validateSchema: false,
+      verbose: true,
+      ...ajvOptions
+    });
+    addFormats(this.ajv);
+    addErrors(this.ajv);
+    this.addCustomKeywords(customKeywords || []);
+    this.addCustomFormats(customFormats || {});
+  }
+  /**
+   * Add custom keywords to the validator
+   */
+  addCustomKeywords(keywords) {
+    if (!keywords) return;
+    keywords.forEach((keyword) => {
+      this.ajv.addKeyword(keyword);
+    });
+  }
+  /**
+   * Add custom formats to the validator
+   */
+  addCustomFormats(formats) {
+    if (!formats) return;
+    Object.entries(formats).forEach(([name, validator2]) => {
+      if (validator2 instanceof RegExp) {
+        this.ajv.addFormat(name, validator2);
+      } else {
+        this.ajv.addFormat(name, { validate: validator2 });
+      }
+    });
+  }
+  /**
+   * Create a validator function with caching
+   * @param schema - JSON Schema to validate against
+   * @param cacheKey - Optional cache key for reusing validators
+   */
+  createValidator(schema, cacheKey) {
+    if (cacheKey && !schema.$id) {
+      schema.$id = cacheKey;
+    }
+    if (schema.$id) {
+      const cached = this.ajv.getSchema(schema.$id);
+      if (cached) return cached;
+    }
+    const validator2 = this.ajv.compile(schema);
+    return validator2;
+  }
+  /**
+   * Validate data against a schema and return a structured result
+   */
+  validate(data, schema, options) {
+    const validator2 = this.createValidator(schema, options?.cacheKey);
+    const valid = validator2(data);
+    if (!valid) {
+      const errorMessage = this.formatErrors(validator2.errors);
+      if (options?.throwOnError) {
+        throw new ValidationError(errorMessage, validator2.errors || []);
+      }
+      return {
+        valid: false,
+        errors: validator2.errors || void 0,
+        errorMessage
+      };
+    }
+    return {
+      valid: true,
+      data
+    };
+  }
+  /**
+   * Format errors into a human-readable string
+   */
+  formatErrors(errors, options) {
+    if (!errors || errors.length === 0) {
+      return "No errors";
+    }
+    return this.ajv.errorsText(errors, {
+      separator: "; ",
+      dataVar: "data",
+      ...options
+    });
+  }
+  /**
+   * Get detailed error information
+   */
+  getDetailedErrors(errors) {
+    if (!errors || errors.length === 0) return [];
+    return errors.map((error) => ({
+      field: error.instancePath || "/",
+      message: error.message || "Validation failed",
+      keyword: error.keyword,
+      params: error.params,
+      schemaPath: error.schemaPath
+    }));
+  }
+  /**
+   * Add a schema to the validator for reference
+   */
+  addSchema(schema, key) {
+    this.ajv.addSchema(schema, key);
+    return this;
+  }
+  /**
+   * Remove a schema from the validator
+   */
+  removeSchema(key) {
+    this.ajv.removeSchema(key);
+    return this;
+  }
+};
+var ValidationError = class _ValidationError extends Error {
+  constructor(message, errors) {
+    super(message);
+    this.errors = errors;
+    this.name = "ValidationError";
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+
+// src/core/server/validation.ts
+var validator = void 0;
+function initValidator(RED) {
+  validator = new Validator({
+    customKeywords: [
+      {
+        keyword: "x-nrg-skip-validation",
+        schemaType: "boolean",
+        valid: true
+      },
+      {
+        keyword: "x-nrg-node-type",
+        type: "string",
+        validate: (schemaValue, dataValue) => {
+          if (!dataValue) return true;
+          const node = RED.nodes.getNode(dataValue);
+          return node?.type === schemaValue;
+        }
+      }
+    ],
+    customFormats: {
+      "node-id": /^[a-zA-Z0-9-_]+$/,
+      "flow-id": /^[a-f0-9]{16}$/,
+      "topic-path": (data) => /^[a-zA-Z0-9/_-]+$/.test(data)
+    }
+  });
+}
+
 // src/test/index.ts
-import { initValidator } from "@bonsae/nrg/server";
 function buildConfig(NodeClass, userConfig = {}) {
   const defaults = {};
   if (NodeClass.configSchema?.properties) {
@@ -235,10 +402,19 @@ async function createNode(NodeClass, options = {}) {
   const {
     config: userConfig = {},
     credentials = {},
-    configNodes = {},
     settings = {},
     overrides: overrideOpts = {}
   } = options;
+  const resolvedConfig = {};
+  const configNodes = {};
+  for (const [key, value] of Object.entries(userConfig)) {
+    if (value && typeof value === "object" && "id" in value && "config" in value) {
+      configNodes[value.id] = value;
+      resolvedConfig[key] = value.id;
+    } else {
+      resolvedConfig[key] = value;
+    }
+  }
   const redNodes = buildNodeRedNodes(configNodes);
   const RED = createMockRED({ nodes: redNodes, settings });
   initValidator(RED);
@@ -251,7 +427,7 @@ async function createNode(NodeClass, options = {}) {
   }
   const config = buildConfig(NodeClass, {
     ...configDefaults,
-    ...userConfig
+    ...resolvedConfig
   });
   const nodeRedNode = createMockNodeRedNode({
     id: config.id,

package/types/client.d.ts

@@ -1,36 +1,98 @@
+// Generated by dts-bundle-generator v9.5.1
 
-import type { Component } from "vue";
+import { App, Component } from 'vue';
 
+export interface NodeStateCredentials {
+	[key: string]: any;
+}
+export interface NodeState {
+	credentials: NodeStateCredentials;
+	[key: string]: any;
+}
 export interface NodeButtonDefinition {
-  toggle: string;
-  onclick: () => void;
-  enabled?: () => boolean;
-  visible?: () => boolean;
+	toggle: string;
+	onClick: () => void;
+	enabled?: () => boolean;
+	visible?: () => boolean;
+}
+export interface NodeRedNodeButtonDefinition {
+	toggle: string;
+	onclick: () => void;
+	enabled?: () => boolean;
+	visible?: () => boolean;
 }
-
 export interface NodeFormDefinition {
-  component?: Component;
+	component?: Component;
+}
+export interface NodeRedNode {
+	id: string;
+	type: string;
+	name: string;
+	category: string;
+	x: string;
+	y: string;
+	g: string;
+	z: string;
+	credentials: Record<string, any>;
+	_def: {
+		defaults: Record<string, {
+			value: string;
+			type?: string;
+			label?: string;
+			required?: boolean;
+		}>;
+		credentials: Record<string, {
+			value: string;
+			type?: "password" | "text";
+			label?: string;
+			required?: boolean;
+		}>;
+		category: string;
+		color?: string;
+		icon?: string;
+		label?: ((this: NodeRedNode) => string) | string;
+		inputs?: number;
+		outputs?: number;
+		paletteLabel?: ((this: NodeRedNode) => string) | string;
+		labelStyle?: ((this: NodeRedNode) => string) | string;
+		inputLabels?: ((this: NodeRedNode, index: number) => string) | string;
+		outputLabels?: ((this: NodeRedNode, index: number) => string) | string;
+		align?: "left" | "right";
+		button?: NodeRedNodeButtonDefinition;
+	};
+	_newState?: NodeRedNode;
+	_app?: App | null;
+	_: (str: string) => string;
+	[key: string]: any;
 }
-
 export interface NodeDefinition {
-  type: string;
-  category?: string;
-  color?: string;
-  icon?: ((this: any) => string) | string;
-  label?: ((this: any) => string) | string;
-  inputs?: number;
-  outputs?: number;
-  paletteLabel?: ((this: any) => string) | string;
-  labelStyle?: ((this: any) => string) | string;
-  inputLabels?: ((this: any) => string) | string;
-  outputLabels?: ((this: any) => string) | string;
-  align?: "left" | "right";
-  button?: NodeButtonDefinition;
-  onEditResize?: (this: any, size: { width: number; height: number }) => void;
-  onPaletteAdd?: (this: any) => void;
-  onPaletteRemove?: (this: any) => void;
-  form?: NodeFormDefinition;
+	type: string;
+	category?: string;
+	color?: string;
+	icon?: ((this: NodeRedNode) => string) | string;
+	label?: ((this: NodeRedNode) => string) | string;
+	inputs?: number;
+	outputs?: number;
+	paletteLabel?: ((this: NodeRedNode) => string) | string;
+	labelStyle?: ((this: NodeRedNode) => string) | string;
+	inputLabels?: ((this: NodeRedNode, index: number) => string) | string;
+	outputLabels?: ((this: NodeRedNode, index: number) => string) | string;
+	align?: "left" | "right";
+	button?: NodeButtonDefinition;
+	onEditResize?: (this: NodeRedNode, size: {
+		width: number;
+		height: number;
+	}) => void;
+	onPaletteAdd?: (this: NodeRedNode) => void;
+	onPaletteRemove?: (this: NodeRedNode) => void;
+	form?: NodeFormDefinition;
 }
+export interface NodeFeatures {
+	hasInputSchema: boolean;
+	hasOutputSchema: boolean;
+}
+
+export {};
 
 export declare function defineNode<T extends NodeDefinition>(options: T): T;
 export declare function registerType(definition: NodeDefinition): Promise<void>;

package/types/server.d.ts

@@ -1262,6 +1262,15 @@ export interface TVoid extends TSchema {
 	type: "void";
 }
 export interface SchemaOptions {
+  exportable?: boolean;
+  "x-nrg-node-type"?: string;
+  "x-nrg-form"?: {
+    icon?: string;
+    typedInputTypes?: string[];
+    editorLanguage?: string;
+    toggle?: boolean;
+  };
+
 	$schema?: string;
 	/** Id for this schema */
 	$id?: string;
@@ -2048,6 +2057,16 @@ declare class TypedInput<T = unknown> {
 	get value(): unknown;
 	resolve(msg?: Record<string, any>): Promise<T>;
 }
+export interface NrgSchemaExtensions {
+	exportable?: boolean;
+	"x-nrg-node-type"?: string;
+	"x-nrg-form"?: {
+		icon?: string;
+		typedInputTypes?: string[];
+		editorLanguage?: string;
+		toggle?: boolean;
+	};
+}
 export interface TNodeRef<T = any> extends TSchema {
 	[Kind]: "NodeRef";
 	static: T;
@@ -2063,20 +2082,9 @@ export interface TTypedInput<T = unknown> extends TSchema {
 	[Kind]: "TypedInput";
 	static: TypedInput<T>;
 }
-export interface NrgFormOptions {
-	icon?: string;
-	typedInputTypes?: string[];
-	editorLanguage?: string;
-	toggle?: boolean;
-}
-export interface NrgSchemaOptions extends SchemaOptions {
-	exportable?: boolean;
-	"x-nrg-node-type"?: string;
-	"x-nrg-form"?: NrgFormOptions;
-}
-export interface Schema<T extends TProperties = TProperties> extends TObject<T> {
-	$id: string;
+export interface NrgSchemaOptions extends SchemaOptions, NrgSchemaExtensions {
 }
+export type Schema<T extends TProperties = TProperties> = TObject<T>;
 declare const NodeConfigSchema: TObject<{
 	id: TString;
 	type: TString;
@@ -2106,8 +2114,8 @@ export declare const SchemaType: JavaScriptTypeBuilder & {
 	NodeRef: typeof NodeRef;
 	TypedInput: typeof TypedInput$1;
 };
-export declare function defineSchema<T extends TProperties>(properties: T, options: ObjectOptions & {
-	$id: string;
+export declare function defineSchema<T extends TProperties>(properties: T, options?: ObjectOptions & {
+	$id?: string;
 }): Schema<T>;
 export type NodeContextScope = "node" | "flow" | "global";
 export interface NodeContextStore {
@@ -2143,20 +2151,20 @@ export type ConfigNodeContext = {
 	node: NodeContextStore;
 	global: NodeContextStore;
 };
-export declare abstract class IONode<TConfig = any, TCredentials = any, TInput = any, TOutput = any, TSettings = any> extends Node$1<TConfig, TCredentials, TSettings> {
+export declare class IONode<TConfig = any, TCredentials = any, TInput = any, TOutput = any, TSettings = any> extends Node$1<TConfig, TCredentials, TSettings> {
 	static readonly align?: "left" | "right";
 	static readonly color: HexColor;
-	static readonly inputs?: number;
-	static readonly outputs?: number;
 	static readonly inputSchema?: Schema;
 	static readonly outputsSchema?: Schema | Schema[];
 	static readonly validateInput: boolean;
 	static readonly validateOutput: boolean;
+	static get inputs(): 0 | 1;
+	static get outputs(): number;
 	private _send;
 	readonly config: IONodeConfig<TConfig>;
 	protected readonly context: IONodeContext;
 	constructor(RED: RED, node: any, config: IONodeConfig<TConfig>, credentials: IONodeCredentials<TCredentials>);
-	abstract input(msg: TInput): void | Promise<void>;
+	input(msg: TInput): void | Promise<void>;
 	send(msg: TOutput): void;
 	private _nodeSource;
 	status(status: IONodeStatus): void;
@@ -2203,8 +2211,6 @@ export interface IONodeDefinition<TConfigSchema extends TSchema | undefined = un
 	type: string;
 	category?: string;
 	color?: HexColor;
-	inputs?: 0 | 1;
-	outputs?: number;
 	align?: "left" | "right";
 	configSchema?: TConfigSchema;
 	credentialsSchema?: TCredsSchema;

package/types/test.d.ts

@@ -1,39 +1,49 @@
+// Generated by dts-bundle-generator v9.5.1
 
+export interface MockNodeRedNodeOptions {
+	id?: string;
+	type?: string;
+	name?: string;
+	z?: string;
+	wires?: string[][];
+	credentials?: Record<string, any>;
+	[key: string]: any;
+}
 export interface CreateNodeOptions {
-  config?: Record<string, any>;
-  credentials?: Record<string, any>;
-  configNodes?: Record<string, any>;
-  settings?: Record<string, any>;
-  overrides?: Record<string, any>;
+	config?: Record<string, any>;
+	credentials?: Record<string, any>;
+	settings?: Record<string, any>;
+	overrides?: MockNodeRedNodeOptions;
 }
-
-type ExtractInput<T> = T extends { input(msg: infer I): any } ? I : any;
-type ExtractOutput<T> = T extends { send(msg: infer O): any } ? O : any;
-
+export type ExtractInput<T> = T extends {
+	input(msg: infer I): any;
+} ? I : any;
+export type ExtractOutput<T> = T extends {
+	send(msg: infer O): any;
+} ? O : any;
 export interface TestNodeHelpers<TInput = any, TOutput = any> {
-  receive(msg: TInput): Promise<void>;
-  close(removed?: boolean): Promise<void>;
-  reset(): void;
-  sent(): TOutput[];
-  sent(port: number): any[];
-  statuses(): any[];
-  logged(level?: "info" | "warn" | "error" | "debug"): string[];
-  warned(): string[];
-  errored(): string[];
+	receive(msg: TInput): Promise<void>;
+	close(removed?: boolean): Promise<void>;
+	reset(): void;
+	sent(): TOutput[];
+	sent(port: number): any[];
+	statuses(): any[];
+	logged(level?: "info" | "warn" | "error" | "debug"): string[];
+	warned(): string[];
+	errored(): string[];
 }
-
 export interface CreateNodeResult<T> {
-  node: T & TestNodeHelpers<ExtractInput<T>, ExtractOutput<T>>;
-  RED: any;
+	node: T & TestNodeHelpers<ExtractInput<T>, ExtractOutput<T>>;
+	RED: any;
 }
-
-interface NodeClass {
-  readonly type: string;
-  readonly category?: string;
-  readonly configSchema?: any;
-  registered?(RED: any): void | Promise<void>;
-  _registered?(RED: any): void | Promise<void>;
-  new (...args: any[]): any;
+export interface NodeClass {
+	readonly type: string;
+	readonly category?: string;
+	readonly configSchema?: any;
+	registered?(RED: any): void | Promise<void>;
+	_registered?(RED: any): void | Promise<void>;
+	new (...args: any[]): any;
 }
-
 export declare function createNode<T extends NodeClass>(NodeClass: T, options?: CreateNodeOptions): Promise<CreateNodeResult<InstanceType<T>>>;
+
+export {};