@bonsae/nrg-runtime 0.22.0

package/types/client.d.ts

@@ -0,0 +1,266 @@
+// 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/internal/client/components.d.ts

@@ -0,0 +1,9 @@
+import type { DefineComponent } from "vue";
+export declare const NodeRedInput: DefineComponent<{}, {}, any>;
+export declare const NodeRedTypedInput: DefineComponent<{}, {}, any>;
+export declare const NodeRedConfigInput: DefineComponent<{}, {}, any>;
+export declare const NodeRedSelectInput: DefineComponent<{}, {}, any>;
+export declare const NodeRedEditorInput: DefineComponent<{}, {}, any>;
+export declare const NodeRedInputLabel: DefineComponent<{}, {}, any>;
+export declare const NodeRedToggle: DefineComponent<{}, {}, any>;
+export declare const NodeRedJsonSchemaForm: DefineComponent<{}, {}, any>;

package/types/internal/client/index.d.ts

@@ -0,0 +1,9 @@
+import type { TSchema } from "@sinclair/typebox";
+export declare function useFormNode<TConfig extends TSchema = TSchema, TCredentials extends TSchema = TSchema>(): {
+  node: Record<string, any>;
+  schema: Record<string, any>;
+  errors: Record<string, string>;
+};
+export declare function validateForm(schema: unknown, value: unknown): Record<string, string>;
+export declare function composeValidationSchema(...schemas: unknown[]): unknown;
+export type JsonSchemaObject = Record<string, any>;

package/types/internal/server/index.d.ts

@@ -0,0 +1,422 @@
+// Generated by dts-bundle-generator v9.5.1
+
+import { SchemaOptions, Static, TObject, TOptional, TProperties, TSchema, TString } from '@sinclair/typebox';
+import { EventEmitter } from 'events';
+import { Express as Express$1 } from 'express';
+import { Http2ServerRequest } from 'http2';
+
+/** Symbol for the internal wireHandlers template method. Not exported from public API.
+ * Uses Symbol.for() so the symbol is shared across separate bundles (server + test). */
+export declare const WIRE_HANDLERS: unique symbol;
+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;
+}
+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>;
+}>;
+type Schema<T extends TProperties = TProperties> = TObject<T>;
+export 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>;
+}
+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;
+}
+export 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;
+}
+export 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;
+}
+/**
+ * Wrap Node-RED's callback-style context store as the promise-based
+ * {@link NodeContextStore} nrg nodes use (`this.context.node/flow/global`).
+ *
+ * `increment`/`update` are atomic: they delegate to the underlying store's
+ * native op when it provides one (the only way to be atomic across instances —
+ * e.g. a DynamoDB conditional write / Redis), and otherwise serialize per key
+ * in-process (atomic within this instance, best-effort across HA replicas).
+ */
+export declare function setupContext(context: NodeRedContextStore, store?: string): NodeContextStore;
+export declare function initValidator(RED: RED): void;
+
+export {};