@bonsae/nrg 0.22.1 → 0.22.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bonsae/nrg",
-  "version": "0.22.1",
+  "version": "0.22.2",
   "description": "NRG framework — build Node-RED nodes with Vue 3, TypeScript, and JSON Schema",
   "author": "Allan Oricil <allanoricil@duck.com>",
   "license": "MIT",
@@ -119,7 +119,7 @@
     }
   },
   "dependencies": {
-    "@bonsae/nrg-runtime": "0.22.1",
+    "@bonsae/nrg-runtime": "0.22.2",
     "@clack/prompts": "^1.0.1",
     "@sinclair/typebox": "^0.34.33",
     "@vitejs/plugin-vue": "^5.2.3",

package/types/client.d.ts

@@ -1 +1,266 @@
-export * from "@bonsae/nrg-runtime/client";
+// Generated by dts-bundle-generator v9.5.1
+
+import { Static, TSchema } from '@sinclair/typebox';
+import { SchemaObject } from 'ajv';
+import { App, Component } from 'vue';
+
+interface NodeRefResolved<T = any> {
+	readonly __nrg_node_ref: true;
+	readonly __instance: T;
+}
+interface TypedInputResolved {
+	resolve(...args: any[]): any;
+	value: unknown;
+	type: string;
+}
+interface JsonSchemaObjectExtensions {
+	format?: "node-id" | "flow-id" | "topic-path" | (string & {});
+	/** expose this settings property to the editor via RED.settings */
+	exportable?: boolean;
+	/** set by SchemaType.NodeRef — the referenced config node type */
+	"x-nrg-node-type"?: string;
+	/** set by SchemaType.TypedInput — marks a TypedInput value/type pair */
+	"x-nrg-typed-input"?: boolean;
+	/** set by markNonValidatable — ajv skips this property */
+	"x-nrg-skip-validation"?: boolean;
+	/** form rendering hints consumed by the auto-generated editor form */
+	"x-nrg-form"?: {
+		icon?: string;
+		typedInputTypes?: string[];
+		editorLanguage?: string;
+		toggle?: boolean;
+	};
+}
+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;
+}
+export interface NodeRedNodeButtonDefinition {
+	toggle: string;
+	onclick: () => void;
+	enabled?: () => boolean;
+	visible?: () => boolean;
+}
+export interface NodeFormDefinition {
+	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;
+	/** dynamic port count (base outputs + enabled built-in ports) */
+	outputs?: number;
+	/** injected when the node has an inputSchema */
+	validateInput?: boolean;
+	/** built-in port toggles, present when declared in the configSchema */
+	errorPort?: boolean;
+	completePort?: boolean;
+	statusPort?: boolean;
+	/**
+	 * Per-port output settings, indexed by base-output port. `validateOutputs` is
+	 * injected (empty) when the node has an outputsSchema; `outputReturnProperties`
+	 * and `outputContextModes` are author-declared (SchemaType.*) — present only
+	 * when the node opts into per-port return keys / context modes. Read at
+	 * runtime by IONode.
+	 */
+	validateOutputs?: Record<number, boolean>;
+	outputContextModes?: Record<number, "carry" | "trace" | "reset">;
+	outputReturnProperties?: Record<number, string>;
+	[key: string]: any;
+}
+export interface NodeDefinition {
+	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;
+}
+/** Form rendering hints carried by the `x-nrg-form` schema keyword. */
+export type NrgFormOptions = NonNullable<JsonSchemaObjectExtensions["x-nrg-form"]>;
+/**
+ * A serialized property schema inside {@link JsonSchemaObject} `properties`,
+ * including NRG's custom keywords (shared vocabulary in core/schema-options)
+ * that drive form rendering and NodeRef/TypedInput identification.
+ */
+export interface JsonPropertySchema extends JsonSchemaObjectExtensions {
+	type?: string | string[];
+	properties?: Record<string, JsonPropertySchema>;
+	required?: string[];
+	enum?: unknown[];
+	anyOf?: JsonPropertySchema[];
+	const?: unknown;
+	items?: JsonPropertySchema;
+	title?: string;
+	description?: string;
+	default?: unknown;
+}
+/**
+ * A serialized JSON Schema object as the build pipeline emits it (never a
+ * live TypeBox instance). Extends ajv's `SchemaObject` so it flows into
+ * validator APIs without casts, while keeping the `type: "object"`
+ * discriminant and structured `properties`/`required` that ajv's open
+ * `[x: string]: any` shape does not provide.
+ */
+export interface JsonSchemaObject extends SchemaObject {
+	type: "object";
+	properties?: Record<string, JsonPropertySchema>;
+	required?: string[];
+}
+/**
+ * A node definition as it exists at editor runtime, after the build pipeline
+ * merged in the schema-derived artifacts (defaults, credentials, serialized
+ * schemas). Authors write {@link NodeDefinition}; the inliner provides the
+ * rest.
+ */
+export interface RuntimeNodeDefinition extends NodeDefinition {
+	defaults?: NodeDefaults;
+	credentials?: NodeCredentials;
+	/**
+	 * Names of the base output ports when `outputsSchema` is a record of named
+	 * ports, in declaration order; absent for single/positional outputs. Resolved
+	 * server-side by the inliner so the editor never guesses port names from the
+	 * serialized schema.
+	 */
+	outputPortNames?: string[];
+	configSchema?: JsonSchemaObject;
+	credentialsSchema?: JsonSchemaObject;
+	inputSchema?: JsonSchemaObject;
+	/**
+	 * Single port, positional ports, or named ports (key = port name).
+	 * Not constrained to object schemas: with returnProperty the raw sent
+	 * value is validated, so results may be any schema shape.
+	 */
+	outputsSchema?: JsonPropertySchema | JsonPropertySchema[] | Record<string, JsonPropertySchema>;
+}
+export interface NodeDefaults {
+	[key: string]: {
+		value: any;
+		type?: string;
+		label?: string;
+		required?: boolean;
+		validate?: (this: NodeRedNode, value: any, opt: any) => any;
+	};
+}
+export interface NodeCredentials {
+	[key: string]: {
+		value?: string;
+		type?: "password" | "text";
+		label?: string;
+		required?: boolean;
+	};
+}
+export interface NodeFeatures {
+	hasInputSchema: boolean;
+	hasOutputSchema: boolean;
+	/**
+	 * Base output ports (excludes built-in error/complete/status), in port-index
+	 * order. Drives the per-port context-mode rows in the Outputs subsection.
+	 */
+	outputPorts: {
+		index: number;
+		label: string;
+	}[];
+}
+/** Client-side representation of a TypedInput field: the raw value string and its type selector. */
+export interface TypedInputValue {
+	value: string;
+	type: string;
+}
+/**
+ * Maps a schema's static type to the raw values the editor form holds.
+ * The server counterpart (`ResolvedStatic` in server/schemas/types) maps the
+ * same brands — shared via core/brands — to resolved runtime values instead.
+ * - `NodeRef<T>` → `string` (the referenced node's id)
+ * - `TypedInput<T>` → `TypedInputValue` (raw value + type pair)
+ * - Functions pass through, arrays and objects map recursively
+ */
+export type EditorStatic<T> = T extends NodeRefResolved<any> ? string : T extends TypedInputResolved ? TypedInputValue : T extends (...args: any[]) => any ? T : T extends Array<infer I> ? EditorStatic<I>[] : T extends object ? {
+	[K in keyof T]: EditorStatic<T[K]>;
+} : T;
+/**
+ * Infers the client-side TypeScript type from a TypeBox schema.
+ *
+ * Resolves schema types to their client form representations:
+ * - `NodeRef<T>` → `string` (node ID in the editor)
+ * - `TypedInput<T>` → `{ value: string; type: string }`
+ * - All other types resolve via TypeBox's `Static<T>`
+ *
+ * @example
+ * ```ts
+ * import type { Infer } from "@bonsae/nrg/client";
+ * import type { ConfigSchema } from "../schemas/my-node";
+ *
+ * type Config = Infer<typeof ConfigSchema>;
+ * ```
+ */
+export type Infer<T extends TSchema> = EditorStatic<Static<T>>;
+
+export {};
+
+export declare function defineNode<T extends NodeDefinition>(options: T): T;
+export declare function registerType(definition: NodeDefinition): Promise<void>;
+export declare function registerTypes(nodes: NodeDefinition[]): Promise<void>;
+export declare function useFormNode<TConfig extends TSchema = TSchema, TCredentials extends TSchema = TSchema>(): {
+  node: NodeRedNode & Infer<TConfig> & { credentials: Infer<TCredentials> & Record<string, any> };
+  schema: Record<string, any>;
+  errors: Record<string, string>;
+};

