• Version 1.3.4
  • Published
  • 11.3 kB
  • 6 dependencies
  • MIT license


npm i @types/node-red
yarn add @types/node-red
pnpm add @types/node-red


TypeScript definitions for node-red



variable nodeRed

const nodeRed: nodeRed.NodeRedApp;


    interface EditorNodeCredential

    interface EditorNodeCredential extends editorClient.NodeCredential {}

      interface EditorNodeDef

      interface EditorNodeDef<
      TProps extends EditorNodeProperties = EditorNodeProperties,
      TCreds = undefined,
      TInstProps extends TProps = TProps
      > extends editorClient.NodeDef<TProps, TCreds, TInstProps> {}
      • Node Definition Read more: https://nodered.org/docs/creating-nodes/node-html#node-definition

      interface EditorNodeProperties

      interface EditorNodeProperties extends editorClient.NodeProperties {}
      • Node properties Read more: https://nodered.org/docs/creating-nodes/properties

      interface EditorNodePropertyDef

      interface EditorNodePropertyDef<
      TInstProps extends EditorNodeProperties = EditorNodeProperties
      > extends editorClient.NodePropertyDef<TVal, TInstProps> {}
      • Property definition Read more: https://nodered.org/docs/creating-nodes/properties#property-definitions

      interface EditorRED

      interface EditorRED extends editorClient.RED {}
      • Type def for the global RED in the node .html files. Should be used to access RED.nodes.registerType function registering a node with the editor.


        declare const RED: EditorRED;
        >("my-node", {

      interface EditorWidgetEditableList

      interface EditorWidgetEditableList extends editorClient.WidgetEditableList {}

        interface EditorWidgetEditableListOptions

        interface EditorWidgetEditableListOptions<T>
        extends editorClient.WidgetEditableListOptions<T> {}
        • WIDGETS

        interface EditorWidgetTypedInput

        interface EditorWidgetTypedInput extends editorClient.WidgetTypedInput {}

          interface EditorWidgetTypedInputOptions

          interface EditorWidgetTypedInputOptions
          extends editorClient.WidgetTypedInputOptions {}

            interface EditorWidgetTypedInputTypeDefinition

            interface EditorWidgetTypedInputTypeDefinition
            extends editorClient.WidgetTypedInputTypeDefinition {}

              interface Node

              interface Node<TCreds extends {} = {}> extends registry.Node<TCreds> {}

                interface NodeAPI

                interface NodeAPI<TSets extends NodeAPISettingsWithData = NodeAPISettingsWithData>
                extends registry.NodeAPI<TSets> {}

                  interface NodeAPISettingsWithData

                  interface NodeAPISettingsWithData extends registry.NodeAPISettingsWithData {}

                    interface NodeConstructor

                    interface NodeConstructor<
                    TNode extends Node<TCreds>,
                    TNodeDef extends NodeDef,
                    TCreds extends {}
                    > extends registry.NodeConstructor<TNode, TNodeDef, TCreds> {}

                      interface NodeContext

                      interface NodeContext extends registry.NodeContext {}

                        interface NodeContextData

                        interface NodeContextData extends registry.NodeContextData {}

                          interface NodeCredential

                          interface NodeCredential extends registry.NodeCredential {}

                            interface NodeDef

                            interface NodeDef extends registry.NodeDef {}

                              interface NodeInitializer

                              interface NodeInitializer<
                              TSets extends NodeAPISettingsWithData = NodeAPISettingsWithData
                              > extends registry.NodeInitializer<TSets> {}
                              • Type def for the functions that should be exported by the node .js files.

                              interface NodeMessage

                              interface NodeMessage extends registry.NodeMessage {}

                                interface NodeMessageInFlow

                                interface NodeMessageInFlow extends registry.NodeMessageInFlow {}

                                  interface NodeMessageParts

                                  interface NodeMessageParts extends registry.NodeMessageParts {}

                                    interface NodeRedApp

                                    interface NodeRedApp {}

                                      property auth

                                      auth: editorAPI.Auth;
                                      • The editor authentication api.

                                      property events

                                      events: EventEmitter;
                                      • Runtime events emitter

                                      property hooks

                                      hooks: util.Hooks;
                                      • Runtime hooks engine

                                      property httpAdmin

                                      readonly httpAdmin: Express;
                                      • The express application for the Editor Admin API

                                      property httpNode

                                      readonly httpNode: Express;
                                      • The express application for HTTP Nodes

                                      property init

                                      init: (httpServer: HttpServer, userSettings: runtime.LocalSettings) => void;
                                      • Initialise the Node-RED application.

                                        Parameter httpServer

                                        the HTTP server object to use

                                        Parameter userSettings

                                        an object containing the runtime settings

                                      property log

                                      log: util.Log;
                                      • Logging utilities

                                      property nodes

                                      readonly nodes: runtime.InternalNodesModule;
                                      • This provides access to the internal nodes module of the runtime. The details of this API remain undocumented as they should not be used directly.

                                        Most administrative actions should be performed use the runtime api under @node-red/runtime.

                                      property plugins

                                      readonly plugins: runtime.InternalPluginsModule;
                                      • This provides access to the internal plugins module of the runtime. The details of this API remain undocumented as they should not be used directly.

                                        Most administrative actions should be performed use the runtime api under @node-red/runtime.

                                      property runtime

                                      runtime: runtime.RuntimeModule;
                                      • The runtime api

                                      property server

                                      readonly server: HttpServer;
                                      • The HTTP Server used by the runtime

                                      property settings

                                      readonly settings: runtime.PersistentSettings;
                                      • This provides access to the internal settings module of the runtime.

                                      property start

                                      start: () => Promise<void>;
                                      • Start the Node-RED application.

                                      property stop

                                      stop: () => Promise<void>;
                                      • Stop the Node-RED application.

                                      property util

                                      util: util.Util;
                                      • General utilities

                                      property version

                                      readonly version: string;
                                      • Get the version of the runtime

                                      interface NodeSetting

                                      interface NodeSetting<T> extends registry.NodeSetting<T> {}

                                        interface NodeStatus

                                        interface NodeStatus extends registry.NodeStatus {}

                                          Type Aliases

                                          type EditorNodeCredentials

                                          type EditorNodeCredentials<T> = editorClient.NodeCredentials<T>;

                                            type EditorNodeInstance

                                            type EditorNodeInstance<TProps extends EditorNodeProperties = EditorNodeProperties> =

                                              type EditorNodePropertiesDef

                                              type EditorNodePropertiesDef<
                                              TProps extends EditorNodeProperties,
                                              TInstProps extends TProps = TProps
                                              > = editorClient.NodePropertiesDef<TProps, TInstProps>;
                                              • Properties definitions (defaults object) Read more: https://nodered.org/docs/creating-nodes/properties

                                              type EditorWidgetTypedInputType

                                              type EditorWidgetTypedInputType = editorClient.WidgetTypedInputType;

                                                type NodeCredentials

                                                type NodeCredentials<TCreds> = registry.NodeCredentials<TCreds>;

                                                  type NodeSettings

                                                  type NodeSettings<TSets> = registry.NodeSettings<TSets>;

                                                    type NodeStatusFill

                                                    type NodeStatusFill = registry.NodeStatusFill;

                                                      type NodeStatusShape

                                                      type NodeStatusShape = registry.NodeStatusShape;

                                                        Package Files (1)

                                                        Dependencies (6)

                                                        Dev Dependencies (0)

                                                        No dev dependencies.

                                                        Peer Dependencies (0)

                                                        No peer dependencies.


                                                        To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                        You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/node-red.

                                                        • Markdown
                                                        • HTML
                                                          <a href="https://www.jsdocs.io/package/@types/node-red"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>