guh - Developer documentation

JSON-RPC API

Description

The JSON RPC interface represents a TCP socket connection using plaintext string communication. Messages are exchanged using the JSON format. Please note that this is not a REST API as the transport channel is not based on HTTP. It is an internal RPC mechanism to allow communication between the guh Server and the main controller interface. This communication socket is not meant to be exported to the outside of the of the systen as it allows arbitrary commands to manipulate the system.

The JSON message protocol communicates by exchanging JSON Objects with the following properties:

The JSONRPC API is self documenting and can be introspected by calling "JSONRPC.Introspect".

Parameters are optional if the type is the type is prefixed with "o:" for optional.

Communicating with the server

The server listens by default on TCP port 2222 for incoming TCP connections. It will respond to incoming connections with a some information about the server. Telnet can be used to issue commands for testing.

An example how to communicate with the API using telnet on the same host where the guh server is running:

       $  telnet localhost 2222
       Trying 127.0.0.1...
       Connected to localhost.
       Escape character is '^]'.
       {
           "id": 0,
           "protocol version": 28,
           "server": "guh JSONRPC interface",
           "version": "0.6.0"
       }

Now the connection is established and waits for commands.

Classes

guhserver::ActionHandler

This subclass of JsonHandler processes the JSON requests for the Actions namespace

guhserver::CloudHandler

This subclass of JsonHandler processes the JSON requests for the Cloud namespace

guhserver::ConfigurationHandler

This subclass of JsonHandler processes the JSON requests for the Configuration namespace

guhserver::DeviceClassesResource

This subclass of RestResource processes the REST requests for the DeviceClasses namespace

guhserver::DeviceHandler

This subclass of JsonHandler processes the JSON requests for the Devices namespace of the JSON-RPC API

guhserver::DevicesResource

This subclass of RestResource processes the REST requests for the Devices namespace

guhserver::EventHandler

This subclass of JsonHandler processes the JSON requests for the Events namespace

guhserver::JsonHandler

This class represents an interface for developing a handler for the JSON-RPC API

guhserver::JsonReply

This class represents a reply for the JSON-RPC API request

guhserver::JsonTypes

This class represents the types for the JSON-RPC API

guhserver::LoggingHandler

This subclass of JsonHandler processes the JSON requests for the Logging namespace of the JSON-RPC API

guhserver::LogsResource

This subclass of RestResource processes the REST requests for the Logs namespace

guhserver::NetworkManagerHandler

This subclass of JsonHandler processes the JSON requests for the NetworkManager namespace of the JSON-RPC API

guhserver::PluginsResource

This subclass of RestResource processes the REST requests for the Plugins namespace

guhserver::RulesHandler

This subclass of JsonHandler processes the JSON requests for the Rules namespace of the JSON-RPC API

guhserver::RulesResource

This subclass of RestResource processes the REST requests for the Rules namespace

guhserver::StateHandler

This subclass of JsonHandler processes the JSON requests for the States namespace of the JSON-RPC API

guhserver::VendorsResource

This subclass of RestResource processes the REST requests for the Vendors namespace

Examples

Introspect API

Request

   {
       "id": 1,
       "method":"JSONRPC.Introspect"
   }

Response

   {
       "id": 1,
       "params": {
           "methods": {
               ...
               "Devices.GetSupportedDevices": {
                   "description": "Returns a list of supported Device classes.",
                   "params": {
                   },
                   "returns": {
                       "deviceClasses": [
                           "$ref:DeviceClass"
                       ]
                   }
               },
               ...
           },
           "types": {
               ...
               "DeviceClass": {
                   "actions": [
                       "$ref:ActionType"
                   ],
                   "id": "uuid",
                   "name": "string",
                   "params": [
                       "$ref:ParamType"
                   ],
                   "states": [
                       "$ref:StateType"
                   ],
                   "events": [
                       "$ref:EventType"
                   ]
               },
               ...
           }
       },
       "status": "success"
   }

Getting a list of supported devices

Request

   {
       "id":1,
       "method":"Devices.GetSupportedDevices"
   }

Response:

{
       "id": 1,
       "params": {
           "deviceClasses": [
               {
                   "actions": [
                   ],
                   "id": "{bd216356-f1ec-4324-9785-6982d2174e17}",
                   "name": "WiFi Device",
                   "params": [
                       {
                           "name": "mac",
                           "type": "string"
                       }
                   ],
                   "states": [
                       {
                           "id": "{cb43e1b5-4f61-4538-bfa2-c33055c542cf}",
                           "name": "inRange",
                           "type": "bool"
                       }
                   ],
                   "events": [
                       {
                           "id": "{7cae711a-a0af-41b4-b3bf-38d3e23b41ba}",
                           "name": "inRange",
                           "params": [
                               {
                                   "name": "inRange",
                                   "type": "bool"
                               }
                           ]
                       }
                   ]
               }
               ...
           ]
       }
       "status": "success"
   }

Newest JSON-RPC API