package/types/server.d.ts

@@ -1 +1,941 @@
-export * from "@bonsae/nrg-runtime/server";
+/// <reference path="./shims/typebox.d.ts" />
+// Generated by dts-bundle-generator v9.5.1
+
+import { Kind, ObjectOptions, SchemaOptions, Static, TArray, TBoolean, TConst, TEnum, TFunction, TInteger, TIntersect, TLiteral, TNull, TNumber, TObject, TOptional, TProperties, TRecord, TRef, TSchema, TString, TTuple, TUnion } from '@sinclair/typebox';
+import { EventEmitter } from 'events';
+import { Express as Express$1 } from 'express';
+import { Http2ServerRequest } from 'http2';
+
+declare const TYPED_INPUT_TYPES: readonly [
+	"msg",
+	"flow",
+	"global",
+	"str",
+	"num",
+	"bool",
+	"json",
+	"bin",
+	"re",
+	"jsonata",
+	"date",
+	"env",
+	"node",
+	"cred"
+];
+declare const BUILTIN_PORT_KEYS: readonly [
+	"errorPort",
+	"completePort",
+	"statusPort"
+];
+export interface NodeRedRuntimeSettings {
+	userDir?: string;
+	nodesDir?: string | string[];
+	flowFile?: string;
+	flowFilePretty?: boolean;
+	credentialSecret?: string | false;
+	requireHttps?: boolean;
+	https?: {
+		key: string;
+		cert: string;
+	} | (() => Promise<{
+		key: string;
+		cert: string;
+	}> | {
+		key: string;
+		cert: string;
+	});
+	httpsRefreshInterval?: number;
+	httpAdminRoot?: string;
+	httpNodeRoot?: string;
+	httpNodeCors?: {
+		origin: string;
+		methods: string;
+	};
+	httpStatic?: string | {
+		path: string;
+		root: string;
+	}[];
+	httpStaticRoot?: string;
+	httpAdminMiddleware?: (req: unknown, res: unknown, next: () => void) => void;
+	httpNodeMiddleware?: (req: unknown, res: unknown, next: () => void) => void;
+	httpServerOptions?: Record<string, unknown>;
+	adminAuth?: {
+		type?: "credentials" | "strategy";
+		users?: {
+			username: string;
+			password: string;
+			permissions?: string | string[];
+		}[];
+		default?: {
+			permissions?: string | string[];
+		};
+		tokens?: (token: string) => Promise<{
+			user: string;
+			permissions: string | string[];
+		} | null>;
+		tokenHeader: "string";
+		sessionExpiryTime?: number;
+		[key: string]: unknown;
+	};
+	httpNodeAuth?: {
+		user?: string;
+		pass?: string;
+	};
+	httpStaticAuth?: {
+		user?: string;
+		pass?: string;
+	};
+	lang?: "en-US" | "de" | "es-ES" | "fr" | "ko" | "pt-BR" | "ru" | "ja" | "zh-CN" | "zh-TW";
+	diagnostics?: {
+		enabled?: boolean;
+		ui?: boolean;
+	};
+	runtimeState?: {
+		enabled?: boolean;
+		ui?: boolean;
+	};
+	disableEditor?: boolean;
+	editorTheme?: {
+		page?: {
+			title?: string;
+			favicon?: string;
+			css?: string | string[];
+			scripts?: string | string[];
+		};
+		header?: {
+			title?: string;
+			image?: string;
+			url?: string;
+		};
+		deployButton?: {
+			type?: "simple" | "default";
+			label?: string;
+			icon?: string;
+		};
+		menu?: {
+			"menu-item-import-library"?: boolean;
+			"menu-item-export-library"?: boolean;
+			"menu-item-keyboard-shortcuts"?: boolean;
+			"menu-item-help"?: {
+				label?: string;
+				url?: string;
+			};
+			[menuItem: string]: boolean | {
+				label?: string;
+				url?: string;
+			} | undefined;
+		};
+		userMenu?: boolean;
+		login?: {
+			image?: string;
+		};
+		logout?: {
+			redirect?: string;
+		};
+		palette?: {
+			catalogues?: string[];
+			categories?: string[];
+			theme?: {
+				category: string;
+				type: string;
+				color: string;
+			}[];
+		};
+		projects?: {
+			enabled?: boolean;
+			workflow?: {
+				mode: "manual" | "auto";
+			};
+		};
+		codeEditor?: {
+			lib?: "monaco" | "ace";
+			options?: Record<string, unknown>;
+		};
+		mermaid?: {
+			theme?: string;
+		};
+		tours?: boolean;
+		theme?: string;
+		[key: string]: unknown;
+	};
+	contextStorage?: {
+		default?: {
+			module?: "memory" | "localfilesystem" | object;
+			config?: Record<string, unknown>;
+		};
+		[store: string]: {
+			module?: "memory" | "localfilesystem" | object;
+			config?: Record<string, unknown>;
+		} | undefined;
+	};
+	exportGlobalContextKeys?: boolean;
+	logging?: {
+		console?: {
+			level?: "fatal" | "error" | "warn" | "info" | "debug" | "trace" | "off";
+			metrics?: boolean;
+			audit?: boolean;
+		};
+	};
+	fileWorkingDirectory?: string;
+	functionExternalModules?: boolean;
+	functionGlobalContext?: Record<string, unknown>;
+	nodeMessageBufferMaxLength?: number;
+	functionTimeout?: number;
+	externalModules?: {
+		autoInstall?: boolean;
+		autoInstallRetry?: number;
+		palette?: {
+			allowInstall?: boolean;
+			allowUpdate?: boolean;
+			allowUpload?: boolean;
+			allowList?: string[];
+			denyList?: string[];
+			allowUpdateList?: string[];
+			denyUpdateList?: string[];
+		};
+		modules?: {
+			allowInstall?: boolean;
+			allowList?: string[];
+			denyList?: string[];
+		};
+	};
+	execMaxBufferSize?: number;
+	debugMaxLength?: number;
+	debugUseColors?: boolean;
+	httpRequestTimeout?: number;
+	mqttReconnectTime?: number;
+	serialReconnectTime?: number;
+	socketReconnectTime?: number;
+	socketTimeout?: number;
+	tcpMsgQueueSize?: number;
+	inboundWebSocketTimeout?: number;
+	tlsConfigDisableLocalFiles?: boolean;
+	webSocketNodeVerifyClient?: (info: {
+		origin: string;
+		req: Http2ServerRequest;
+		secure: boolean;
+	}) => boolean;
+	apiMaxLength?: string;
+	[key: string]: unknown;
+}
+interface NodeRedLog {
+	info(msg: any): void;
+	warn(msg: any): void;
+	error(msg: any, error?: any): void;
+	debug(msg: any): void;
+	trace(msg: any): void;
+	log(msg: {
+		level: number;
+		msg: string;
+	}): void;
+	metric(): boolean;
+	audit(msg: Record<string, any>, req?: any): void;
+	addHandler(handler: (msg: any) => void): void;
+	removeHandler(handler: (msg: any) => void): void;
+	FATAL: 10;
+	ERROR: 20;
+	WARN: 30;
+	INFO: 40;
+	DEBUG: 50;
+	TRACE: 60;
+	AUDIT: 98;
+	METRIC: 99;
+}
+interface NodeRedNode {
+	id: string;
+	type: string;
+	name?: string;
+	z?: string;
+	x: number;
+	y: number;
+	g?: string;
+	wires: string[][];
+	credentials: any;
+	_node?: INode;
+	send(msg: any): void;
+	receive(msg: any): void;
+	status(status: string | {
+		fill?: string;
+		shape?: string;
+		text?: string;
+	}): void;
+	updateWires(wires: string[][]): void;
+	on(event: string, callback: (...args: any[]) => void): void;
+	log(msg: any): void;
+	warn(msg: any): void;
+	error(msg: any, errorMsg?: any): void;
+	context(): NodeRedNodeContext;
+	[key: string]: any;
+}
+interface NodeRedNodeContext extends NodeRedContextStore {
+	flow: NodeRedContextStore;
+	global: NodeRedContextStore;
+}
+interface NodeRedNodes {
+	registerType(type: string, constructor: any, opts?: any): void;
+	getNode(id: string): (NodeRedNode & {
+		_node?: INode;
+	}) | undefined;
+	createNode(node: NodeRedNode, config: Record<string, any>): void;
+	getCredentials(id: string): Record<string, any> | undefined;
+	/** Merge credentials into a node's stored credential set (runtime API). */
+	addCredentials(id: string, credentials: Record<string, any>): void;
+	eachNode(callback: (node: any) => void): void;
+	getType(type: string): any;
+	getNodeInfo(type: string): any;
+	getNodeList(filter?: any): any[];
+	getModuleInfo(module: string): any;
+	installModule(module: string, version?: string): Promise<any>;
+	uninstallModule(module: string): Promise<any>;
+	enableNode(id: string): Promise<any>;
+	disableNode(id: string): Promise<any>;
+}
+interface NodeRedUtil {
+	evaluateNodeProperty(value: any, type: string, node: any, msg: Record<string, any> | undefined, callback: (err: Error | null, result: any) => void): void;
+	generateId(): string;
+	cloneMessage<T = any>(msg: T): T;
+	ensureString(o: any): string;
+	ensureBuffer(o: any): Buffer;
+	compareObjects(obj1: any, obj2: any): boolean;
+	getMessageProperty(msg: any, expr: string): any;
+	setMessageProperty(msg: any, prop: string, value: any, createMissing?: boolean): void;
+	getObjectProperty(obj: any, expr: string): any;
+	setObjectProperty(obj: any, prop: string, value: any, createMissing?: boolean): void;
+	normalisePropertyExpression(str: string, msg?: any, toString?: boolean): string[];
+	normaliseNodeTypeName(name: string): string;
+	prepareJSONataExpression(value: string, node: any): any;
+	evaluateJSONataExpression(expr: any, msg: any, callback: (err: Error | null, result: any) => void): void;
+	parseContextStore(key: string): {
+		store: string | undefined;
+		key: string;
+	};
+	getSetting(node: any, name: string, flow?: any): any;
+	encodeObject(obj: any): any;
+}
+interface NodeRedHooks {
+	add(hookId: string, callback: (event: any) => void | Promise<void>): void;
+	remove(hookId: string): void;
+	trigger(hookId: string, event: any, callback?: (err?: Error) => void): void | Promise<void>;
+	has(hookId: string): boolean;
+	clear(): void;
+}
+type NodeRedExpressApp = Express;
+export interface RED {
+	/** Internationalization function */
+	_(key: string, substitutions?: Record<string, string>): string;
+	/** Logging API */
+	log: NodeRedLog;
+	/** Node registry and management */
+	nodes: NodeRedNodes;
+	/** Utility functions */
+	util: NodeRedUtil;
+	/** Hook system for message lifecycle and module events */
+	hooks: NodeRedHooks;
+	/** Runtime event emitter */
+	events: EventEmitter;
+	/** Express app for admin HTTP endpoints */
+	httpAdmin: NodeRedExpressApp;
+	/** Express app for node HTTP endpoints */
+	httpNode: NodeRedExpressApp;
+	/** Runtime settings (user-provided settings plus node-registered settings) */
+	settings: NodeRedRuntimeSettings & Record<string, any>;
+	/** Node-RED version string */
+	version(): string;
+}
+interface NodeRedContextStore {
+	get(key: string, store: string | undefined, callback: (err: Error | null, value: any) => void): void;
+	set(key: string, value: any, store: string | undefined, callback: (err: Error | null) => void): void;
+	keys(store: string | undefined, callback: (err: Error | null, keys: string[]) => void): void;
+	/**
+	 * Optional atomic add — provided by context stores that support it (e.g.
+	 * DynamoDB `ADD` / Redis `INCR`). When absent, nrg serializes in-process.
+	 */
+	increment?(key: string, by: number, store: string | undefined, callback: (err: Error | null, value: number) => void): void;
+	/**
+	 * Optional atomic read-modify-write — provided by stores that support it
+	 * (e.g. a DynamoDB conditional write). When absent, nrg serializes in-process.
+	 */
+	update?(key: string, fn: (current: any) => any, store: string | undefined, callback: (err: Error | null, value: any) => void): void;
+}
+declare class TypedInput<T = unknown> {
+	private readonly RED;
+	private readonly node;
+	private readonly input;
+	private readonly resolvers;
+	constructor(RED: RED, node: NodeRedNode, input: {
+		value: unknown;
+		type: TypedInputType;
+	});
+	get type(): TypedInputType;
+	get value(): unknown;
+	resolve(msg?: Record<string, any>): Promise<T>;
+}
+interface JsonSchemaObjectExtensions {
+	format?: "node-id" | "flow-id" | "topic-path" | (string & {});
+	/** expose this settings property to the editor via RED.settings */
+	exportable?: boolean;
+	/** set by SchemaType.NodeRef — the referenced config node type */
+	"x-nrg-node-type"?: string;
+	/** set by SchemaType.TypedInput — marks a TypedInput value/type pair */
+	"x-nrg-typed-input"?: boolean;
+	/** set by markNonValidatable — ajv skips this property */
+	"x-nrg-skip-validation"?: boolean;
+	/** form rendering hints consumed by the auto-generated editor form */
+	"x-nrg-form"?: {
+		icon?: string;
+		typedInputTypes?: string[];
+		editorLanguage?: string;
+		toggle?: boolean;
+	};
+}
+declare const NodeConfigSchema: import("@sinclair/typebox").TObject<{
+	id: import("@sinclair/typebox").TString;
+	type: import("@sinclair/typebox").TString;
+	name: import("@sinclair/typebox").TString;
+	z: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+declare const ConfigNodeConfigSchema: import("@sinclair/typebox").TObject<{
+	_users: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+	id: import("@sinclair/typebox").TString;
+	type: import("@sinclair/typebox").TString;
+	name: import("@sinclair/typebox").TString;
+	z: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+declare const IONodeConfigSchema: import("@sinclair/typebox").TObject<{
+	wires: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+	x: import("@sinclair/typebox").TNumber;
+	y: import("@sinclair/typebox").TNumber;
+	g: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+	id: import("@sinclair/typebox").TString;
+	type: import("@sinclair/typebox").TString;
+	name: import("@sinclair/typebox").TString;
+	z: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export declare const NodeSourceSchema: import("@sinclair/typebox").TObject<{
+	id: import("@sinclair/typebox").TString;
+	type: import("@sinclair/typebox").TString;
+	name: import("@sinclair/typebox").TString;
+}>;
+export declare const ErrorPortSchema: import("@sinclair/typebox").TObject<{
+	error: import("@sinclair/typebox").TObject<{
+		message: import("@sinclair/typebox").TString;
+		source: import("@sinclair/typebox").TObject<{
+			id: import("@sinclair/typebox").TString;
+			type: import("@sinclair/typebox").TString;
+			name: import("@sinclair/typebox").TString;
+		}>;
+	}>;
+}>;
+export declare const CompletePortSchema: import("@sinclair/typebox").TObject<{
+	complete: import("@sinclair/typebox").TObject<{
+		source: import("@sinclair/typebox").TObject<{
+			id: import("@sinclair/typebox").TString;
+			type: import("@sinclair/typebox").TString;
+			name: import("@sinclair/typebox").TString;
+		}>;
+	}>;
+}>;
+export declare const StatusPortSchema: import("@sinclair/typebox").TObject<{
+	status: import("@sinclair/typebox").TUnion<[
+		import("@sinclair/typebox").TObject<{
+			fill: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[
+				import("@sinclair/typebox").TLiteral<"red">,
+				import("@sinclair/typebox").TLiteral<"green">
+			]>>;
+			shape: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[
+				import("@sinclair/typebox").TLiteral<"dot">,
+				import("@sinclair/typebox").TLiteral<"string">
+			]>>;
+			text: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+		}>,
+		import("@sinclair/typebox").TString
+	]>;
+	source: import("@sinclair/typebox").TObject<{
+		id: import("@sinclair/typebox").TString;
+		type: import("@sinclair/typebox").TString;
+		name: import("@sinclair/typebox").TString;
+	}>;
+}>;
+interface NodeRefResolved<T = any> {
+	readonly __nrg_node_ref: true;
+	readonly __instance: T;
+}
+/** Schema type representing a reference to a config node. Resolves to the node instance at runtime. */
+export interface TNodeRef<T = any> extends TSchema {
+	[Kind]: "NodeRef";
+	static: NodeRefResolved<T>;
+	type: "string";
+	format: "node-id";
+	"x-nrg-node-type"?: string;
+}
+type ResolvedStatic<T> = T extends NodeRefResolved<infer I> ? I : T extends TypedInput<any> ? T : T extends (...args: any[]) => any ? T : T extends Array<infer Item> ? ResolvedStatic<Item>[] : T extends object ? {
+	[K in keyof T]: ResolvedStatic<T[K]>;
+} : T;
+/**
+ * Infers the TypeScript type from a schema or a record of schemas.
+ *
+ * - Single schema: `Infer<typeof MySchema>` → the inferred message type
+ * - Record of schemas: `Infer<typeof outputsSchema>` → `{ portName: InferredType }` port map
+ *
+ * The record form produces a simple mapped type that resolves eagerly,
+ * giving `sendToPort()` proper autocomplete in class-based nodes.
+ */
+export type Infer<T extends TSchema | Record<string, TSchema>> = T extends TSchema ? ResolvedStatic<Static<T>> : {
+	[K in keyof T & string]: T[K] extends TSchema ? ResolvedStatic<Static<T[K]>> : never;
+};
+type TypedInputType = (typeof TYPED_INPUT_TYPES)[number];
+/** Schema type representing a Node-RED TypedInput (value + type pair). */
+export interface TTypedInput<T = unknown> extends TSchema {
+	[Kind]: "TypedInput";
+	static: TypedInput<T>;
+	"x-nrg-typed-input": true;
+}
+interface NrgSchemaOptions extends SchemaOptions, JsonSchemaObjectExtensions {
+}
+/** An NRG object schema created by {@link defineSchema}. */
+export type Schema<T extends TProperties = TProperties> = TObject<T>;
+export type NodeSource = Static<typeof NodeSourceSchema>;
+export type ErrorPortMessage = Static<typeof ErrorPortSchema>;
+export type CompletePortMessage = Static<typeof CompletePortSchema>;
+export type StatusPortMessage = Static<typeof StatusPortSchema>;
+type InferOr<T, Fallback> = T extends TSchema ? Infer<T> : Fallback;
+type InferOutputs<T> = T extends readonly TSchema[] ? {
+	[K in keyof T]: T[K] extends TSchema ? Infer<T[K]> : never;
+} : T extends TSchema ? Infer<T> : T extends Record<string, TSchema> ? {
+	[K in keyof T & string]: Infer<T[K]>;
+} : any;
+declare function NodeRef<T extends (new (...args: any[]) => any) & {
+	type: string;
+}>(nodeClass: T, options?: NrgSchemaOptions): TNodeRef<InstanceType<T>>;
+declare function TypedInput$1<T = unknown>(options?: NrgSchemaOptions): TTypedInput<T>;
+declare function OutputReturnProperties(options?: NrgSchemaOptions & {
+	default?: Record<number, string>;
+}): import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TString>;
+declare function OutputContextModes(options?: NrgSchemaOptions & {
+	default?: Record<number, "carry" | "trace" | "reset">;
+}): import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TUnion<[
+	import("@sinclair/typebox").TLiteral<"carry">,
+	import("@sinclair/typebox").TLiteral<"trace">,
+	import("@sinclair/typebox").TLiteral<"reset">
+]>>;
+/**
+ * Extended TypeBox type builder with NRG-specific schema types.
+ * Includes all standard TypeBox types plus {@link NodeRef}, {@link TypedInput},
+ * {@link OutputReturnProperties} and {@link OutputContextModes}.
+ *
+ * For ports or config fields that carry non-data values (functions, class
+ * instances, Buffers, streams, connections), use `Unsafe<T>()` to get the
+ * TypeScript type without runtime validation — `Any()`/`Unknown()` skip
+ * validation too but lose the type. For config-node references and typed inputs
+ * use {@link NodeRef} / {@link TypedInput} instead. See the Schemas guide.
+ */
+export declare const SchemaType: import("@sinclair/typebox").JavaScriptTypeBuilder & {
+	NodeRef: typeof NodeRef;
+	TypedInput: typeof TypedInput$1;
+	OutputReturnProperties: typeof OutputReturnProperties;
+	OutputContextModes: typeof OutputContextModes;
+};
+/**
+ * Creates a validated object schema from a set of properties. Automatically
+ * marks non-JSON types (e.g., Function) as non-validatable.
+ *
+ * @example
+ * ```ts
+ * const ConfigsSchema = defineSchema({
+ *   name: SchemaType.String({ default: "" }),
+ *   timeout: SchemaType.Number({ default: 5000 }),
+ * }, { $id: "my-node:configs" });
+ * ```
+ */
+export declare function defineSchema<T extends TProperties>(properties: T, options?: ObjectOptions & {
+	$id?: string;
+}): Schema<T>;
+type NodeContextScope = "node" | "flow" | "global";
+interface NodeContextStore {
+	get<T = any>(key: string): Promise<T>;
+	set<T = any>(key: string, value: T): Promise<void>;
+	keys(): Promise<string[]>;
+	/**
+	 * Atomically add `by` (default 1) to a numeric key and return the new value.
+	 * Prefer this over `get`+`set` for counters: it's atomic across instances when
+	 * the context store supports it (e.g. a DynamoDB `ADD` or Redis `INCR` store),
+	 * and serialized within the process otherwise — so concurrent messages never
+	 * lose updates.
+	 */
+	increment(key: string, by?: number): Promise<number>;
+	/**
+	 * Atomic read-modify-write: `fn(current)` returns the next value, applied
+	 * atomically (a conditional write + retry on a capable store, a per-key lock
+	 * otherwise). `fn` MAY run more than once on a write conflict, so keep it pure
+	 * (no side effects).
+	 */
+	update<T = any>(key: string, fn: (current: T) => T | Promise<T>): Promise<T>;
+}
+export interface NodeConstructor<T = any, TConfig = any, TCredentials = any> {
+	readonly type: string;
+	readonly category: string;
+	readonly color?: string;
+	readonly align?: "left" | "right";
+	readonly inputs?: number;
+	readonly outputs?: number;
+	readonly configSchema?: Schema;
+	readonly credentialsSchema?: Schema;
+	readonly settingsSchema?: Schema;
+	readonly inputSchema?: Schema;
+	readonly outputsSchema?: TSchema | TSchema[] | Record<string, TSchema>;
+	readonly validateInput?: boolean;
+	readonly validateOutput?: boolean;
+	readonly name: string;
+	registered?(RED: RED): void | Promise<void>;
+	register(RED: RED): void | Promise<void>;
+	validateSettings(RED: RED): void;
+	new (RED: RED, node: NodeRedNode, config: NodeConfig<TConfig>, credentials: NodeCredentials<TCredentials>): T;
+}
+type NodeConfig<TConfig = any> = TConfig & Static<typeof NodeConfigSchema>;
+type NodeCredentials<TCredentials = any> = TCredentials;
+/** Public instance interface for all NRG nodes. Implemented by {@link Node}. */
+export interface INode<TConfig = any, TCredentials = any, TSettings = any> {
+	readonly config: NodeConfig<TConfig>;
+	readonly id: string;
+	readonly name: string | undefined;
+	readonly z: string | undefined;
+	readonly credentials: NodeCredentials<TCredentials> | undefined;
+	readonly settings: TSettings;
+	i18n(key: string, substitutions?: Record<string, string>): string;
+	setTimeout(fn: () => void, ms: number): NodeJS.Timeout;
+	setInterval(fn: () => void, ms: number): NodeJS.Timeout;
+	clearTimeout(timer: NodeJS.Timeout): void;
+	clearInterval(interval: NodeJS.Timeout): void;
+	on(event: string, callback: (...args: any[]) => void): void;
+	log(msg: any): void;
+	warn(message: string): void;
+	error(message: string, msg?: any): void;
+	created?(): void | Promise<void>;
+	closed?(removed?: boolean): void | Promise<void>;
+}
+declare const WIRE_HANDLERS: unique symbol;
+/**
+ * Abstract base class for all NRG nodes. Provides lifecycle hooks, config
+ * validation, logging, timers, i18n, and settings management.
+ *
+ * Extend {@link IONode} for message-processing nodes or {@link ConfigNode}
+ * for shared configuration nodes.
+ */
+declare abstract class Node$1<TConfig = any, TCredentials = any, TSettings = any> implements INode<TConfig, TCredentials, TSettings> {
+	#private;
+	static readonly type: string;
+	static readonly category: "config" | string;
+	static readonly configSchema?: Schema;
+	static readonly credentialsSchema?: Schema;
+	static readonly settingsSchema?: Schema;
+	static registered?(RED: RED): void | Promise<void>;
+	static validateSettings(RED: RED): void;
+	/**
+	 * Registers this node class with Node-RED. Handles instance creation,
+	 * event handler wiring, settings validation, and the user's registered() hook.
+	 */
+	static register(RED: RED): Promise<void>;
+	protected readonly RED: RED;
+	protected readonly node: NodeRedNode;
+	protected readonly context: ConfigNodeContext | IONodeContext;
+	readonly config: NodeConfig<TConfig>;
+	private readonly timers;
+	private readonly intervals;
+	constructor(RED: RED, node: NodeRedNode, config: NodeConfig<TConfig>, credentials: NodeCredentials<TCredentials>);
+	[WIRE_HANDLERS](nodeRedNode: NodeRedNode, createdPromise: Promise<void>): void;
+	i18n(key: string, substitutions?: Record<string, string>): string;
+	setTimeout(fn: () => void, ms: number): NodeJS.Timeout;
+	setInterval(fn: () => void, ms: number): NodeJS.Timeout;
+	clearTimeout(timer: NodeJS.Timeout): void;
+	clearInterval(interval: NodeJS.Timeout): void;
+	created?(): void | Promise<void>;
+	closed?(removed?: boolean): void | Promise<void>;
+	on(event: string, callback: (...args: any[]) => void): void;
+	log(msg: any): void;
+	warn(message: string): void;
+	error(message: string, msg?: any): void;
+	get id(): string;
+	get name(): string | undefined;
+	get z(): string | undefined;
+	get credentials(): NodeCredentials<TCredentials> | undefined;
+	get settings(): TSettings;
+}
+/**
+ * Controls how an outgoing message carries the incoming message's context:
+ * - `"carry"` (default): keep all incoming keys — including any upstream
+ *   `input` — but do not record this node, so context flows through without the
+ *   provenance chain growing. The safe default for loops and long chains.
+ * - `"trace"`: keep all incoming keys and also push the full input under
+ *   `input`, so the prior message — including any value the result overwrites —
+ *   stays recoverable (`msg.input.output`). The chain accumulates one frame per
+ *   node, a provenance trail visible in the debug panel; opt in for linear
+ *   flows that want full lineage.
+ * - `"reset"`: drop all inherited context; the outgoing message is only the
+ *   result at the return key.
+ */
+export type ContextMode = "carry" | "trace" | "reset";
+/**
+ * Base class for nodes that process messages. Provides input/output handling,
+ * schema validation, status updates, and emit port management.
+ *
+ * Every node has a return key (`"output"` by default): the value passed to
+ * `send()` is merged into the incoming message at that key
+ * (`{ ...msg, [returnKey]: result }`), so upstream properties propagate. By
+ * default the context is carried without growing; declaring
+ * `outputContextModes` in the `configSchema` lets the flow author pick `trace`
+ * (keep the full prior message under `input` as a recoverable provenance chain)
+ * or `reset` per port. The return key, output validation, and context mode all
+ * resolve per output port; declaring `outputReturnProperties` in the
+ * `configSchema` sets per-port default keys and lets the flow author pick a key
+ * other than `output` per port — it does not change that a return key always
+ * exists. `this.send(x)` always means "x is the result", never "x is the whole
+ * message".
+ *
+ * @example
+ * ```ts
+ * export default class MyNode extends IONode<Config, any, Input, Output> {
+ *   static readonly type = "my-node";
+ *   static readonly category = "function";
+ *   static readonly color = "#ffffff" as const;
+ *
+ *   async input(msg: Input) {
+ *     // sends { ...msg, output: <result> }
+ *     this.send(msg.output.toUpperCase());
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class IONode<TConfig = any, TCredentials = any, TInput = any, TOutput = any, TSettings = any> extends Node$1<TConfig, TCredentials, TSettings> implements IIONode<TConfig, TCredentials, TInput, TOutput, TSettings> {
+	#private;
+	static readonly align?: "left" | "right";
+	static readonly color: HexColor;
+	static readonly inputSchema?: Schema;
+	static readonly outputsSchema?: TSchema | TSchema[] | Record<string, TSchema>;
+	static readonly validateInput: boolean;
+	static readonly validateOutput: boolean;
+	static get inputs(): 0 | 1;
+	static get outputs(): number;
+	/**
+	 * The names of the base output ports when `outputsSchema` is a record of
+	 * named ports (`{ success, failure }`), in declaration order — otherwise
+	 * `undefined` (a single schema or a positional array). Resolved here, where
+	 * TypeBox's `Kind` symbol is intact, so the editor reads the names directly
+	 * instead of guessing them from a serialized (symbol-stripped) schema.
+	 */
+	static get outputPortNames(): string[] | undefined;
+	readonly config: IONodeConfig<TConfig>;
+	protected readonly context: IONodeContext;
+	constructor(RED: RED, node: NodeRedNode, config: IONodeConfig<TConfig>, credentials: IONodeCredentials<TCredentials>);
+	[WIRE_HANDLERS](nodeRedNode: NodeRedNode, createdPromise: Promise<void>): void;
+	input(msg: TInput): void | Promise<void>;
+	send(msg: TOutput): void;
+	get baseOutputs(): number;
+	get totalOutputs(): number;
+	/**
+	 * Send a message to a specific output port by index or name.
+	 * Custom named ports are resolved from `outputsSchema` when it is a record.
+	 * Numeric indices refer to the base output ports (0-based).
+	 *
+	 * Built-in ports (`"error"`, `"complete"`, `"status"`) are managed by the
+	 * framework and cannot be sent to directly. Use `this.status()` for status,
+	 * throw an error or call `this.error()` for the error port, and the complete
+	 * port is sent automatically on successful input processing.
+	 */
+	sendToPort<P extends (TOutput extends Record<string, Record<string, any>> ? keyof TOutput & string : never) | number>(port: P, msg: P extends keyof TOutput ? TOutput[P] : unknown): void;
+	status(status: IONodeStatus): void;
+	error(message: string, msg?: any): void;
+	updateWires(wires: string[][]): void;
+	receive(msg: TInput): void;
+	get x(): number;
+	get y(): number;
+	get g(): string | undefined;
+	get wires(): string[][];
+	get credentials(): IONodeCredentials<TCredentials> | undefined;
+}
+type IONodeContextScope = NodeContextScope;
+type BuiltinPortFlags = {
+	[K in (typeof BUILTIN_PORT_KEYS)[number]]?: boolean;
+};
+type IONodeConfig<TConfig = any> = NodeConfig<TConfig> & Static<typeof IONodeConfigSchema> & BuiltinPortFlags & {
+	validateInput?: boolean;
+	/** Per-port output-validation flags, keyed by base-output port index. */
+	validateOutputs?: Record<number, boolean>;
+	/** Per-port return properties, keyed by base-output port index. */
+	outputReturnProperties?: Record<number, string>;
+	/** Per-port context modes, keyed by base-output port index. */
+	outputContextModes?: Record<number, "carry" | "trace" | "reset">;
+};
+type IONodeCredentials<TCredentials = any> = NodeCredentials<TCredentials>;
+type IONodeStatus = {
+	fill?: "red" | "green" | "yellow" | "blue" | "grey" | "gray";
+	shape?: "ring" | "dot";
+	text?: string;
+} | string;
+type IONodeContext = {
+	(scope: IONodeContextScope, store?: string): NodeContextStore;
+	node: NodeContextStore;
+	flow: NodeContextStore;
+	global: NodeContextStore;
+};
+type HexColor = `#${string}`;
+type BoundIONode<TC extends TSchema | undefined, TCr extends TSchema | undefined, TS extends TSchema | undefined, TIn extends TSchema | undefined, TOut extends TSchema | readonly TSchema[] | Record<string, TSchema> | undefined> = IONode<InferOr<TC, any>, InferOr<TCr, any>, InferOr<TIn, any>, InferOutputs<TOut>, InferOr<TS, any>>;
+/** Public instance interface for IO nodes. Implemented by {@link IONode}. */
+export interface IIONode<TConfig = any, TCredentials = any, TInput = any, TOutput = any, TSettings = any> extends INode<TConfig, TCredentials, TSettings> {
+	readonly config: IONodeConfig<TConfig>;
+	readonly credentials: IONodeCredentials<TCredentials> | undefined;
+	readonly x: number;
+	readonly y: number;
+	readonly g: string | undefined;
+	readonly wires: string[][];
+	input(msg: TInput): void | Promise<void>;
+	send(msg: TOutput): void;
+	status(status: IONodeStatus): void;
+	updateWires(wires: string[][]): void;
+	receive(msg: TInput): void;
+	readonly baseOutputs: number;
+	readonly totalOutputs: number;
+	sendToPort<P extends (TOutput extends Record<string, Record<string, any>> ? keyof TOutput & string : never) | number>(port: P, msg: P extends keyof TOutput ? TOutput[P] : unknown): void;
+}
+interface IONodeDefinition<TConfigSchema extends TSchema | undefined = undefined, TCredsSchema extends TSchema | undefined = undefined, TSettingsSchema extends TSchema | undefined = undefined, TInputSchema extends TSchema | undefined = undefined, TOutputsSchema extends TSchema | readonly TSchema[] | Record<string, TSchema> | undefined = undefined> {
+	type: string;
+	category?: string;
+	color?: HexColor;
+	align?: "left" | "right";
+	configSchema?: TConfigSchema;
+	credentialsSchema?: TCredsSchema;
+	settingsSchema?: TSettingsSchema;
+	inputSchema?: TInputSchema;
+	outputsSchema?: TOutputsSchema;
+	validateInput?: boolean;
+	validateOutput?: boolean;
+	registered?(RED: RED): void | Promise<void>;
+	created?(this: BoundIONode<TConfigSchema, TCredsSchema, TSettingsSchema, TInputSchema, TOutputsSchema>): void | Promise<void>;
+	closed?(this: BoundIONode<TConfigSchema, TCredsSchema, TSettingsSchema, TInputSchema, TOutputsSchema>, removed?: boolean): void | Promise<void>;
+	input?(this: BoundIONode<TConfigSchema, TCredsSchema, TSettingsSchema, TInputSchema, TOutputsSchema>, msg: InferOr<TInputSchema, any>): void | Promise<void>;
+}
+/**
+ * Base class for configuration nodes that are shared across multiple nodes
+ * (e.g., server connections, credentials). Registered with `category: "config"`.
+ *
+ * @example
+ * ```ts
+ * export default class MyServer extends ConfigNode<Config> {
+ *   static readonly type = "my-server";
+ * }
+ * ```
+ */
+export declare abstract class ConfigNode<TConfig = any, TCredentials = any, TSettings = any> extends Node$1<TConfig, TCredentials, TSettings> implements IConfigNode<TConfig, TCredentials, TSettings> {
+	static readonly category: string;
+	readonly config: ConfigNodeConfig<TConfig>;
+	protected readonly context: ConfigNodeContext;
+	constructor(RED: RED, node: NodeRedNode, config: ConfigNodeConfig<TConfig>, credentials: ConfigNodeCredentials<TCredentials>);
+	get userIds(): string[];
+	get users(): INode[];
+	getUser<T extends INode = INode>(index: number): T | undefined;
+	get credentials(): ConfigNodeCredentials<TCredentials> | undefined;
+}
+type ConfigNodeContextScope = Exclude<NodeContextScope, "flow">;
+type ConfigNodeConfig<TConfig = any> = NodeConfig<TConfig> & Static<typeof ConfigNodeConfigSchema>;
+type ConfigNodeCredentials<TCredentials = any> = NodeCredentials<TCredentials>;
+type ConfigNodeContext = {
+	(scope: ConfigNodeContextScope, store?: string): NodeContextStore;
+	node: NodeContextStore;
+	global: NodeContextStore;
+};
+type BoundConfigNode<TC extends TSchema | undefined, TCr extends TSchema | undefined, TS extends TSchema | undefined> = ConfigNode<InferOr<TC, any>, InferOr<TCr, any>, InferOr<TS, any>>;
+/** Public instance interface for config nodes. Implemented by {@link ConfigNode}. */
+export interface IConfigNode<TConfig = any, TCredentials = any, TSettings = any> extends INode<TConfig, TCredentials, TSettings> {
+	readonly config: ConfigNodeConfig<TConfig>;
+	readonly credentials: ConfigNodeCredentials<TCredentials> | undefined;
+	readonly userIds: string[];
+	readonly users: INode[];
+	getUser<T extends INode = INode>(index: number): T | undefined;
+}
+interface ConfigNodeDefinition<TConfigSchema extends TSchema | undefined = undefined, TCredsSchema extends TSchema | undefined = undefined, TSettingsSchema extends TSchema | undefined = undefined> {
+	type: string;
+	configSchema?: TConfigSchema;
+	credentialsSchema?: TCredsSchema;
+	settingsSchema?: TSettingsSchema;
+	registered?(RED: RED): void | Promise<void>;
+	created?(this: BoundConfigNode<TConfigSchema, TCredsSchema, TSettingsSchema>): void | Promise<void>;
+	closed?(this: BoundConfigNode<TConfigSchema, TCredsSchema, TSettingsSchema>, removed?: boolean): void | Promise<void>;
+}
+/**
+ * Registers a custom node with Node-RED.
+ *
+ * @param RED - The Node-RED runtime API object
+ * @param NodeClass - A node class extending Node, IONode, or ConfigNode
+ * @throws If NodeClass does not extend Node
+ * @throws If NodeClass.type is not defined
+ */
+export declare function registerType(RED: RED, NodeClass: NodeConstructor): Promise<void>;
+type RegistrationFunction = ((RED: RED) => Promise<void>) & {
+	nodes: NodeConstructor[];
+};
+/**
+ * Registers multiple node classes with Node-RED.
+ *
+ * Returns a Node-RED package function that Node-RED calls with the RED
+ * runtime object when loading the package.
+ *
+ * @param nodes - Array of node classes to register
+ */
+export declare function registerTypes(nodes: NodeConstructor[]): RegistrationFunction;
+/**
+ * Creates an IO node class from a definition object. Provides automatic type
+ * inference from schemas, reducing boilerplate compared to the class-based API.
+ *
+ * @example
+ * ```ts
+ * export default defineIONode({
+ *   type: "my-node",
+ *   color: "#ffffff",
+ *   configSchema: ConfigsSchema,
+ *   inputSchema: InputSchema,
+ *   outputsSchema: OutputSchema,
+ *   async input(msg) {
+ *     this.send({ payload: msg.payload.toUpperCase() });
+ *   },
+ * });
+ * ```
+ */
+export declare function defineIONode<TConfigSchema extends TSchema | undefined = undefined, TCredsSchema extends TSchema | undefined = undefined, TSettingsSchema extends TSchema | undefined = undefined, TInputSchema extends TSchema | undefined = undefined, TOutputsSchema extends TSchema | readonly TSchema[] | Record<string, TSchema> | undefined = undefined>(def: IONodeDefinition<TConfigSchema, TCredsSchema, TSettingsSchema, TInputSchema, TOutputsSchema>): NodeConstructor<IIONode<InferOr<TConfigSchema, any>, InferOr<TCredsSchema, any>, InferOr<TInputSchema, any>, InferOutputs<TOutputsSchema>>>;
+/**
+ * Creates a config node class from a definition object.
+ *
+ * @example
+ * ```ts
+ * export default defineConfigNode({
+ *   type: "my-server",
+ *   configSchema: ConfigsSchema,
+ *   credentialsSchema: CredsSchema,
+ * });
+ * ```
+ */
+export declare function defineConfigNode<TConfigSchema extends TSchema | undefined = undefined, TCredsSchema extends TSchema | undefined = undefined, TSettingsSchema extends TSchema | undefined = undefined>(def: ConfigNodeDefinition<TConfigSchema, TCredsSchema, TSettingsSchema>): NodeConstructor<IConfigNode<InferOr<TConfigSchema, any>, InferOr<TCredsSchema, any>>>;
+/** Error class for NRG framework errors (validation failures, registration errors, etc.). */
+export declare class NrgError extends Error {
+	constructor(message: string);
+}
+/** Defines the set of nodes exported by a Node-RED package. */
+export interface ModuleDefinition {
+	nodes: NodeConstructor[];
+}
+/**
+ * Declares the nodes that make up a Node-RED module. The returned object
+ * is used as the default export of `src/server/index.ts`.
+ *
+ * @example
+ * ```ts
+ * export default defineModule({
+ *   nodes: [MyNode, MyConfigNode],
+ * });
+ * ```
+ */
+export declare function defineModule(definition: ModuleDefinition): ModuleDefinition;
+
+export {
+	Node$1 as Node,
+};
+
+export {};