47
{
    "methods": {
        "Actions.ExecuteAction": {
            "description": "Execute a single action.",
            "params": {
                "actionTypeId": "Uuid",
                "deviceId": "Uuid",
                "o:params": [
                    "$ref:Param"
                ]
            },
            "returns": {
                "deviceError": "$ref:DeviceError"
            }
        },
        "Actions.GetActionType": {
            "description": "Get the ActionType for the given ActionTypeId",
            "params": {
                "actionTypeId": "Uuid"
            },
            "returns": {
                "deviceError": "$ref:DeviceError",
                "o:actionType": {
                    "id": "Uuid",
                    "index": "Int",
                    "name": "Uuid",
                    "paramTypes": [
                        "$ref:ParamType"
                    ]
                }
            }
        },
        "Cloud.Authenticate": {
            "description": "Connect and authenticate the cloud connection with the given username and password.",
            "params": {
                "password": "String",
                "username": "String"
            },
            "returns": {
                "cloudError": "$ref:CloudError"
            }
        },
        "Cloud.Enable": {
            "description": "Enable or disable the cloud connection.",
            "params": {
                "enable": "Bool"
            },
            "returns": {
                "cloudError": "$ref:CloudError"
            }
        },
        "Cloud.GetConnectionStatus": {
            "description": "Get the current status of the cloud connection.",
            "params": {
            },
            "returns": {
                "active": "Bool",
                "authenticated": "Bool",
                "connected": "Bool",
                "enabled": "Bool"
            }
        },
        "Configuration.GetAvailableLanguages": {
            "description": "Returns a list of locale codes available for the server. i.e. en_US, de_AT",
            "params": {
            },
            "returns": {
                "languages": [
                    "String"
                ]
            }
        },
        "Configuration.GetConfigurations": {
            "description": "Get all configuration parameters of the server.",
            "params": {
            },
            "returns": {
                "basicConfiguration": {
                    "language": "String",
                    "serverName": "String",
                    "serverTime": "Uint",
                    "serverUuid": "Uuid",
                    "timeZone": "String"
                },
                "sslConfiguration": {
                    "enabled": "Bool"
                },
                "tcpServerConfiguration": {
                    "host": "String",
                    "port": "Uint"
                },
                "webServerConfiguration": {
                    "host": "String",
                    "port": "Uint"
                },
                "webSocketServerConfiguration": {
                    "host": "String",
                    "port": "Uint"
                }
            }
        },
        "Configuration.GetTimeZones": {
            "description": "Get the list of available timezones.",
            "params": {
            },
            "returns": {
                "timeZones": [
                    "String"
                ]
            }
        },
        "Configuration.SetLanguage": {
            "description": "Sets the server language to the given language. See also: \"GetAvailableLanguages\"",
            "params": {
                "language": "String"
            },
            "returns": {
                "configurationError": "$ref:ConfigurationError"
            }
        },
        "Configuration.SetServerName": {
            "description": "Set the name of the server. Default is guhIO.",
            "params": {
                "serverName": "String"
            },
            "returns": {
                "configurationError": "$ref:ConfigurationError"
            }
        },
        "Configuration.SetTcpServerConfiguration": {
            "description": "Configure the TCP interface of the server. Note: if you are using the TCP server for this call you will loose the connection.",
            "params": {
                "host": "String",
                "port": "Uint"
            },
            "returns": {
                "configurationError": "$ref:ConfigurationError"
            }
        },
        "Configuration.SetTimeZone": {
            "description": "Set the time zone of the server. See also: \"GetTimeZones\"",
            "params": {
                "timeZone": "String"
            },
            "returns": {
                "configurationError": "$ref:ConfigurationError"
            }
        },
        "Configuration.SetWebServerConfiguration": {
            "description": "Configure the web server of the server.",
            "params": {
                "host": "String",
                "port": "Uint"
            },
            "returns": {
                "configurationError": "$ref:ConfigurationError"
            }
        },
        "Configuration.SetWebSocketServerConfiguration": {
            "description": "Configure the web socket interface of the server. Note: if you are using the web socket server for this call you will loose the connection.",
            "params": {
                "host": "String",
                "port": "Uint"
            },
            "returns": {
                "configurationError": "$ref:ConfigurationError"
            }
        },
        "Devices.AddConfiguredDevice": {
            "description": "Add a configured device with a setupMethod of SetupMethodJustAdd. For devices with a setupMethod different than SetupMethodJustAdd, use PairDevice. Use deviceDescriptorId or deviceParams, depending on the createMethod of the device class. CreateMethodJustAdd takes the parameters you want to have with that device. CreateMethodDiscovery requires the use of a deviceDescriptorId.",
            "params": {
                "deviceClassId": "Uuid",
                "name": "String",
                "o:deviceDescriptorId": "Uuid",
                "o:deviceParams": [
                    "$ref:Param"
                ]
            },
            "returns": {
                "deviceError": "$ref:DeviceError",
                "o:deviceId": "Uuid"
            }
        },
        "Devices.ConfirmPairing": {
            "description": "Confirm an ongoing pairing. In case of SetupMethodEnterPin also provide the pin in the params.",
            "params": {
                "o:secret": "String",
                "pairingTransactionId": "Uuid"
            },
            "returns": {
                "deviceError": "$ref:DeviceError",
                "o:deviceId": "Uuid"
            }
        },
        "Devices.EditDevice": {
            "description": "Edit the name of a device. This method does not change the configuration of the device.",
            "params": {
                "deviceId": "Uuid",
                "name": "String"
            },
            "returns": {
                "deviceError": "$ref:DeviceError"
            }
        },
        "Devices.GetActionTypes": {
            "description": "Get action types for a specified deviceClassId.",
            "params": {
                "deviceClassId": "Uuid"
            },
            "returns": {
                "actionTypes": [
                    "$ref:ActionType"
                ]
            }
        },
        "Devices.GetConfiguredDevices": {
            "description": "Returns a list of configured devices, optionally filtered by deviceId.",
            "params": {
                "o:deviceId": "Uuid"
            },
            "returns": {
                "devices": [
                    "$ref:Device"
                ]
            }
        },
        "Devices.GetDiscoveredDevices": {
            "description": "Performs a device discovery and returns the results. This function may take a while to return.",
            "params": {
                "deviceClassId": "Uuid",
                "o:discoveryParams": [
                    "$ref:Param"
                ]
            },
            "returns": {
                "deviceError": "$ref:DeviceError",
                "o:deviceDescriptors": [
                    "$ref:DeviceDescriptor"
                ]
            }
        },
        "Devices.GetEventTypes": {
            "description": "Get event types for a specified deviceClassId.",
            "params": {
                "deviceClassId": "Uuid"
            },
            "returns": {
                "eventTypes": [
                    "$ref:EventType"
                ]
            }
        },
        "Devices.GetPluginConfiguration": {
            "description": "Get a plugin's params.",
            "params": {
                "pluginId": "Uuid"
            },
            "returns": {
                "deviceError": "$ref:DeviceError",
                "o:configuration": [
                    "$ref:Param"
                ]
            }
        },
        "Devices.GetPlugins": {
            "description": "Returns a list of loaded plugins.",
            "params": {
            },
            "returns": {
                "plugins": [
                    "$ref:Plugin"
                ]
            }
        },
        "Devices.GetStateTypes": {
            "description": "Get state types for a specified deviceClassId.",
            "params": {
                "deviceClassId": "Uuid"
            },
            "returns": {
                "stateTypes": [
                    "$ref:StateType"
                ]
            }
        },
        "Devices.GetStateValue": {
            "description": "Get the value of the given device and the given stateType",
            "params": {
                "deviceId": "Uuid",
                "stateTypeId": "Uuid"
            },
            "returns": {
                "deviceError": "$ref:DeviceError",
                "o:value": "Variant"
            }
        },
        "Devices.GetStateValues": {
            "description": "Get all the state values of the given device.",
            "params": {
                "deviceId": "Uuid"
            },
            "returns": {
                "deviceError": "$ref:DeviceError",
                "o:values": [
                    {
                        "stateTypeId": "Uuid",
                        "value": "Variant"
                    }
                ]
            }
        },
        "Devices.GetSupportedDevices": {
            "description": "Returns a list of supported Device classes, optionally filtered by vendorId.",
            "params": {
                "o:vendorId": "Uuid"
            },
            "returns": {
                "deviceClasses": [
                    "$ref:DeviceClass"
                ]
            }
        },
        "Devices.GetSupportedVendors": {
            "description": "Returns a list of supported Vendors.",
            "params": {
            },
            "returns": {
                "vendors": [
                    "$ref:Vendor"
                ]
            }
        },
        "Devices.PairDevice": {
            "description": "Pair a device. Use this for DeviceClasses with a setupMethod different than SetupMethodJustAdd. Use deviceDescriptorId or deviceParams, depending on the createMethod of the device class. CreateMethodJustAdd takes the parameters you want to have with that device. CreateMethodDiscovery requires the use of a deviceDescriptorId. If success is true, the return values will contain a pairingTransactionId, a displayMessage and the setupMethod. Depending on the setupMethod you should either proceed with AddConfiguredDevice or PairDevice.",
            "params": {
                "deviceClassId": "Uuid",
                "name": "String",
                "o:deviceDescriptorId": "Uuid",
                "o:deviceParams": [
                    "$ref:Param"
                ]
            },
            "returns": {
                "deviceError": "$ref:DeviceError",
                "o:displayMessage": "String",
                "o:pairingTransactionId": "Uuid",
                "o:setupMethod": "$ref:SetupMethod"
            }
        },
        "Devices.ReconfigureDevice": {
            "description": "Edit the parameter configuration of the device. The device params will be set to the passed parameters and the setup device will be called. If the device is discoverable, you can perform a GetDiscoveredDevices before calling this method and pass the new DeviceDescriptor (rediscover). Only writable parameters can be changed. By default, every Param is writable.",
            "params": {
                "deviceId": "Uuid",
                "o:deviceDescriptorId": "Uuid",
                "o:deviceParams": [
                    "$ref:Param"
                ]
            },
            "returns": {
                "deviceError": "$ref:DeviceError"
            }
        },
        "Devices.RemoveConfiguredDevice": {
            "description": "Remove a device from the system.",
            "params": {
                "deviceId": "Uuid",
                "o:removePolicy": "$ref:RemovePolicy",
                "o:removePolicyList": [
                    {
                        "policy": "$ref:RemovePolicy",
                        "ruleId": "Uuid"
                    }
                ]
            },
            "returns": {
                "deviceError": "$ref:DeviceError",
                "o:ruleIds": [
                    "Uuid"
                ]
            }
        },
        "Devices.SetPluginConfiguration": {
            "description": "Set a plugin's params.",
            "params": {
                "configuration": [
                    "$ref:Param"
                ],
                "pluginId": "Uuid"
            },
            "returns": {
                "deviceError": "$ref:DeviceError"
            }
        },
        "Events.GetEventType": {
            "description": "Get the EventType for the given eventTypeId.",
            "params": {
                "eventTypeId": "Uuid"
            },
            "returns": {
                "deviceError": "$ref:DeviceError",
                "o:eventType": "$ref:EventType"
            }
        },
        "JSONRPC.Introspect": {
            "description": "Introspect this API.",
            "params": {
            },
            "returns": {
                "methods": "Object",
                "types": "Object"
            }
        },
        "JSONRPC.SetNotificationStatus": {
            "description": "Enable/Disable notifications for this connections.",
            "params": {
                "enabled": "Bool"
            },
            "returns": {
                "enabled": "Bool"
            }
        },
        "JSONRPC.Version": {
            "description": "Version of this Guh/JSONRPC interface.",
            "params": {
            },
            "returns": {
                "protocol version": "String",
                "version": "String"
            }
        },
        "Logging.GetLogEntries": {
            "description": "Get the LogEntries matching the given filter. Each list element of a given filter will be connected with OR to each other. Each of the given filters will be connected with AND to each other.",
            "params": {
                "o:deviceIds": [
                    "Uuid"
                ],
                "o:eventTypes": [
                    "$ref:LoggingEventType"
                ],
                "o:loggingLevels": [
                    "$ref:LoggingLevel"
                ],
                "o:loggingSources": [
                    "$ref:LoggingSource"
                ],
                "o:timeFilters": [
                    {
                        "o:endDate": "Int",
                        "o:startDate": "Int"
                    }
                ],
                "o:typeIds": [
                    "Uuid"
                ],
                "o:values": [
                    "Variant"
                ]
            },
            "returns": {
                "loggingError": "$ref:LoggingError",
                "o:logEntries": [
                    "$ref:LogEntry"
                ]
            }
        },
        "NetworkManager.ConnectWifiNetwork": {
            "description": "Connect to the wifi network with the given ssid and password.",
            "params": {
                "interface": "String",
                "o:password": "String",
                "ssid": "String"
            },
            "returns": {
                "networkManagerError": "$ref:NetworkManagerError"
            }
        },
        "NetworkManager.DisconnectInterface": {
            "description": "Disconnect the given network interface. The interface will remain disconnected until the user connect it again.",
            "params": {
                "interface": "String"
            },
            "returns": {
                "networkManagerError": "$ref:NetworkManagerError"
            }
        },
        "NetworkManager.EnableNetworking": {
            "description": "Enable or disable networking in the NetworkManager.",
            "params": {
                "enable": "Bool"
            },
            "returns": {
                "networkManagerError": "$ref:NetworkManagerError"
            }
        },
        "NetworkManager.EnableWirelessNetworking": {
            "description": "Enable or disable wireless networking in the NetworkManager.",
            "params": {
                "enable": "Bool"
            },
            "returns": {
                "networkManagerError": "$ref:NetworkManagerError"
            }
        },
        "NetworkManager.GetNetworkDevices": {
            "description": "Get the list of current network devices.",
            "params": {
            },
            "returns": {
                "networkManagerError": "$ref:NetworkManagerError",
                "wiredNetworkDevices": [
                    "$ref:WiredNetworkDevice"
                ],
                "wirelessNetworkDevices": [
                    "$ref:WirelessNetworkDevice"
                ]
            }
        },
        "NetworkManager.GetNetworkStatus": {
            "description": "Get the current network manager status.",
            "params": {
            },
            "returns": {
                "networkManagerError": "$ref:NetworkManagerError",
                "o:status": {
                    "networkingEnabled": "Bool",
                    "state": "$ref:NetworkManagerState",
                    "wirelessNetworkingEnabled": "Bool"
                }
            }
        },
        "NetworkManager.GetWirelessAccessPoints": {
            "description": "Get the current list of wireless network access points for the given interface. The interface has to be a WirelessNetworkDevice.",
            "params": {
                "interface": "String"
            },
            "returns": {
                "networkManagerError": "$ref:NetworkManagerError",
                "o:wirelessAccessPoints": [
                    "$ref:WirelessAccessPoint"
                ]
            }
        },
        "NetworkManager.ScanWifiNetworks": {
            "description": "Start a wifi scan for searching new networks.",
            "params": {
                "interface": "String"
            },
            "returns": {
                "networkManagerError": "$ref:NetworkManagerError"
            }
        },
        "Rules.AddRule": {
            "description": "Add a rule. You can describe rules by one or many EventDesciptors and a StateEvaluator. Note that only one of either eventDescriptor or eventDescriptorList may be passed at a time. A rule can be created but left disabled, meaning it won't actually be executed until set to enabled. If not given, enabled defaults to true.",
            "params": {
                "actions": [
                    "$ref:RuleAction"
                ],
                "name": "String",
                "o:enabled": "Bool",
                "o:eventDescriptors": [
                    "$ref:EventDescriptor"
                ],
                "o:executable": "Bool",
                "o:exitActions": [
                    "$ref:RuleAction"
                ],
                "o:stateEvaluator": "$ref:StateEvaluator",
                "o:timeDescriptor": "$ref:TimeDescriptor"
            },
            "returns": {
                "o:ruleId": "Uuid",
                "ruleError": "$ref:RuleError"
            }
        },
        "Rules.DisableRule": {
            "description": "Disable a rule. The rule won't be triggered by it's events or state changes while it is disabled. If successfull, the notification \"Rule.RuleConfigurationChanged\" will be emitted.",
            "params": {
                "ruleId": "Uuid"
            },
            "returns": {
                "ruleError": "$ref:RuleError"
            }
        },
        "Rules.EditRule": {
            "description": "Edit the parameters of a rule. The configuration of the rule with the given ruleId will be replaced with the new given configuration. In ordert to enable or disable a Rule, please use the methods \"Rules.EnableRule\" and \"Rules.DisableRule\". If successfull, the notification \"Rule.RuleConfigurationChanged\" will be emitted.",
            "params": {
                "actions": [
                    "$ref:RuleAction"
                ],
                "name": "String",
                "o:enabled": "Bool",
                "o:eventDescriptors": [
                    "$ref:EventDescriptor"
                ],
                "o:executable": "Bool",
                "o:exitActions": [
                    "$ref:RuleAction"
                ],
                "o:stateEvaluator": "$ref:StateEvaluator",
                "o:timeDescriptor": "$ref:TimeDescriptor",
                "ruleId": "Uuid"
            },
            "returns": {
                "o:rule": "$ref:Rule",
                "ruleError": "$ref:RuleError"
            }
        },
        "Rules.EnableRule": {
            "description": "Enabled a rule that has previously been disabled.If successfull, the notification \"Rule.RuleConfigurationChanged\" will be emitted.",
            "params": {
                "ruleId": "Uuid"
            },
            "returns": {
                "ruleError": "$ref:RuleError"
            }
        },
        "Rules.ExecuteActions": {
            "description": "Execute the action list of the rule with the given ruleId.",
            "params": {
                "ruleId": "Uuid"
            },
            "returns": {
                "ruleError": "$ref:RuleError"
            }
        },
        "Rules.ExecuteExitActions": {
            "description": "Execute the exit action list of the rule with the given ruleId.",
            "params": {
                "ruleId": "Uuid"
            },
            "returns": {
                "ruleError": "$ref:RuleError"
            }
        },
        "Rules.FindRules": {
            "description": "Find a list of rules containing any of the given parameters.",
            "params": {
                "deviceId": "Uuid"
            },
            "returns": {
                "ruleIds": [
                    "Uuid"
                ]
            }
        },
        "Rules.GetRuleDetails": {
            "description": "Get details for the rule identified by ruleId",
            "params": {
                "ruleId": "Uuid"
            },
            "returns": {
                "o:rule": "$ref:Rule",
                "ruleError": "$ref:RuleError"
            }
        },
        "Rules.GetRules": {
            "description": "Get the descriptions of all configured rules. If you need more information about a specific rule use the method Rules.GetRuleDetails.",
            "params": {
            },
            "returns": {
                "ruleDescriptions": [
                    "$ref:RuleDescription"
                ]
            }
        },
        "Rules.RemoveRule": {
            "description": "Remove a rule",
            "params": {
                "ruleId": "Uuid"
            },
            "returns": {
                "ruleError": "$ref:RuleError"
            }
        },
        "States.GetStateType": {
            "description": "Get the StateType for the given stateTypeId.",
            "params": {
                "stateTypeId": "Uuid"
            },
            "returns": {
                "deviceError": "$ref:DeviceError",
                "o:stateType": "$ref:StateType"
            }
        }
    },
    "notifications": {
        "Cloud.ConnectionStatusChanged": {
            "description": "Emitted whenever the status of the cloud connection changed. The cloud connection is active if a cloud client is talking with the server.",
            "params": {
                "active": "Bool",
                "authenticated": "Bool",
                "connected": "Bool",
                "enabled": "Bool"
            }
        },
        "Configuration.BasicConfigurationChanged": {
            "description": "Emitted whenever the basic configuration of this server changes.",
            "params": {
                "serverName": "String",
                "serverTime": "Uint",
                "serverUuid": "Uuid",
                "timeZone": "String"
            }
        },
        "Configuration.LanguageChanged": {
            "description": "Emitted whenever the language of the server changed. The Plugins, Vendors and DeviceClasses have to be reloaded to get the translated data.",
            "params": {
                "language": "String"
            }
        },
        "Configuration.TcpServerConfigurationChanged": {
            "description": "Emitted whenever the TCP server configuration changes.",
            "params": {
                "host": "String",
                "port": "Uint"
            }
        },
        "Configuration.WebServerConfigurationChanged": {
            "description": "Emitted whenever the web server configuration changes.",
            "params": {
                "host": "String",
                "port": "Uint"
            }
        },
        "Configuration.WebSocketServerConfigurationChanged": {
            "description": "Emitted whenever the web socket server configuration changes.",
            "params": {
                "host": "String",
                "port": "Uint"
            }
        },
        "Devices.DeviceAdded": {
            "description": "Emitted whenever a Device was added.",
            "params": {
                "device": "$ref:Device"
            }
        },
        "Devices.DeviceChanged": {
            "description": "Emitted whenever the params or name of a Device changed (by EditDevice or ReconfigureDevice).",
            "params": {
                "device": "$ref:Device"
            }
        },
        "Devices.DeviceRemoved": {
            "description": "Emitted whenever a Device was removed.",
            "params": {
                "deviceId": "Uuid"
            }
        },
        "Devices.StateChanged": {
            "description": "Emitted whenever a State of a device changes.",
            "params": {
                "deviceId": "Uuid",
                "stateTypeId": "Uuid",
                "value": "Variant"
            }
        },
        "Events.EventTriggered": {
            "description": "Emitted whenever an Event is triggered.",
            "params": {
                "event": "$ref:Event"
            }
        },
        "Logging.LogDatabaseUpdated": {
            "description": "Emitted whenever the database was updated. The database will be updated when a log entry was deleted. A log entry will be deleted when the corresponding device or a rule will be removed, or when the oldest entry of the database was deleted to keep to database in the size limits.",
            "params": {
            }
        },
        "Logging.LogEntryAdded": {
            "description": "Emitted whenever an entry is appended to the logging system. ",
            "params": {
                "logEntry": "$ref:LogEntry"
            }
        },
        "NetworkManager.NetworkStatusChanged": {
            "description": "Emitted whenever a status of a NetworkManager changes.",
            "params": {
                "status": {
                    "networkingEnabled": "Bool",
                    "state": "$ref:NetworkManagerState",
                    "wirelessNetworkingEnabled": "Bool"
                }
            }
        },
        "NetworkManager.WiredNetworkDeviceAdded": {
            "description": "Emitted whenever a new WiredNetworkDevice was added.",
            "params": {
                "wiredNetworkDevice": "$ref:WiredNetworkDevice"
            }
        },
        "NetworkManager.WiredNetworkDeviceChanged": {
            "description": "Emitted whenever the given WiredNetworkDevice has changed.",
            "params": {
                "wiredNetworkDevice": "$ref:WiredNetworkDevice"
            }
        },
        "NetworkManager.WiredNetworkDeviceRemoved": {
            "description": "Emitted whenever a WiredNetworkDevice was removed.",
            "params": {
                "interface": "String"
            }
        },
        "NetworkManager.WirelessNetworkDeviceAdded": {
            "description": "Emitted whenever a new WirelessNetworkDevice was added.",
            "params": {
                "wirelessNetworkDevice": "$ref:WirelessNetworkDevice"
            }
        },
        "NetworkManager.WirelessNetworkDeviceChanged": {
            "description": "Emitted whenever the given WirelessNetworkDevice has changed.",
            "params": {
                "wirelessNetworkDevice": "$ref:WirelessNetworkDevice"
            }
        },
        "NetworkManager.WirelessNetworkDeviceRemoved": {
            "description": "Emitted whenever a WirelessNetworkDevice was removed.",
            "params": {
                "interface": "String"
            }
        },
        "Rules.RuleActiveChanged": {
            "description": "Emitted whenever the active state of a Rule changed.",
            "params": {
                "active": "Bool",
                "ruleId": "Uuid"
            }
        },
        "Rules.RuleAdded": {
            "description": "Emitted whenever a Rule was added.",
            "params": {
                "rule": "$ref:Rule"
            }
        },
        "Rules.RuleConfigurationChanged": {
            "description": "Emitted whenever the configuration of a Rule changed.",
            "params": {
                "rule": "$ref:Rule"
            }
        },
        "Rules.RuleRemoved": {
            "description": "Emitted whenever a Rule was removed.",
            "params": {
                "ruleId": "Uuid"
            }
        }
    },
    "types": {
        "Action": {
            "actionTypeId": "Uuid",
            "deviceId": "Uuid",
            "o:params": [
                "$ref:Param"
            ]
        },
        "ActionType": {
            "id": "Uuid",
            "index": "Int",
            "name": "Uuid",
            "paramTypes": [
                "$ref:ParamType"
            ]
        },
        "BasicTag": [
            "BasicTagService",
            "BasicTagDevice",
            "BasicTagSensor",
            "BasicTagActuator",
            "BasicTagLighting",
            "BasicTagEnergy",
            "BasicTagMultimedia",
            "BasicTagWeather",
            "BasicTagGateway",
            "BasicTagHeating",
            "BasicTagCooling",
            "BasicTagNotification",
            "BasicTagSecurity",
            "BasicTagTime",
            "BasicTagShading",
            "BasicTagAppliance",
            "BasicTagCamera",
            "BasicTagLock"
        ],
        "BasicType": [
            "Uuid",
            "String",
            "Int",
            "Uint",
            "Double",
            "Bool",
            "Variant",
            "Color",
            "Time",
            "Object"
        ],
        "CalendarItem": {
            "duration": "Uint",
            "o:datetime": "Uint",
            "o:repeating": "$ref:RepeatingOption",
            "o:startTime": "Time"
        },
        "CloudError": [
            "CloudErrorNoError",
            "CloudErrorAuthenticationFailed",
            "CloudErrorCloudConnectionDisabled",
            "CloudErrorIdentityServerNotReachable",
            "CloudErrorProxyServerNotReachable",
            "CloudErrorLoginCredentialsMissing"
        ],
        "ConfigurationError": [
            "ConfigurationErrorNoError",
            "ConfigurationErrorInvalidTimeZone",
            "ConfigurationErrorInvalidStationName",
            "ConfigurationErrorInvalidPort",
            "ConfigurationErrorInvalidHostAddress",
            "ConfigurationErrorBluetoothHardwareNotAvailable",
            "ConfigurationErrorInvalidCertificate"
        ],
        "CreateMethod": [
            "CreateMethodUser",
            "CreateMethodAuto",
            "CreateMethodDiscovery"
        ],
        "Device": {
            "deviceClassId": "Uuid",
            "id": "Uuid",
            "name": "String",
            "o:parentId": "Uuid",
            "params": [
                "$ref:Param"
            ],
            "setupComplete": "Bool",
            "states": [
                {
                    "stateTypeId": "Uuid",
                    "value": "Variant"
                }
            ]
        },
        "DeviceClass": {
            "actionTypes": [
                "$ref:ActionType"
            ],
            "basicTags": [
                "$ref:BasicTag"
            ],
            "createMethods": [
                "$ref:CreateMethod"
            ],
            "deviceIcon": "$ref:DeviceIcon",
            "discoveryParamTypes": [
                "$ref:ParamType"
            ],
            "eventTypes": [
                "$ref:EventType"
            ],
            "id": "Uuid",
            "name": "String",
            "o:criticalStateTypeId": "Uuid",
            "o:primaryActionTypeId": "Uuid",
            "o:primaryStateTypeId": "Uuid",
            "paramTypes": [
                "$ref:ParamType"
            ],
            "pluginId": "Uuid",
            "setupMethod": "$ref:SetupMethod",
            "stateTypes": [
                "$ref:StateType"
            ],
            "vendorId": "Uuid"
        },
        "DeviceDescriptor": {
            "description": "String",
            "id": "Uuid",
            "title": "String"
        },
        "DeviceError": [
            "DeviceErrorNoError",
            "DeviceErrorPluginNotFound",
            "DeviceErrorVendorNotFound",
            "DeviceErrorDeviceNotFound",
            "DeviceErrorDeviceClassNotFound",
            "DeviceErrorActionTypeNotFound",
            "DeviceErrorStateTypeNotFound",
            "DeviceErrorEventTypeNotFound",
            "DeviceErrorDeviceDescriptorNotFound",
            "DeviceErrorMissingParameter",
            "DeviceErrorInvalidParameter",
            "DeviceErrorSetupFailed",
            "DeviceErrorDuplicateUuid",
            "DeviceErrorCreationMethodNotSupported",
            "DeviceErrorSetupMethodNotSupported",
            "DeviceErrorHardwareNotAvailable",
            "DeviceErrorHardwareFailure",
            "DeviceErrorAuthentificationFailure",
            "DeviceErrorAsync",
            "DeviceErrorDeviceInUse",
            "DeviceErrorDeviceInRule",
            "DeviceErrorDeviceIsChild",
            "DeviceErrorPairingTransactionIdNotFound",
            "DeviceErrorParameterNotWritable"
        ],
        "DeviceIcon": [
            "DeviceIconNone",
            "DeviceIconBed",
            "DeviceIconBlinds",
            "DeviceIconCeilingLamp",
            "DeviceIconCouch",
            "DeviceIconDeskLamp",
            "DeviceIconDesk",
            "DeviceIconHifi",
            "DeviceIconPower",
            "DeviceIconEnergy",
            "DeviceIconRadio",
            "DeviceIconSmartPhone",
            "DeviceIconSocket",
            "DeviceIconStandardLamp",
            "DeviceIconSun",
            "DeviceIconTablet",
            "DeviceIconThermometer",
            "DeviceIconTune",
            "DeviceIconTv",
            "DeviceIconBattery",
            "DeviceIconDishwasher",
            "DeviceIconWashingMachine",
            "DeviceIconLaundryDryer",
            "DeviceIconIrHeater",
            "DeviceIconRadiator",
            "DeviceIconSwitch",
            "DeviceIconMotionDetectors",
            "DeviceIconWeather",
            "DeviceIconTime",
            "DeviceIconLightBulb",
            "DeviceIconGateway",
            "DeviceIconMail",
            "DeviceIconNetwork",
            "DeviceIconCloud",
            "DeviceIconGarage",
            "DeviceIconRollerShutter"
        ],
        "Event": {
            "deviceId": "Uuid",
            "eventTypeId": "Uuid",
            "o:params": [
                "$ref:Param"
            ]
        },
        "EventDescriptor": {
            "deviceId": "Uuid",
            "eventTypeId": "Uuid",
            "o:paramDescriptors": [
                "$ref:ParamDescriptor"
            ]
        },
        "EventType": {
            "id": "Uuid",
            "index": "Int",
            "name": "String",
            "o:graphRelevant": "Bool",
            "o:ruleRelevant": "Bool",
            "paramTypes": [
                "$ref:ParamType"
            ]
        },
        "InputType": [
            "InputTypeNone",
            "InputTypeTextLine",
            "InputTypeTextArea",
            "InputTypePassword",
            "InputTypeSearch",
            "InputTypeMail",
            "InputTypeIPv4Address",
            "InputTypeIPv6Address",
            "InputTypeUrl",
            "InputTypeMacAddress"
        ],
        "LogEntry": {
            "loggingLevel": "$ref:LoggingLevel",
            "o:active": "Bool",
            "o:deviceId": "Uuid",
            "o:errorCode": "String",
            "o:eventType": "$ref:LoggingEventType",
            "o:typeId": "Uuid",
            "o:value": "String",
            "source": "$ref:LoggingSource",
            "timestamp": "Int"
        },
        "LoggingError": [
            "LoggingErrorNoError",
            "LoggingErrorLogEntryNotFound",
            "LoggingErrorInvalidFilterParameter"
        ],
        "LoggingEventType": [
            "LoggingEventTypeTrigger",
            "LoggingEventTypeActiveChange",
            "LoggingEventTypeEnabledChange",
            "LoggingEventTypeActionsExecuted",
            "LoggingEventTypeExitActionsExecuted"
        ],
        "LoggingLevel": [
            "LoggingLevelInfo",
            "LoggingLevelAlert"
        ],
        "LoggingSource": [
            "LoggingSourceSystem",
            "LoggingSourceEvents",
            "LoggingSourceActions",
            "LoggingSourceStates",
            "LoggingSourceRules"
        ],
        "NetworkDeviceState": [
            "NetworkDeviceStateUnknown",
            "NetworkDeviceStateUnmanaged",
            "NetworkDeviceStateUnavailable",
            "NetworkDeviceStateDisconnected",
            "NetworkDeviceStatePrepare",
            "NetworkDeviceStateConfig",
            "NetworkDeviceStateNeedAuth",
            "NetworkDeviceStateIpConfig",
            "NetworkDeviceStateIpCheck",
            "NetworkDeviceStateSecondaries",
            "NetworkDeviceStateActivated",
            "NetworkDeviceStateDeactivating",
            "NetworkDeviceStateFailed"
        ],
        "NetworkManagerError": [
            "NetworkManagerErrorNoError",
            "NetworkManagerErrorUnknownError",
            "NetworkManagerErrorWirelessNotAvailable",
            "NetworkManagerErrorAccessPointNotFound",
            "NetworkManagerErrorNetworkInterfaceNotFound",
            "NetworkManagerErrorInvalidNetworkDeviceType",
            "NetworkManagerErrorWirelessNetworkingDisabled",
            "NetworkManagerErrorWirelessConnectionFailed",
            "NetworkManagerErrorNetworkingDisabled",
            "NetworkManagerErrorNetworkManagerNotAvailable"
        ],
        "NetworkManagerState": [
            "NetworkManagerStateUnknown",
            "NetworkManagerStateAsleep",
            "NetworkManagerStateDisconnected",
            "NetworkManagerStateDisconnecting",
            "NetworkManagerStateConnecting",
            "NetworkManagerStateConnectedLocal",
            "NetworkManagerStateConnectedSite",
            "NetworkManagerStateConnectedGlobal"
        ],
        "Param": {
            "paramTypeId": "Uuid",
            "value": "$ref:BasicType"
        },
        "ParamDescriptor": {
            "operator": "$ref:ValueOperator",
            "paramTypeId": "Uuid",
            "value": "$ref:BasicType"
        },
        "ParamType": {
            "id": "Uuid",
            "index": "Int",
            "name": "String",
            "o:allowedValues": [
                "Variant"
            ],
            "o:defaultValue": "Variant",
            "o:inputType": "$ref:InputType",
            "o:maxValue": "Variant",
            "o:minValue": "Variant",
            "o:readOnly": "Bool",
            "o:unit": "$ref:Unit",
            "type": "$ref:BasicType"
        },
        "Plugin": {
            "id": "Uuid",
            "name": "String",
            "paramTypes": [
                "$ref:ParamType"
            ]
        },
        "RemovePolicy": [
            "RemovePolicyCascade",
            "RemovePolicyUpdate"
        ],
        "RepeatingMode": [
            "RepeatingModeNone",
            "RepeatingModeHourly",
            "RepeatingModeDaily",
            "RepeatingModeWeekly",
            "RepeatingModeMonthly",
            "RepeatingModeYearly"
        ],
        "RepeatingOption": {
            "mode": "$ref:RepeatingMode",
            "o:monthDays": [
                "Int"
            ],
            "o:weekDays": [
                "Int"
            ]
        },
        "Rule": {
            "actions": [
                "$ref:RuleAction"
            ],
            "active": "Bool",
            "enabled": "Bool",
            "eventDescriptors": [
                "$ref:EventDescriptor"
            ],
            "executable": "Bool",
            "exitActions": [
                "$ref:RuleAction"
            ],
            "id": "Uuid",
            "name": "String",
            "stateEvaluator": "$ref:StateEvaluator",
            "timeDescriptor": "$ref:TimeDescriptor"
        },
        "RuleAction": {
            "actionTypeId": "Uuid",
            "deviceId": "Uuid",
            "o:ruleActionParams": [
                "$ref:RuleActionParam"
            ]
        },
        "RuleActionParam": {
            "o:eventParamTypeId": "Uuid",
            "o:eventTypeId": "Uuid",
            "o:value": "$ref:BasicType",
            "paramTypeId": "Uuid"
        },
        "RuleDescription": {
            "active": "Bool",
            "enabled": "Bool",
            "executable": "Bool",
            "id": "Uuid",
            "name": "String"
        },
        "RuleError": [
            "RuleErrorNoError",
            "RuleErrorInvalidRuleId",
            "RuleErrorRuleNotFound",
            "RuleErrorDeviceNotFound",
            "RuleErrorEventTypeNotFound",
            "RuleErrorStateTypeNotFound",
            "RuleErrorActionTypeNotFound",
            "RuleErrorInvalidParameter",
            "RuleErrorInvalidRuleFormat",
            "RuleErrorMissingParameter",
            "RuleErrorInvalidRuleActionParameter",
            "RuleErrorInvalidStateEvaluatorValue",
            "RuleErrorTypesNotMatching",
            "RuleErrorNotExecutable",
            "RuleErrorInvalidTimeDescriptor",
            "RuleErrorInvalidRepeatingOption",
            "RuleErrorInvalidCalendarItem",
            "RuleErrorInvalidTimeEventItem",
            "RuleErrorContainsEventBasesAction",
            "RuleErrorNoExitActions"
        ],
        "SetupMethod": [
            "SetupMethodJustAdd",
            "SetupMethodDisplayPin",
            "SetupMethodEnterPin",
            "SetupMethodPushButton"
        ],
        "State": {
            "deviceId": "Uuid",
            "stateTypeId": "Uuid",
            "value": "Variant"
        },
        "StateDescriptor": {
            "deviceId": "Uuid",
            "operator": "$ref:ValueOperator",
            "stateTypeId": "Uuid",
            "value": "Variant"
        },
        "StateEvaluator": {
            "o:childEvaluators": [
                "$ref:StateEvaluator"
            ],
            "o:operator": "$ref:StateOperator",
            "o:stateDescriptor": "$ref:StateDescriptor"
        },
        "StateOperator": [
            "StateOperatorAnd",
            "StateOperatorOr"
        ],
        "StateType": {
            "defaultValue": "Variant",
            "id": "Uuid",
            "index": "Int",
            "name": "String",
            "o:graphRelevant": "Bool",
            "o:maxValue": "Variant",
            "o:minValue": "Variant",
            "o:possibleValues": [
                "Variant"
            ],
            "o:ruleRelevant": "Bool",
            "o:unit": "$ref:Unit",
            "type": "$ref:BasicType"
        },
        "TimeDescriptor": {
            "o:calendarItems": [
                "$ref:CalendarItem"
            ],
            "o:timeEventItems": [
                "$ref:TimeEventItem"
            ]
        },
        "TimeEventItem": {
            "o:datetime": "Uint",
            "o:repeating": "$ref:RepeatingOption",
            "o:time": "Time"
        },
        "Unit": [
            "UnitNone",
            "UnitSeconds",
            "UnitMinutes",
            "UnitHours",
            "UnitUnixTime",
            "UnitMeterPerSecond",
            "UnitKiloMeterPerHour",
            "UnitDegree",
            "UnitRadiant",
            "UnitDegreeCelsius",
            "UnitDegreeKelvin",
            "UnitMired",
            "UnitMilliBar",
            "UnitBar",
            "UnitPascal",
            "UnitHectoPascal",
            "UnitAtmosphere",
            "UnitLumen",
            "UnitLux",
            "UnitCandela",
            "UnitMilliMeter",
            "UnitCentiMeter",
            "UnitMeter",
            "UnitKiloMeter",
            "UnitGram",
            "UnitKiloGram",
            "UnitDezibel",
            "UnitBpm",
            "UnitKiloByte",
            "UnitMegaByte",
            "UnitGigaByte",
            "UnitTeraByte",
            "UnitMilliWatt",
            "UnitWatt",
            "UnitKiloWatt",
            "UnitKiloWattHour",
            "UnitEuroPerMegaWattHour",
            "UnitEuroCentPerKiloWattHour",
            "UnitPercentage",
            "UnitPartsPerMillion",
            "UnitEuro",
            "UnitDollar",
            "UnitHerz",
            "UnitAmpere",
            "UnitMilliAmpere",
            "UnitVolt",
            "UnitMilliVolt",
            "UnitVoltAmpere",
            "UnitVoltAmpereReactive",
            "UnitAmpereHour"
        ],
        "ValueOperator": [
            "ValueOperatorEquals",
            "ValueOperatorNotEquals",
            "ValueOperatorLess",
            "ValueOperatorGreater",
            "ValueOperatorLessOrEqual",
            "ValueOperatorGreaterOrEqual"
        ],
        "Vendor": {
            "id": "Uuid",
            "name": "String"
        },
        "WiredNetworkDevice": {
            "bitRate": "String",
            "interface": "String",
            "macAddress": "String",
            "pluggedIn": "Bool",
            "state": "$ref:NetworkDeviceState"
        },
        "WirelessAccessPoint": {
            "frequency": "Double",
            "macAddress": "String",
            "protected": "Bool",
            "signalStrength": "Int",
            "ssid": "String"
        },
        "WirelessNetworkDevice": {
            "bitRate": "String",
            "interface": "String",
            "macAddress": "String",
            "o:currentAccessPoint": "$ref:WirelessAccessPoint",
            "state": "$ref:NetworkDeviceState"
        }
    }
}