JSON-RPC API

\chapterCommunicating with the server

The JSON RPC interface represents a 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 nymea Server and the main controller interface. This communication socket is not meant to be exported to the outside of the of the system as it allows arbitrary commands to manipulate the system.

Message format

Request message

The request message is a JSON objects and contains following properties:

{
    "id": integer,
    "method": "Namespace.Method",
    "o:token": "string",
    "o:params" { }
}

Note: M = mandatory, O = optional

idMintegerThe id should be a unique identifier for the message. Any server response will contain the same id allowing to match responses to requests/commands.
methodMstringThe method field holds the method to be executed. Methods are grouped into namespaces. The method string consists of two parts, the namespace and the method name, separated by a dot (i.e: JSONRPC.Introspect).

See also: Methods

tokenOstringThe token property contains the authentication token received from the authentication process. This parameter is optional and only required if the authentication is enabled.

See also: Authentication

paramsOobjectThe params contains any JSON object. This parameter is optional and differs according to the requested method.

Response message

The response message is a JSON objects and contains following properties:

{
    "id": integer,
    "status": "string",
    "o:params" { },
    "o:error": "string"
}

Note: M = mandatory, O = optional

idMintegerThe id matching to the requested id.
statusMstringThe status property can be:
  • "success"
  • "error"
  • "unauthorized"
paramsOobjectThe params contains any JSON object. This parameter is optional and differs according to the requested method.
errorOstringThe error property will only be added if a protocol related error happen and the "status" property is error or unauthorized. The value contains a description of the API error.

If there is an error on the JSON RPC transport layer, the server will respond with an error message. This error is related to the protocol layer of the communication.

If the server needs a very long time to process a request or there happens any error, the JSON RPC server will timeout a request. The timeout interval is 30 seconds.

Handshake

Once connected to the socket, the first thing you have to do is to initiate the Handshake. This is done by calling the JSONRPC.Hello message. The server will reply with with information about the running instance. Use this handshake message to configure basic parameters for the connection, for instance the locale.

Here is an example of a handshake request:

{
    "id": 0,
    "method": "JSONRPC.Hello",
    "params": {
        "locale": "de_DE"
    }
}

And the according reply of the server.

{
    "id": 0,
    "status": "success",
    "params": {
        "name": "My nymea",
        "protocol version": "2.0",
        "authenticationRequired": false,
        "initialSetupRequired": false,
        "pushButtonAuthAvailable": false,
        "server": "nymea",
        "locale": "de_DE",
        "uuid": "{42842b0f-a7bb-4a94-b624-a55f31c5603e}",
        "version": "0.12.1"
    }
}
idintegerIt will be the same ID as the request
statusstringWhether or not the JSONRPC request was successful.
paramsjson objectThe response parameters
namestringThis field represents the name of the server you are connected to. This name is user defined an can be changed using Configuration.SetServerName.
protocol versionstringThe field represents the API version of the server you are connected to (Major.Minor). This should be used for API compatibility checks. A major version bump indicates a breaking API change, a minor version bump is means something was added and does not break the API compatibility.
authenticationRequiredboolIf this property is true, a client must perform the authentication process before being able to interact with the API.

See also: Authentication

initialSetupRequiredboolThis property indicates if the server was set up already. A server is set up if a user has been created. If the authenticationRequired property is false, this field can be ignored.
pushButtonAuthAvailableboolThis property indicates if the server has a running push-button agent and therefore the push-button authentication available. If the authenticationRequired property is false, this field can be ignored.

See also: Push-button authentication

serverstringThis property holds the name of the server. This name can not be changed.
localestringThis property holds the locale for this connection. It should generally match with the locale you requested in the Hello message. If you did not pass any locale request, the server default will be used which can be configured using Settings.SetLanguage. However, Configuration.SetLanguage is deprecated as of 2.0. Clients should request a per-connection locale.
uuidstringThis property holds the UUID of the server and can be used as a unique identifier.
versionstringThis property holds the build version of the server.

Note that the client can re-initiate the handshake at any point. This might be useful to check whether server properties have changed (e.g. the initialSetup has been performed by another client in the meantime, or to change connection parameters for the connection, for example the locale.

Sending a request

Once the handshake has been performed, normal communication with the server can begin. In order to send a request to the server, the client has to send an API message according to the format descibed here.

The JSON content should always be sent as a compack JSON Object (without spaces, tabs and new line characters within the object {...}). At the end of this compact JSON string the payload must be terminated with the \n character. This makes sure, that the parsing of the message is easier and a single message can be split in multiple cunckes during the transport. The client parsing should work the same way.

Note that the Handshake already follows this model, that is, the Handshake is like any other regular method.

In order to demonstrate this with an example, the JSONRPC.Hello request could look like this:

Note: Send following content as compact JSON ending with \n:

{"id":122,"method":"JSONRPC.KeepAlive", "params": {"sessionId": "my-session"}}

The id can be a random integer, just make sure there are no other commands with the same id around. The easiest way to do that is incrementing the id with each new request. The JSONRPC.KeepAlive method requires one additional parameter, a sessionId.

The server will return a response for this request. The response will have the same id as your request. The json content of the response will also be a compact JSON string ending with the \n character.

{"id":122,"params":{"success": true, "sessionId": "my-session"}}

Getting notifications

In order to enable/disable notifications on your socket, the methods JSONRPC.SetNotificationStatus can be used. By default, the notifications on a new created connection are disabled. If you get disconnected, the notification must be enabled again for the next connection.

Once the notifications are enabled, the server will start notifying you with all different notifications described in section Notifications.

A notification message has following properties:

{
    "id": integer,
    "notification": "Namespace.Notification",
    "o: params": { }

}

Note: M = mandatory, O = optional

idMintegerThe id should be a unique identifier for the message. The notification id will be increased for each notification sent to your connection.
notificationMstringThe notification field holds the name of this notification. Notifications are grouped into namespaces like the methods. The notification string consists of two parts, the namespace and the notification name, separated by a dot. This property can be used to check if a received message is a response to a request or a notification.

See also: Methods

paramsOobjectThe params contains any JSON object. This parameter is optional and differs according to each notification.

\chapterAuthentication

The API has an authentication mechanism, which makes sure that no unauthorized network participent can perform actions or get information from the server. For using the authentication the authenticationRequired property in the handshake must be true.

There are some methods, which can be called even without authentication:

Note: If you are using an authenticated connection, please make sure you are using an encrypted transport layer, otherwise you have a serious security problem.

In order to verify each request sent to the server, the client has to send a token in each JSON RPC message (see Request message - token). There are two different types of authentication in order to get a token:

If both authentication methods are available, the Push-button authentication should be preferred.

Username and password

If the handshake property initialSetupRequired is true, there is no user configured yet. This means the you have to create a user before you are abele to authenticate.

Create a user

Currently the nymead server is a single user only system and allows only one user. Creating a new user is only allowed if the handshake property initialSetupRequired is true.

Call the JSONRPC.CreateUser method with the username (should be an email address) and password. The returned UserError informs you about the result. If the user was created successfully, you can use those credentials for authenticate your connection.

Authenticate

If you have already created the system user using JSONRPC.CreateUser, you can now call the method JSONRPC.Authenticate using the same user name, password and the client device name. This name should give information about the device using this token i.e. "Phone xy" or "Cool client application xy". This information helps you later to associate the token with this client device.

If the user name and password are ok, the server will return the token which can be used for further communication. This token can be stored together with the server uuid ont he client side. The client does not need to reauthenticate until:

  • The token gets rejected from the server
  • The token gets deleted from on the client
  • The token gets removed from the server

Push-button authentication

If the push button authentication is enabled, a client can only get a token if he has physical access to the device where the server is running. For this authentication method the handshake property initialSetupRequired can be ignored.

The Push-button authentication method works like this:

  • The client initialtes the push authentication using JSONRPC.RequestPushButtonAuth containing the device name for token association.
  • The server returns the status and a transactionId. Now is the time to instruct the user how the button should be pressed.
  • Once the user has pressed the button, the JSONRPC.PushButtonAuthFinished notification will be emitted. If there was no error and the authentication went fine, this notification contains the same transactionId for request matching and the token which can be used from now on.

A possible case where the Push-button authentication could fail is a situation where 2 different clients request for a Push-button authentication. In that case the authentication will faile since it you cannot steal the button event from an other request.

Removing a token

If a device gets lost or you want to force a reauthentication to a client, a token can be removed from the system. This can be done using the JSONRPC.RemoveToken method. Once a token is removed, it can never be used again and the client owning that token can not perform any actions any more on this server until he re-authenticates again.

\chapterAPI

This section contains the complete API description of the current server. The JSON-RPC API is self documenting and can be introspected by calling JSONRPC.Introspect.

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

Specific API Types are prefixed with $ref: and are documented in the Types section.

/*! In the following section you can find a detaild description of the current API version 3.1.

Types

Action

{
    "actionTypeId": "Uuid",
    "deviceId": "Uuid",
    "o:params": [
        "$ref:Param"
    ]
}

See also: Param

ActionType

{
    "displayName": "String",
    "id": "Uuid",
    "index": "Int",
    "name": "String",
    "paramTypes": [
        "$ref:ParamType"
    ]
}

See also: ParamType

BasicType

[
    "Uuid",
    "String",
    "StringList",
    "Int",
    "Uint",
    "Double",
    "Bool",
    "Variant",
    "Color",
    "Time",
    "Object"
]

BrowserIcon

[
    "BrowserIconNone",
    "BrowserIconFolder",
    "BrowserIconFile",
    "BrowserIconMusic",
    "BrowserIconVideo",
    "BrowserIconPictures",
    "BrowserIconApplication",
    "BrowserIconDocument",
    "BrowserIconPackage",
    "BrowserIconFavorites"
]

BrowserItem

{
    "actionTypeIds": [
        "Uuid"
    ],
    "browsable": "Bool",
    "description": "String",
    "disabled": "Bool",
    "displayName": "String",
    "executable": "Bool",
    "icon": "$ref:BrowserIcon",
    "id": "String",
    "o:mediaIcon": "$ref:MediaBrowserIcon",
    "thumbnail": "String"
}

See also: MediaBrowserIcon, BrowserIcon

CalendarItem

{
    "duration": "Uint",
    "o:datetime": "Uint",
    "o:repeating": "$ref:RepeatingOption",
    "o:startTime": "Time"
}

See also: RepeatingOption

CloudConnectionState

[
    "CloudConnectionStateDisabled",
    "CloudConnectionStateUnconfigured",
    "CloudConnectionStateConnecting",
    "CloudConnectionStateConnected"
]

ConfigurationError

[
    "ConfigurationErrorNoError",
    "ConfigurationErrorInvalidTimeZone",
    "ConfigurationErrorInvalidStationName",
    "ConfigurationErrorInvalidId",
    "ConfigurationErrorInvalidPort",
    "ConfigurationErrorInvalidHostAddress",
    "ConfigurationErrorBluetoothHardwareNotAvailable",
    "ConfigurationErrorInvalidCertificate"
]

CreateMethod

[
    "CreateMethodUser",
    "CreateMethodAuto",
    "CreateMethodDiscovery"
]

Device

{
    "deviceClassId": "Uuid",
    "id": "Uuid",
    "name": "String",
    "o:parentId": "Uuid",
    "params": [
        "$ref:Param"
    ],
    "settings": [
        "$ref:Param"
    ],
    "setupComplete": "Bool",
    "states": [
        {
            "stateTypeId": "Uuid",
            "value": "Variant"
        }
    ]
}

See also: Param, Param

DeviceClass

{
    "actionTypes": [
        "$ref:ActionType"
    ],
    "browsable": "Bool",
    "browserItemActionTypes": [
        "$ref:ActionType"
    ],
    "createMethods": [
        "$ref:CreateMethod"
    ],
    "discoveryParamTypes": [
        "$ref:ParamType"
    ],
    "displayName": "String",
    "eventTypes": [
        "$ref:EventType"
    ],
    "id": "Uuid",
    "interfaces": [
        "String"
    ],
    "name": "String",
    "paramTypes": [
        "$ref:ParamType"
    ],
    "pluginId": "Uuid",
    "settingsTypes": [
        "$ref:ParamType"
    ],
    "setupMethod": "$ref:SetupMethod",
    "stateTypes": [
        "$ref:StateType"
    ],
    "vendorId": "Uuid"
}

See also: ParamType, ActionType, CreateMethod, ParamType, ActionType, SetupMethod, StateType, EventType, ParamType

DeviceDescriptor

{
    "description": "String",
    "deviceId": "Uuid",
    "deviceParams": [
        "$ref:Param"
    ],
    "id": "Uuid",
    "title": "String"
}

See also: Param

DeviceError

[
    "DeviceErrorNoError",
    "DeviceErrorPluginNotFound",
    "DeviceErrorVendorNotFound",
    "DeviceErrorDeviceNotFound",
    "DeviceErrorDeviceClassNotFound",
    "DeviceErrorActionTypeNotFound",
    "DeviceErrorStateTypeNotFound",
    "DeviceErrorEventTypeNotFound",
    "DeviceErrorDeviceDescriptorNotFound",
    "DeviceErrorMissingParameter",
    "DeviceErrorInvalidParameter",
    "DeviceErrorSetupFailed",
    "DeviceErrorDuplicateUuid",
    "DeviceErrorCreationMethodNotSupported",
    "DeviceErrorSetupMethodNotSupported",
    "DeviceErrorHardwareNotAvailable",
    "DeviceErrorHardwareFailure",
    "DeviceErrorAuthenticationFailure",
    "DeviceErrorDeviceInUse",
    "DeviceErrorDeviceInRule",
    "DeviceErrorDeviceIsChild",
    "DeviceErrorPairingTransactionIdNotFound",
    "DeviceErrorParameterNotWritable",
    "DeviceErrorItemNotFound",
    "DeviceErrorItemNotExecutable",
    "DeviceErrorUnsupportedFeature",
    "DeviceErrorTimeout"
]

Event

{
    "deviceId": "Uuid",
    "eventTypeId": "Uuid",
    "o:params": [
        "$ref:Param"
    ]
}

See also: Param

EventDescriptor

{
    "o:deviceId": "Uuid",
    "o:eventTypeId": "Uuid",
    "o:interface": "String",
    "o:interfaceEvent": "String",
    "o:paramDescriptors": [
        "$ref:ParamDescriptor"
    ]
}

See also: ParamDescriptor

EventType

{
    "displayName": "String",
    "id": "Uuid",
    "index": "Int",
    "name": "String",
    "paramTypes": [
        "$ref:ParamType"
    ]
}

See also: 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:itemId": "String",
    "o:typeId": "Uuid",
    "o:value": "String",
    "source": "$ref:LoggingSource",
    "timestamp": "Int"
}

See also: LoggingSource, LoggingEventType, LoggingLevel

LoggingError

[
    "LoggingErrorNoError",
    "LoggingErrorLogEntryNotFound",
    "LoggingErrorInvalidFilterParameter"
]

LoggingEventType

[
    "LoggingEventTypeTrigger",
    "LoggingEventTypeActiveChange",
    "LoggingEventTypeEnabledChange",
    "LoggingEventTypeActionsExecuted",
    "LoggingEventTypeExitActionsExecuted"
]

LoggingLevel

[
    "LoggingLevelInfo",
    "LoggingLevelAlert"
]

LoggingSource

[
    "LoggingSourceSystem",
    "LoggingSourceEvents",
    "LoggingSourceActions",
    "LoggingSourceStates",
    "LoggingSourceRules",
    "LoggingSourceBrowserActions"
]

MediaBrowserIcon

[
    "MediaBrowserIconNone",
    "MediaBrowserIconPlaylist",
    "MediaBrowserIconRecentlyPlayed",
    "MediaBrowserIconLibrary",
    "MediaBrowserIconMusicLibrary",
    "MediaBrowserIconVideoLibrary",
    "MediaBrowserIconPictureLibrary",
    "MediaBrowserIconDisk",
    "MediaBrowserIconUSB",
    "MediaBrowserIconNetwork",
    "MediaBrowserIconAux",
    "MediaBrowserIconSpotify",
    "MediaBrowserIconAmazon",
    "MediaBrowserIconTuneIn",
    "MediaBrowserIconSiriusXM",
    "MediaBrowserIconVTuner",
    "MediaBrowserIconTidal",
    "MediaBrowserIconAirable",
    "MediaBrowserIconDeezer",
    "MediaBrowserIconNapster",
    "MediaBrowserIconSoundCloud"
]

MqttPolicy

{
    "allowedPublishTopicFilters": "StringList",
    "allowedSubscribeTopicFilters": "StringList",
    "clientId": "String",
    "password": "String",
    "username": "String"
}

Namespace

[
    "Actions",
    "Configuration",
    "Devices",
    "Events",
    "JSONRPC",
    "Logging",
    "NetworkManager",
    "Rules",
    "States",
    "System",
    "Tags"
]

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"
]

Package

{
    "canRemove": "Bool",
    "candidateVersion": "String",
    "changelog": "String",
    "displayName": "String",
    "id": "String",
    "installedVersion": "String",
    "rollbackAvailable": "Bool",
    "summary": "String",
    "updateAvailable": "Bool"
}

Param

{
    "paramTypeId": "Uuid",
    "value": "$ref:BasicType"
}

See also: BasicType

ParamDescriptor

{
    "o:paramName": "Uuid",
    "o:paramTypeId": "Uuid",
    "operator": "$ref:ValueOperator",
    "value": "$ref:BasicType"
}

See also: BasicType, ValueOperator

ParamType

{
    "displayName": "String",
    "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"
}

See also: Unit, InputType, BasicType

Plugin

{
    "displayName": "String",
    "id": "Uuid",
    "name": "String",
    "paramTypes": [
        "$ref:ParamType"
    ]
}

See also: ParamType

RemovePolicy

[
    "RemovePolicyCascade",
    "RemovePolicyUpdate"
]

RepeatingMode

[
    "RepeatingModeNone",
    "RepeatingModeHourly",
    "RepeatingModeDaily",
    "RepeatingModeWeekly",
    "RepeatingModeMonthly",
    "RepeatingModeYearly"
]

RepeatingOption

{
    "mode": "$ref:RepeatingMode",
    "o:monthDays": [
        "Int"
    ],
    "o:weekDays": [
        "Int"
    ]
}

See also: RepeatingMode

Repository

{
    "displayName": "String",
    "enabled": "Bool",
    "id": "String"
}

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"
}

See also: TimeDescriptor, RuleAction, StateEvaluator, RuleAction, EventDescriptor

RuleAction

{
    "o:actionTypeId": "Uuid",
    "o:browserItemId": "String",
    "o:deviceId": "Uuid",
    "o:interface": "String",
    "o:interfaceAction": "String",
    "o:ruleActionParams": [
        "$ref:RuleActionParam"
    ]
}

See also: RuleActionParam

RuleActionParam

{
    "o:eventParamTypeId": "Uuid",
    "o:eventTypeId": "Uuid",
    "o:paramName": "String",
    "o:paramTypeId": "Uuid",
    "o:stateDeviceId": "Uuid",
    "o:stateTypeId": "Uuid",
    "o:value": "$ref:BasicType"
}

See also: BasicType

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",
    "RuleErrorInterfaceNotFound"
]

ServerConfiguration

{
    "address": "String",
    "authenticationEnabled": "Bool",
    "id": "String",
    "port": "Uint",
    "sslEnabled": "Bool"
}

SetupMethod

[
    "SetupMethodJustAdd",
    "SetupMethodDisplayPin",
    "SetupMethodEnterPin",
    "SetupMethodPushButton",
    "SetupMethodUserAndPassword",
    "SetupMethodOAuth"
]

State

{
    "deviceId": "Uuid",
    "stateTypeId": "Uuid",
    "value": "Variant"
}

StateDescriptor

{
    "o:deviceId": "Uuid",
    "o:interface": "String",
    "o:interfaceState": "String",
    "o:stateTypeId": "Uuid",
    "operator": "$ref:ValueOperator",
    "value": "Variant"
}

See also: ValueOperator

StateEvaluator

{
    "o:childEvaluators": [
        "$ref:StateEvaluator"
    ],
    "o:operator": "$ref:StateOperator",
    "o:stateDescriptor": "$ref:StateDescriptor"
}

See also: StateEvaluator, StateDescriptor, StateOperator

StateOperator

[
    "StateOperatorAnd",
    "StateOperatorOr"
]

StateType

{
    "defaultValue": "Variant",
    "displayName": "String",
    "id": "Uuid",
    "index": "Int",
    "name": "String",
    "o:maxValue": "Variant",
    "o:minValue": "Variant",
    "o:possibleValues": [
        "Variant"
    ],
    "o:unit": "$ref:Unit",
    "type": "$ref:BasicType"
}

See also: Unit, BasicType

Tag

{
    "appId": "String",
    "o:deviceId": "Uuid",
    "o:ruleId": "Uuid",
    "o:value": "String",
    "tagId": "String"
}

TagError

[
    "TagErrorNoError",
    "TagErrorDeviceNotFound",
    "TagErrorRuleNotFound",
    "TagErrorTagNotFound"
]

TimeDescriptor

{
    "o:calendarItems": [
        "$ref:CalendarItem"
    ],
    "o:timeEventItems": [
        "$ref:TimeEventItem"
    ]
}

See also: TimeEventItem, CalendarItem

TimeEventItem

{
    "o:datetime": "Uint",
    "o:repeating": "$ref:RepeatingOption",
    "o:time": "Time"
}

See also: RepeatingOption

TokenInfo

{
    "creationTime": "Uint",
    "deviceName": "String",
    "id": "Uuid",
    "userName": "String"
}

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",
    "UnitHertz",
    "UnitAmpere",
    "UnitMilliAmpere",
    "UnitVolt",
    "UnitMilliVolt",
    "UnitVoltAmpere",
    "UnitVoltAmpereReactive",
    "UnitAmpereHour",
    "UnitMicroSiemensPerCentimeter",
    "UnitDuration"
]

UserError

[
    "UserErrorNoError",
    "UserErrorBackendError",
    "UserErrorInvalidUserId",
    "UserErrorDuplicateUserId",
    "UserErrorBadPassword",
    "UserErrorTokenNotFound",
    "UserErrorPermissionDenied"
]

ValueOperator

[
    "ValueOperatorEquals",
    "ValueOperatorNotEquals",
    "ValueOperatorLess",
    "ValueOperatorGreater",
    "ValueOperatorLessOrEqual",
    "ValueOperatorGreaterOrEqual"
]

Vendor

{
    "displayName": "String",
    "id": "Uuid",
    "name": "String"
}

WebServerConfiguration

{
    "address": "String",
    "authenticationEnabled": "Bool",
    "id": "String",
    "port": "Uint",
    "sslEnabled": "Bool"
}

WiredNetworkDevice

{
    "bitRate": "String",
    "interface": "String",
    "macAddress": "String",
    "pluggedIn": "Bool",
    "state": "$ref:NetworkDeviceState"
}

See also: 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"
}

See also: WirelessAccessPoint, NetworkDeviceState

Methods

Actions.ExecuteAction

Execute a single action. Params

{
    "actionTypeId": "Uuid",
    "deviceId": "Uuid",
    "o:params": [
        "$ref:Param"
    ]
}

Returns

{
    "deviceError": "$ref:DeviceError",
    "o:displayMessage": "String"
}

See also: DeviceError, Param

Actions.ExecuteBrowserItem

Execute the item identified by itemId on the given device. Params

{
    "deviceId": "Uuid",
    "itemId": "String"
}

Returns

{
    "deviceError": "$ref:DeviceError"
}

See also: DeviceError

Actions.ExecuteBrowserItemAction

Execute the action for the browser item identified by actionTypeId and the itemId on the given device. Params

{
    "actionTypeId": "Uuid",
    "deviceId": "Uuid",
    "itemId": "String",
    "o:params": [
        "$ref:Param"
    ]
}

Returns

{
    "deviceError": "$ref:DeviceError"
}

See also: DeviceError, Param

Actions.GetActionType

Get the ActionType for the given ActionTypeId Params

{
    "actionTypeId": "Uuid"
}

Returns

{
    "deviceError": "$ref:DeviceError",
    "o:actionType": {
        "displayName": "String",
        "id": "Uuid",
        "index": "Int",
        "name": "String",
        "paramTypes": [
            "$ref:ParamType"
        ]
    }
}

See also: ParamType, DeviceError

Configuration.DeleteMqttPolicy

Delete a MQTT policy from the broker. Params

{
    "clientId": "String"
}

Returns

{
    "configurationError": "$ref:ConfigurationError"
}

See also: ConfigurationError

Configuration.DeleteMqttServerConfiguration

Delete a MQTT Server interface of the server. Params

{
    "id": "String"
}

Returns

{
    "configurationError": "$ref:ConfigurationError"
}

See also: ConfigurationError

Configuration.DeleteTcpServerConfiguration

Delete a TCP interface of the server. Note: if you are deleting the configuration for the interface you are currently connected to, the connection will be dropped. Params

{
    "id": "String"
}

Returns

{
    "configurationError": "$ref:ConfigurationError"
}

See also: ConfigurationError

Configuration.DeleteWebServerConfiguration

Delete a WebServer interface of the server. Params

{
    "id": "String"
}

Returns

{
    "configurationError": "$ref:ConfigurationError"
}

See also: ConfigurationError

Configuration.DeleteWebSocketServerConfiguration

Delete a WebSocket Server interface of the server. Note: if you are deleting the configuration for the interface you are currently connected to, the connection will be dropped. Params

{
    "id": "String"
}

Returns

{
    "configurationError": "$ref:ConfigurationError"
}

See also: ConfigurationError

Configuration.GetAvailableLanguages

DEPRECATED - Use the locale property in the Handshake message instead - Returns a list of locale codes available for the server. i.e. en_US, de_AT Params

{}

Returns

{
    "languages": [
        "String"
    ]
}

Configuration.GetConfigurations

Get all configuration parameters of the server. Params

{}

Returns

{
    "basicConfiguration": {
        "debugServerEnabled": "Bool",
        "language": "String",
        "serverName": "String",
        "serverTime": "Uint",
        "serverUuid": "Uuid",
        "timeZone": "String"
    },
    "cloud": {
        "enabled": "Bool"
    },
    "tcpServerConfigurations": [
        "$ref:ServerConfiguration"
    ],
    "webServerConfigurations": [
        "$ref:WebServerConfiguration"
    ],
    "webSocketServerConfigurations": [
        "$ref:ServerConfiguration"
    ]
}

See also: ServerConfiguration, WebServerConfiguration, ServerConfiguration

Configuration.GetMqttPolicies

Get all MQTT broker policies. Params

{}

Returns

{
    "mqttPolicies": [
        "$ref:MqttPolicy"
    ]
}

See also: MqttPolicy

Configuration.GetMqttServerConfigurations

Get all MQTT Server configurations. Params

{}

Returns

{
    "mqttServerConfigurations": [
        "$ref:ServerConfiguration"
    ]
}

See also: ServerConfiguration

Configuration.GetTimeZones

Get the list of available timezones. Params

{}

Returns

{
    "timeZones": [
        "String"
    ]
}

Configuration.SetCloudEnabled

Sets whether the cloud connection is enabled or disabled in the settings. Params

{
    "enabled": "Bool"
}

Returns

{
    "configurationError": "$ref:ConfigurationError"
}

See also: ConfigurationError

Configuration.SetDebugServerEnabled

Enable or disable the debug server. Params

{
    "enabled": "String"
}

Returns

{
    "configurationError": "$ref:ConfigurationError"
}

See also: ConfigurationError

Configuration.SetLanguage

DEPRECATED - Use the locale property in the Handshake message instead - Sets the server language to the given language. See also: "GetAvailableLanguages" Params

{
    "language": "String"
}

Returns

{
    "configurationError": "$ref:ConfigurationError"
}

See also: ConfigurationError

Configuration.SetMqttPolicy

Configure a MQTT broker policy. If the ID is an existing one, the existing policy will be modified, otherwise a new one will be added. Params

{
    "policy": "$ref:MqttPolicy"
}

Returns

{
    "configurationError": "$ref:ConfigurationError"
}

See also: ConfigurationError, MqttPolicy

Configuration.SetMqttServerConfiguration

Configure a MQTT Server interface on the MQTT broker. If the ID is an existing one, the existing config will be modified, otherwise a new one will be added. Setting authenticationEnabled to true will require MQTT clients to use credentials set in the MQTT broker policies. Params

{
    "configuration": "$ref:ServerConfiguration"
}

Returns

{
    "configurationError": "$ref:ConfigurationError"
}

See also: ConfigurationError, ServerConfiguration

Configuration.SetServerName

Set the name of the server. Default is nymea. Params

{
    "serverName": "String"
}

Returns

{
    "configurationError": "$ref:ConfigurationError"
}

See also: ConfigurationError

Configuration.SetTcpServerConfiguration

Configure a TCP interface of the server. If the ID is an existing one, the existing config will be modified, otherwise a new one will be added. Note: if you are changing the configuration for the interface you are currently connected to, the connection will be dropped. Params

{
    "configuration": "$ref:ServerConfiguration"
}

Returns

{
    "configurationError": "$ref:ConfigurationError"
}

See also: ConfigurationError, ServerConfiguration

Configuration.SetTimeZone

Set the time zone of the server. See also: "GetTimeZones" Params

{
    "timeZone": "String"
}

Returns

{
    "configurationError": "$ref:ConfigurationError"
}

See also: ConfigurationError

Configuration.SetWebServerConfiguration

Configure a WebServer interface of the server. If the ID is an existing one, the existing config will be modified, otherwise a new one will be added. Params

{
    "configuration": "$ref:WebServerConfiguration"
}

Returns

{
    "configurationError": "$ref:ConfigurationError"
}

See also: ConfigurationError, WebServerConfiguration

Configuration.SetWebSocketServerConfiguration

Configure a WebSocket Server interface of the server. If the ID is an existing one, the existing config will be modified, otherwise a new one will be added. Note: if you are changing the configuration for the interface you are currently connected to, the connection will be dropped. Params

{
    "configuration": "$ref:ServerConfiguration"
}

Returns

{
    "configurationError": "$ref:ConfigurationError"
}

See also: ConfigurationError, ServerConfiguration

Devices.AddConfiguredDevice

Add a configured device with a setupMethod of SetupMethodJustAdd. For devices with a setupMethod different than SetupMethodJustAdd, use PairDevice. Devices with CreateMethodJustAdd require all parameters to be supplied here. Devices with CreateMethodDiscovery require the use of a deviceDescriptorId. For discovered devices params are not required and will be taken from the DeviceDescriptor, however, they may be overridden by supplying parameters here. Params

{
    "deviceClassId": "Uuid",
    "name": "String",
    "o:deviceDescriptorId": "Uuid",
    "o:deviceParams": [
        "$ref:Param"
    ]
}

Returns

{
    "deviceError": "$ref:DeviceError",
    "o:deviceId": "Uuid",
    "o:displayMessage": "String"
}

See also: DeviceError, Param

Devices.BrowseDevice

Browse a device. If a DeviceClass indicates a device is browsable, this method will return the BrowserItems. If no parameter besides the deviceId is used, the root node of this device will be returned. Any returned item which is browsable can be passed as node. Results will be children of the given node. Params

{
    "deviceId": "Uuid",
    "o:itemId": "String"
}

Returns

{
    "deviceError": "$ref:DeviceError",
    "items": [
        "$ref:BrowserItem"
    ]
}

See also: BrowserItem, DeviceError

Devices.ConfirmPairing

Confirm an ongoing pairing. For SetupMethodUserAndPassword, provide the username in the "username" field and the password in the "secret" field. For SetupMethodEnterPin and provide the PIN in the "secret" field. For SetupMethodOAuth, return the entire unmodified callback URL containing the code parameter back in the secret field. Params

{
    "o:secret": "String",
    "o:username": "String",
    "pairingTransactionId": "Uuid"
}

Returns

{
    "deviceError": "$ref:DeviceError",
    "o:deviceId": "Uuid",
    "o:displayMessage": "String"
}

See also: DeviceError

Devices.EditDevice

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"
}

See also: DeviceError

Devices.GetActionTypes

Get action types for a specified deviceClassId. Params

{
    "deviceClassId": "Uuid"
}

Returns

{
    "actionTypes": [
        "$ref:ActionType"
    ]
}

See also: ActionType

Devices.GetBrowserItem

Get a single item from the browser. This won't give any more info on an item than a regular browseDevice call, but it allows to fetch details of an item if only the ID is known. Params

{
    "deviceId": "Uuid",
    "o:itemId": "String"
}

Returns

{
    "deviceError": "$ref:DeviceError",
    "o:item": "$ref:BrowserItem"
}

See also: BrowserItem, DeviceError

Devices.GetConfiguredDevices

Returns a list of configured devices, optionally filtered by deviceId. Params

{
    "o:deviceId": "Uuid"
}

Returns

{
    "devices": [
        "$ref:Device"
    ]
}

See also: Device

Devices.GetDiscoveredDevices

Performs a device discovery and returns the results. This function may take a while to return. Note that this method will include all the found devices, that is, including devices that may already have been added. Those devices will have deviceId set to the device id of the already added device. Such results may be used to reconfigure existing devices and might be filtered in cases where only unknown devices are of interest. Params

{
    "deviceClassId": "Uuid",
    "o:discoveryParams": [
        "$ref:Param"
    ]
}

Returns

{
    "deviceError": "$ref:DeviceError",
    "o:deviceDescriptors": [
        "$ref:DeviceDescriptor"
    ],
    "o:displayMessage": "String"
}

See also: DeviceDescriptor, DeviceError, Param

Devices.GetEventTypes

Get event types for a specified deviceClassId. Params

{
    "deviceClassId": "Uuid"
}

Returns

{
    "eventTypes": [
        "$ref:EventType"
    ]
}

See also: EventType

Devices.GetPluginConfiguration

Get a plugin's params. Params

{
    "pluginId": "Uuid"
}

Returns

{
    "deviceError": "$ref:DeviceError",
    "o:configuration": [
        "$ref:Param"
    ]
}

See also: Param, DeviceError

Devices.GetPlugins

Returns a list of loaded plugins. Params

{}

Returns

{
    "plugins": [
        "$ref:Plugin"
    ]
}

See also: Plugin

Devices.GetStateTypes

Get state types for a specified deviceClassId. Params

{
    "deviceClassId": "Uuid"
}

Returns

{
    "stateTypes": [
        "$ref:StateType"
    ]
}

See also: StateType

Devices.GetStateValue

Get the value of the given device and the given stateType Params

{
    "deviceId": "Uuid",
    "stateTypeId": "Uuid"
}

Returns

{
    "deviceError": "$ref:DeviceError",
    "o:value": "Variant"
}

See also: DeviceError

Devices.GetStateValues

Get all the state values of the given device. Params

{
    "deviceId": "Uuid"
}

Returns

{
    "deviceError": "$ref:DeviceError",
    "o:values": [
        {
            "stateTypeId": "Uuid",
            "value": "Variant"
        }
    ]
}

See also: DeviceError

Devices.GetSupportedDevices

Returns a list of supported Device classes, optionally filtered by vendorId. Params

{
    "o:vendorId": "Uuid"
}

Returns

{
    "deviceClasses": [
        "$ref:DeviceClass"
    ]
}

See also: DeviceClass

Devices.GetSupportedVendors

Returns a list of supported Vendors. Params

{}

Returns

{
    "vendors": [
        "$ref:Vendor"
    ]
}

See also: Vendor

Devices.PairDevice

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, optionally, parameters can be overridden here. 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:oAuthUrl": "String",
    "o:pairingTransactionId": "Uuid",
    "o:setupMethod": "$ref:SetupMethod"
}

See also: SetupMethod, DeviceError, Param

Devices.ReconfigureDevice

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",
    "o:displayMessage": "String"
}

See also: DeviceError, Param

Devices.RemoveConfiguredDevice

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"
    ]
}

See also: DeviceError, RemovePolicy, RemovePolicy

Devices.SetDeviceSettings

Change the settings of a device. Params

{
    "deviceId": "Uuid",
    "settings": [
        "$ref:Param"
    ]
}

Returns

{
    "deviceError": "$ref:DeviceError"
}

See also: DeviceError, Param

Devices.SetPluginConfiguration

Set a plugin's params. Params

{
    "configuration": [
        "$ref:Param"
    ],
    "pluginId": "Uuid"
}

Returns

{
    "deviceError": "$ref:DeviceError"
}

See also: DeviceError, Param

Events.GetEventType

Get the EventType for the given eventTypeId. Params

{
    "eventTypeId": "Uuid"
}

Returns

{
    "deviceError": "$ref:DeviceError",
    "o:eventType": "$ref:EventType"
}

See also: EventType, DeviceError

JSONRPC.Authenticate

Authenticate a client to the api via user & password challenge. Provide a device name which allows the user to identify the client and revoke the token in case the device is lost or stolen. This will return a new token to be used to authorize a client at the API. Params

{
    "deviceName": "String",
    "password": "String",
    "username": "String"
}

Returns

{
    "o:token": "String",
    "success": "Bool"
}

JSONRPC.CreateUser

Create a new user in the API. Currently this is only allowed to be called once when a new nymea instance is set up. Call Authenticate after this to obtain a device token for this user. Params

{
    "password": "String",
    "username": "String"
}

Returns

{
    "error": "$ref:UserError"
}

See also: UserError

JSONRPC.Hello

Initiates a connection. Use this method to perform an initial handshake of the connection. Optionally, a parameter "locale" is can be passed to set up the used locale for this connection. Strings such as DeviceClass displayNames etc will be localized to this locale. If this parameter is omitted, the default system locale (depending on the configuration) is used. The reply of this method contains information about this core instance such as version information, uuid and its name. The locale valueindicates the locale used for this connection. Note: This method can be called multiple times. The locale used in the last call for this connection will be used. Other values, like initialSetupRequired might change if the setup has been performed in the meantime. Params

{
    "o:locale": "String"
}

Returns

{
    "authenticationRequired": "Bool",
    "initialSetupRequired": "Bool",
    "language": "String",
    "locale": "String",
    "name": "String",
    "protocol version": "String",
    "pushButtonAuthAvailable": "Bool",
    "server": "String",
    "uuid": "Uuid",
    "version": "String"
}

JSONRPC.Introspect

Introspect this API. Params

{}

Returns

{
    "methods": "Object",
    "notifications": "Object",
    "types": "Object"
}

JSONRPC.IsCloudConnected

Check whether the cloud is currently connected. "connected" will be true whenever connectionState equals CloudConnectionStateConnected and is deprecated. Please use the connectionState value instead. Params

{}

Returns

{
    "connected": "Bool",
    "connectionState": "$ref:CloudConnectionState"
}

See also: CloudConnectionState

JSONRPC.KeepAlive

This is basically a Ping/Pong mechanism a client app may use to check server connectivity. Currently, the server does not actually do anything with this information and will return the call providing the given sessionId back to the caller. It is up to the client whether to use this or not and not required by the server to keep the connection alive. Params

{
    "sessionId": "String"
}

Returns

{
    "sessionId": "String",
    "success": "Bool"
}

JSONRPC.RemoveToken

Revoke access for a given token. Params

{
    "tokenId": "Uuid"
}

Returns

{
    "error": "$ref:UserError"
}

See also: UserError

JSONRPC.RequestPushButtonAuth

Authenticate a client to the api via Push Button method. Provide a device name which allows the user to identify the client and revoke the token in case the device is lost or stolen. If push button hardware is available, this will return with success and start listening for push button presses. When the push button is pressed, the PushButtonAuthFinished notification will be sent to the requesting client. The procedure will be cancelled when the connection is interrupted. If another client requests push button authentication while a procedure is still going on, the second call will take over and the first one will be notified by the PushButtonAuthFinished signal about the error. The application should make it clear to the user to not press the button when the procedure fails as this can happen for 2 reasons: a) a second user is trying to auth at the same time and only the currently active user should press the button or b) it might indicate an attacker trying to take over and snooping in for tokens. Params

{
    "deviceName": "String"
}

Returns

{
    "success": "Bool",
    "transactionId": "Int"
}

JSONRPC.SetNotificationStatus

Enable/Disable notifications for this connections. Either "enabled" or "namespaces" needs to be given but not both of them. The boolean based "enabled" parameter will enable/disable all notifications at once. If instead the list-based "namespaces" parameter is provided, all given namespaceswill be enabled, the others will be disabled. The return value of "success" will indicate success of the operation. The "enabled" property in the return value is deprecated and used for legacy compatibilty only. It will be set to true if at least one namespace has been enabled. Params

{
    "o:enabled": "Bool",
    "o:namespaces": [
        "$ref:Namespace"
    ]
}

Returns

{
    "enabled": "Bool",
    "namespaces": [
        "$ref:Namespace"
    ]
}

See also: Namespace, Namespace

JSONRPC.SetupCloudConnection

Sets up the cloud connection by deploying a certificate and its configuration. Params

{
    "certificatePEM": "String",
    "endpoint": "String",
    "privateKey": "String",
    "publicKey": "String",
    "rootCA": "String"
}

Returns

{
    "success": "Bool"
}

JSONRPC.SetupRemoteAccess

Setup the remote connection by providing AWS token information. This requires the cloud to be connected. Params

{
    "idToken": "String",
    "userId": "String"
}

Returns

{
    "message": "String",
    "status": "Int"
}

JSONRPC.Tokens

Return a list of TokenInfo objects of all the tokens for the current user. Params

{}

Returns

{
    "tokenInfoList": [
        "$ref:TokenInfo"
    ]
}

See also: TokenInfo

JSONRPC.Version

Version of this nymea/JSONRPC interface. Params

{}

Returns

{
    "protocol version": "String",
    "version": "String"
}

Logging.GetLogEntries

Get the LogEntries matching the given filter. The result set will contain entries matching all filter rules combined. If multiple options are given for a single filter type, the result set will contain entries matching any of those. The offset starts at the newest entry in the result set. By default all items are returned. Example: If the specified filter returns a total amount of 100 entries: - a offset value of 10 would include the oldest 90 entries - a offset value of 0 would return all 100 entries

The offset is particularly useful in combination with the maxCount property and can be used for pagination. E.g. A result set of 10000 entries can be fetched in batches of 1000 entries by fetching 1) offset 0, maxCount 1000: Entries 0 to 9999 2) offset 10000, maxCount 1000: Entries 10000 - 19999 3) offset 20000, maxCount 1000: Entries 20000 - 29999 ... Params

{
    "o:deviceIds": [
        "Uuid"
    ],
    "o:eventTypes": [
        "$ref:LoggingEventType"
    ],
    "o:limit": "Int",
    "o:loggingLevels": [
        "$ref:LoggingLevel"
    ],
    "o:loggingSources": [
        "$ref:LoggingSource"
    ],
    "o:offset": "Int",
    "o:timeFilters": [
        {
            "o:endDate": "Int",
            "o:startDate": "Int"
        }
    ],
    "o:typeIds": [
        "Uuid"
    ],
    "o:values": [
        "Variant"
    ]
}

Returns

{
    "count": "Int",
    "loggingError": "$ref:LoggingError",
    "o:logEntries": [
        "$ref:LogEntry"
    ],
    "offset": "Int"
}

See also: LogEntry, LoggingError, LoggingLevel, LoggingEventType, LoggingSource

NetworkManager.ConnectWifiNetwork

Connect to the wifi network with the given ssid and password. Params

{
    "interface": "String",
    "o:password": "String",
    "ssid": "String"
}

Returns

{
    "networkManagerError": "$ref:NetworkManagerError"
}

See also: NetworkManagerError

NetworkManager.DisconnectInterface

Disconnect the given network interface. The interface will remain disconnected until the user connect it again. Params

{
    "interface": "String"
}

Returns

{
    "networkManagerError": "$ref:NetworkManagerError"
}

See also: NetworkManagerError

NetworkManager.EnableNetworking

Enable or disable networking in the NetworkManager. Params

{
    "enable": "Bool"
}

Returns

{
    "networkManagerError": "$ref:NetworkManagerError"
}

See also: NetworkManagerError

NetworkManager.EnableWirelessNetworking

Enable or disable wireless networking in the NetworkManager. Params

{
    "enable": "Bool"
}

Returns

{
    "networkManagerError": "$ref:NetworkManagerError"
}

See also: NetworkManagerError

NetworkManager.GetNetworkDevices

Get the list of current network devices. Params

{}

Returns

{
    "networkManagerError": "$ref:NetworkManagerError",
    "wiredNetworkDevices": [
        "$ref:WiredNetworkDevice"
    ],
    "wirelessNetworkDevices": [
        "$ref:WirelessNetworkDevice"
    ]
}

See also: NetworkManagerError, WiredNetworkDevice, WirelessNetworkDevice

NetworkManager.GetNetworkStatus

Get the current network manager status. Params

{}

Returns

{
    "networkManagerError": "$ref:NetworkManagerError",
    "o:status": {
        "networkingEnabled": "Bool",
        "state": "$ref:NetworkManagerState",
        "wirelessNetworkingEnabled": "Bool"
    }
}

See also: NetworkManagerError, NetworkManagerState

NetworkManager.GetWirelessAccessPoints

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"
    ]
}

See also: NetworkManagerError, WirelessAccessPoint

NetworkManager.ScanWifiNetworks

Start a wifi scan for searching new networks. Params

{
    "interface": "String"
}

Returns

{
    "networkManagerError": "$ref:NetworkManagerError"
}

See also: NetworkManagerError

Rules.AddRule

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. A rule can have a list of actions and exitActions. It must have at least one Action. For state based rules, actions will be executed when the system enters a state matching the stateDescriptor. The exitActions will be executed when the system leaves the described state again. For event based rules, actions will be executed when a matching event happens and if the stateEvaluator matches the system's state. ExitActions for such rules will be executed when a matching event happens and the stateEvaluator is not matching the system's state. A rule marked as executable can be executed via the API using Rules.ExecuteRule, that means, its actions will be executed regardless of the eventDescriptor and stateEvaluators. 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"
}

See also: RuleError, RuleAction, TimeDescriptor, RuleAction, EventDescriptor, StateEvaluator

Rules.DisableRule

Disable a rule. The rule won't be triggered by it's events or state changes while it is disabled. If successful, the notification "Rule.RuleConfigurationChanged" will be emitted. Params

{
    "ruleId": "Uuid"
}

Returns

{
    "ruleError": "$ref:RuleError"
}

See also: RuleError

Rules.EditRule

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 successful, 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"
}

See also: RuleError, Rule, RuleAction, TimeDescriptor, RuleAction, EventDescriptor, StateEvaluator

Rules.EnableRule

Enabled a rule that has previously been disabled.If successful, the notification "Rule.RuleConfigurationChanged" will be emitted. Params

{
    "ruleId": "Uuid"
}

Returns

{
    "ruleError": "$ref:RuleError"
}

See also: RuleError

Rules.ExecuteActions

Execute the action list of the rule with the given ruleId. Params

{
    "ruleId": "Uuid"
}

Returns

{
    "ruleError": "$ref:RuleError"
}

See also: RuleError

Rules.ExecuteExitActions

Execute the exit action list of the rule with the given ruleId. Params

{
    "ruleId": "Uuid"
}

Returns

{
    "ruleError": "$ref:RuleError"
}

See also: RuleError

Rules.FindRules

Find a list of rules containing any of the given parameters. Params

{
    "deviceId": "Uuid"
}

Returns

{
    "ruleIds": [
        "Uuid"
    ]
}

Rules.GetRuleDetails

Get details for the rule identified by ruleId Params

{
    "ruleId": "Uuid"
}

Returns

{
    "o:rule": "$ref:Rule",
    "ruleError": "$ref:RuleError"
}

See also: RuleError, Rule

Rules.GetRules

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"
    ]
}

See also: RuleDescription

Rules.RemoveRule

Remove a rule Params

{
    "ruleId": "Uuid"
}

Returns

{
    "ruleError": "$ref:RuleError"
}

See also: RuleError

States.GetStateType

Get the StateType for the given stateTypeId. Params

{
    "stateTypeId": "Uuid"
}

Returns

{
    "deviceError": "$ref:DeviceError",
    "o:stateType": "$ref:StateType"
}

See also: StateType, DeviceError

System.CheckForUpdates

Instruct the system to poll the server for updates. Normally the system should automatically do this in regular intervals, however, if the client wants to allow the user to manually check for new updates now, this can be called. Returns true if the operation has been started successfully and the update manager will become busy. In order to know whether there are updates available, clients should walk through the list of packages retrieved from GetPackages and check whether there are packages with the updateAvailable flag set to true. Params

{}

Returns

{
    "success": "Bool"
}

System.EnableRepository

Enable or disable a repository. Params

{
    "enabled": "Bool",
    "repositoryId": "String"
}

Returns

{
    "success": "Bool"
}

System.GetCapabilities

Get the list of capabilites on this system. This allows reading whether things like rebooting or shutting down the system running nymea:core is supported on this host. Params

{}

Returns

{
    "powerManagement": "Bool",
    "updateManagement": "Bool"
}

System.GetPackages

Get the list of packages currently available to the system. This might include installed available but not installed packages. Installed packages will have the installedVersion set to a non-empty value. Params

{}

Returns

{
    "packages": [
        "$ref:Package"
    ]
}

See also: Package

System.GetRepositories

Get the list of repositories currently available to the system. Params

{}

Returns

{
    "repositories": [
        "$ref:Repository"
    ]
}

See also: Repository

System.GetUpdateStatus

Get the current status of the update system. "busy" indicates that the system is current busy with an operation regarding updates. This does not necessarily mean an actual update is running. When this is true, update related functions on the client should be marked as busy and no interaction with update components shall be allowed. An example for such a state is when the system queries the server if there are updates available, typically after a call to CheckForUpdates. "updateRunning" on the other hand indicates an actual update process is ongoing. The user should be informed about it, the system also might restart at any point while an update is running. Params

{}

Returns

{
    "busy": "Bool",
    "updateRunning": "Bool"
}

System.Reboot

Initiate a reboot of the system. The return value will indicate whether the procedure has been initiated successfully. Params

{}

Returns

{
    "success": "Bool"
}

System.RemovePackages

Starts removing a package. Returns true if the removal has been started successfully. Before calling this method, clients should check whether the package can be removed (canRemove set to true). Params

{
    "packageIds": [
        "String"
    ]
}

Returns

{
    "success": "Bool"
}

System.RollbackPackages

Starts a rollback. Returns true if the rollback has been started successfully. Before calling this method, clients should check whether the package can be rolled back (canRollback set to true). Params

{
    "packageIds": [
        "String"
    ]
}

Returns

{
    "success": "Bool"
}

System.Shutdown

Initiate a shutdown of the system. The return value will indicate whether the procedure has been initiated successfully. Params

{}

Returns

{
    "success": "Bool"
}

System.UpdatePackages

Starts updating/installing packages with the given ids. Returns true if the upgrade has been started successfully. Note that it might still fail later. Before calling this method, clients should check the packages whether they are in a state where they can either be installed (no installedVersion set) or upgraded (updateAvailable set to true). Params

{
    "o:packageIds": [
        "String"
    ]
}

Returns

{
    "success": "Bool"
}

Tags.AddTag

Add a Tag. A Tag must have a deviceId OR a ruleId (call this method twice if you want to attach the same tag to a device and a rule), an appId (Use the appId of your app), a tagId (e.g. "favorites") and a value. Upon success, a TagAdded notification will be emitted. Calling this method twice for the same ids (device/rule, appId and tagId) but with a different value will update the tag's value and the TagValueChanged notification will be emitted. Params

{
    "tag": "$ref:Tag"
}

Returns

{
    "tagError": "$ref:TagError"
}

See also: TagError, Tag

Tags.GetTags

Get the Tags matching the given filter. Tags can be filtered by a deviceID, a ruleId, an appId, a tagId or a combination of any (however, combining deviceId and ruleId will return an empty result set). Params

{
    "o:appId": "String",
    "o:deviceId": "Uuid",
    "o:ruleId": "Uuid",
    "o:tagId": "String"
}

Returns

{
    "o:tags": [
        "$ref:Tag"
    ],
    "tagError": "$ref:TagError"
}

See also: TagError, Tag

Tags.RemoveTag

Remove a Tag. Tag value is optional and will be disregarded. If the ids match, the tag will be deleted and a TagRemoved notification will be emitted. Params

{
    "tag": "$ref:Tag"
}

Returns

{
    "tagError": "$ref:TagError"
}

See also: TagError, Tag

Notifications

Configuration.BasicConfigurationChanged

Emitted whenever the basic configuration of this server changes. Params

{
    "basicConfiguration": {
        "debugServerEnabled": "Bool",
        "language": "String",
        "serverName": "String",
        "serverTime": "Uint",
        "serverUuid": "Uuid",
        "timeZone": "String"
    }
}

Configuration.CloudConfigurationChanged

Emitted whenever the cloud configuration is changed. Params

{
    "cloudConfiguration": {
        "enabled": "Bool"
    }
}

Configuration.LanguageChanged

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.MqttPolicyChanged

Emitted whenever a MQTT broker policy is changed. Params

{
    "policy": "$ref:MqttPolicy"
}

See also: MqttPolicy

Configuration.MqttPolicyRemoved

Emitted whenever a MQTT broker policy is removed. Params

{
    "clientId": "String"
}

Configuration.MqttServerConfigurationChanged

Emitted whenever the MQTT broker configuration is changed. Params

{
    "mqttServerConfiguration": "$ref:ServerConfiguration"
}

See also: ServerConfiguration

Configuration.MqttServerConfigurationRemoved

Emitted whenever a MQTT server configuration is removed. Params

{
    "id": "String"
}

Configuration.TcpServerConfigurationChanged

Emitted whenever the TCP server configuration changes. Params

{
    "tcpServerConfiguration": "$ref:ServerConfiguration"
}

See also: ServerConfiguration

Configuration.TcpServerConfigurationRemoved

Emitted whenever a TCP server configuration is removed. Params

{
    "id": "String"
}

Configuration.WebServerConfigurationChanged

Emitted whenever the web server configuration changes. Params

{
    "webServerConfiguration": "$ref:WebServerConfiguration"
}

See also: WebServerConfiguration

Configuration.WebServerConfigurationRemoved

Emitted whenever a Web server configuration is removed. Params

{
    "id": "String"
}

Configuration.WebSocketServerConfigurationChanged

Emitted whenever the web socket server configuration changes. Params

{
    "webSocketServerConfiguration": "$ref:ServerConfiguration"
}

See also: ServerConfiguration

Configuration.WebSocketServerConfigurationRemoved

Emitted whenever a WebSocket server configuration is removed. Params

{
    "id": "String"
}

Devices.DeviceAdded

Emitted whenever a Device was added. Params

{
    "device": "$ref:Device"
}

See also: Device

Devices.DeviceChanged

Emitted whenever the params or name of a Device are changed (by EditDevice or ReconfigureDevice). Params

{
    "device": "$ref:Device"
}

See also: Device

Devices.DeviceRemoved

Emitted whenever a Device was removed. Params

{
    "deviceId": "Uuid"
}

Devices.DeviceSettingChanged

Emitted whenever the setting of a Device is changed. Params

{
    "deviceId": "Uuid",
    "paramTypeId": "Uuid",
    "value": "Variant"
}

Devices.PluginConfigurationChanged

Emitted whenever a plugin's configuration is changed. Params

{
    "configuration": [
        "$ref:Param"
    ],
    "pluginId": "Uuid"
}

See also: Param

Devices.StateChanged

Emitted whenever a State of a device changes. Params

{
    "deviceId": "Uuid",
    "stateTypeId": "Uuid",
    "value": "Variant"
}

Events.EventTriggered

Emitted whenever an Event is triggered. Params

{
    "event": "$ref:Event"
}

See also: Event

JSONRPC.CloudConnectedChanged

Emitted whenever the cloud connection status changes. Params

{
    "connected": "Bool",
    "connectionState": "$ref:CloudConnectionState"
}

See also: CloudConnectionState

JSONRPC.PushButtonAuthFinished

Emitted when a push button authentication reaches final state. NOTE: This notification is special. It will only be emitted to connections that did actively request a push button authentication, but also it will be emitted regardless of the notification settings. Params

{
    "o:token": "String",
    "success": "Bool",
    "transactionId": "Int"
}

Logging.LogDatabaseUpdated

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

Emitted whenever an entry is appended to the logging system. Params

{
    "logEntry": "$ref:LogEntry"
}

See also: LogEntry

NetworkManager.NetworkStatusChanged

Emitted whenever a status of a NetworkManager changes. Params

{
    "status": {
        "networkingEnabled": "Bool",
        "state": "$ref:NetworkManagerState",
        "wirelessNetworkingEnabled": "Bool"
    }
}

See also: NetworkManagerState

NetworkManager.WiredNetworkDeviceAdded

Emitted whenever a new WiredNetworkDevice was added. Params

{
    "wiredNetworkDevice": "$ref:WiredNetworkDevice"
}

See also: WiredNetworkDevice

NetworkManager.WiredNetworkDeviceChanged

Emitted whenever the given WiredNetworkDevice has changed. Params

{
    "wiredNetworkDevice": "$ref:WiredNetworkDevice"
}

See also: WiredNetworkDevice

NetworkManager.WiredNetworkDeviceRemoved

Emitted whenever a WiredNetworkDevice was removed. Params

{
    "interface": "String"
}

NetworkManager.WirelessNetworkDeviceAdded

Emitted whenever a new WirelessNetworkDevice was added. Params

{
    "wirelessNetworkDevice": "$ref:WirelessNetworkDevice"
}

See also: WirelessNetworkDevice

NetworkManager.WirelessNetworkDeviceChanged

Emitted whenever the given WirelessNetworkDevice has changed. Params

{
    "wirelessNetworkDevice": "$ref:WirelessNetworkDevice"
}

See also: WirelessNetworkDevice

NetworkManager.WirelessNetworkDeviceRemoved

Emitted whenever a WirelessNetworkDevice was removed. Params

{
    "interface": "String"
}

Rules.RuleActiveChanged

Emitted whenever the active state of a Rule changed. Params

{
    "active": "Bool",
    "ruleId": "Uuid"
}

Rules.RuleAdded

Emitted whenever a Rule was added. Params

{
    "rule": "$ref:Rule"
}

See also: Rule

Rules.RuleConfigurationChanged

Emitted whenever the configuration of a Rule changed. Params

{
    "rule": "$ref:Rule"
}

See also: Rule

Rules.RuleRemoved

Emitted whenever a Rule was removed. Params

{
    "ruleId": "Uuid"
}

System.CapabilitiesChanged

Emitted whenever the system capabilities change. Params

{
    "powerManagement": "Bool",
    "updateManagement": "Bool"
}

System.PackageAdded

Emitted whenever a package is added to the list of packages. Params

{
    "package": "$ref:Package"
}

See also: Package

System.PackageChanged

Emitted whenever a package in the list of packages changes. Params

{
    "package": "$ref:Package"
}

See also: Package

System.PackageRemoved

Emitted whenever a package is removed from the list of packages. Params

{
    "packageId": "String"
}

System.RepositoryAdded

Emitted whenever a repository is added to the list of repositories. Params

{
    "repository": "$ref:Repository"
}

See also: Repository

System.RepositoryChanged

Emitted whenever a repository in the list of repositories changes. Params

{
    "repository": "$ref:Repository"
}

See also: Repository

System.RepositoryRemoved

Emitted whenever a repository is removed from the list of repositories. Params

{
    "repositoryId": "String"
}

System.UpdateStatusChanged

Emitted whenever the update status changes. Params

{
    "busy": "Bool",
    "updateRunning": "Bool"
}

Tags.TagAdded

Emitted whenever a tag is added to the system. Params

{
    "tag": "$ref:Tag"
}

See also: Tag

Tags.TagRemoved

Emitted whenever a tag is removed from the system. Params

{
    "tag": "$ref:Tag"
}

See also: Tag

Tags.TagValueChanged

Emitted whenever a tag's value is changed in the system. Params

{
    "tag": "$ref:Tag"
}

See also: Tag

Full introspect

{
    "methods": {
        "Actions.ExecuteAction": {
            "description": "Execute a single action.",
            "params": {
                "actionTypeId": "Uuid",
                "deviceId": "Uuid",
                "o:params": [
                    "$ref:Param"
                ]
            },
            "returns": {
                "deviceError": "$ref:DeviceError",
                "o:displayMessage": "String"
            }
        },
        "Actions.ExecuteBrowserItem": {
            "description": "Execute the item identified by itemId on the given device.",
            "params": {
                "deviceId": "Uuid",
                "itemId": "String"
            },
            "returns": {
                "deviceError": "$ref:DeviceError"
            }
        },
        "Actions.ExecuteBrowserItemAction": {
            "description": "Execute the action for the browser item identified by actionTypeId and the itemId on the given device.",
            "params": {
                "actionTypeId": "Uuid",
                "deviceId": "Uuid",
                "itemId": "String",
                "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": {
                    "displayName": "String",
                    "id": "Uuid",
                    "index": "Int",
                    "name": "String",
                    "paramTypes": [
                        "$ref:ParamType"
                    ]
                }
            }
        },
        "Configuration.DeleteMqttPolicy": {
            "description": "Delete a MQTT policy from the broker.",
            "params": {
                "clientId": "String"
            },
            "returns": {
                "configurationError": "$ref:ConfigurationError"
            }
        },
        "Configuration.DeleteMqttServerConfiguration": {
            "description": "Delete a MQTT Server interface of the server.",
            "params": {
                "id": "String"
            },
            "returns": {
                "configurationError": "$ref:ConfigurationError"
            }
        },
        "Configuration.DeleteTcpServerConfiguration": {
            "description": "Delete a TCP interface of the server. Note: if you are deleting the configuration for the interface you are currently connected to, the connection will be dropped.",
            "params": {
                "id": "String"
            },
            "returns": {
                "configurationError": "$ref:ConfigurationError"
            }
        },
        "Configuration.DeleteWebServerConfiguration": {
            "description": "Delete a WebServer interface of the server.",
            "params": {
                "id": "String"
            },
            "returns": {
                "configurationError": "$ref:ConfigurationError"
            }
        },
        "Configuration.DeleteWebSocketServerConfiguration": {
            "description": "Delete a WebSocket Server interface of the server. Note: if you are deleting the configuration for the interface you are currently connected to, the connection will be dropped.",
            "params": {
                "id": "String"
            },
            "returns": {
                "configurationError": "$ref:ConfigurationError"
            }
        },
        "Configuration.GetAvailableLanguages": {
            "description": "DEPRECATED - Use the locale property in the Handshake message instead - 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": {
                    "debugServerEnabled": "Bool",
                    "language": "String",
                    "serverName": "String",
                    "serverTime": "Uint",
                    "serverUuid": "Uuid",
                    "timeZone": "String"
                },
                "cloud": {
                    "enabled": "Bool"
                },
                "tcpServerConfigurations": [
                    "$ref:ServerConfiguration"
                ],
                "webServerConfigurations": [
                    "$ref:WebServerConfiguration"
                ],
                "webSocketServerConfigurations": [
                    "$ref:ServerConfiguration"
                ]
            }
        },
        "Configuration.GetMqttPolicies": {
            "description": "Get all MQTT broker policies.",
            "params": {},
            "returns": {
                "mqttPolicies": [
                    "$ref:MqttPolicy"
                ]
            }
        },
        "Configuration.GetMqttServerConfigurations": {
            "description": "Get all MQTT Server configurations.",
            "params": {},
            "returns": {
                "mqttServerConfigurations": [
                    "$ref:ServerConfiguration"
                ]
            }
        },
        "Configuration.GetTimeZones": {
            "description": "Get the list of available timezones.",
            "params": {},
            "returns": {
                "timeZones": [
                    "String"
                ]
            }
        },
        "Configuration.SetCloudEnabled": {
            "description": "Sets whether the cloud connection is enabled or disabled in the settings.",
            "params": {
                "enabled": "Bool"
            },
            "returns": {
                "configurationError": "$ref:ConfigurationError"
            }
        },
        "Configuration.SetDebugServerEnabled": {
            "description": "Enable or disable the debug server.",
            "params": {
                "enabled": "String"
            },
            "returns": {
                "configurationError": "$ref:ConfigurationError"
            }
        },
        "Configuration.SetLanguage": {
            "description": "DEPRECATED - Use the locale property in the Handshake message instead - Sets the server language to the given language. See also: \"GetAvailableLanguages\"",
            "params": {
                "language": "String"
            },
            "returns": {
                "configurationError": "$ref:ConfigurationError"
            }
        },
        "Configuration.SetMqttPolicy": {
            "description": "Configure a MQTT broker policy. If the ID is an existing one, the existing policy will be modified, otherwise a new one will be added.",
            "params": {
                "policy": "$ref:MqttPolicy"
            },
            "returns": {
                "configurationError": "$ref:ConfigurationError"
            }
        },
        "Configuration.SetMqttServerConfiguration": {
            "description": "Configure a MQTT Server interface on the MQTT broker. If the ID is an existing one, the existing config will be modified, otherwise a new one will be added. Setting authenticationEnabled to true will require MQTT clients to use credentials set in the MQTT broker policies.",
            "params": {
                "configuration": "$ref:ServerConfiguration"
            },
            "returns": {
                "configurationError": "$ref:ConfigurationError"
            }
        },
        "Configuration.SetServerName": {
            "description": "Set the name of the server. Default is nymea.",
            "params": {
                "serverName": "String"
            },
            "returns": {
                "configurationError": "$ref:ConfigurationError"
            }
        },
        "Configuration.SetTcpServerConfiguration": {
            "description": "Configure a TCP interface of the server. If the ID is an existing one, the existing config will be modified, otherwise a new one will be added. Note: if you are changing the configuration for the interface you are currently connected to, the connection will be dropped.",
            "params": {
                "configuration": "$ref:ServerConfiguration"
            },
            "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 a WebServer interface of the server. If the ID is an existing one, the existing config will be modified, otherwise a new one will be added.",
            "params": {
                "configuration": "$ref:WebServerConfiguration"
            },
            "returns": {
                "configurationError": "$ref:ConfigurationError"
            }
        },
        "Configuration.SetWebSocketServerConfiguration": {
            "description": "Configure a WebSocket Server interface of the server. If the ID is an existing one, the existing config will be modified, otherwise a new one will be added. Note: if you are changing the configuration for the interface you are currently connected to, the connection will be dropped.",
            "params": {
                "configuration": "$ref:ServerConfiguration"
            },
            "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. Devices with CreateMethodJustAdd require all parameters to be supplied here. Devices with CreateMethodDiscovery require the use of a deviceDescriptorId. For discovered devices params are not required and will be taken from the DeviceDescriptor, however, they may be overridden by supplying parameters here.",
            "params": {
                "deviceClassId": "Uuid",
                "name": "String",
                "o:deviceDescriptorId": "Uuid",
                "o:deviceParams": [
                    "$ref:Param"
                ]
            },
            "returns": {
                "deviceError": "$ref:DeviceError",
                "o:deviceId": "Uuid",
                "o:displayMessage": "String"
            }
        },
        "Devices.BrowseDevice": {
            "description": "Browse a device. If a DeviceClass indicates a device is browsable, this method will return the BrowserItems. If no parameter besides the deviceId is used, the root node of this device will be returned. Any returned item which is browsable can be passed as node. Results will be children of the given node.",
            "params": {
                "deviceId": "Uuid",
                "o:itemId": "String"
            },
            "returns": {
                "deviceError": "$ref:DeviceError",
                "items": [
                    "$ref:BrowserItem"
                ]
            }
        },
        "Devices.ConfirmPairing": {
            "description": "Confirm an ongoing pairing. For SetupMethodUserAndPassword, provide the username in the \"username\" field and the password in the \"secret\" field. For SetupMethodEnterPin and provide the PIN in the \"secret\" field. For SetupMethodOAuth, return the entire unmodified callback URL containing the code parameter back in the secret field.",
            "params": {
                "o:secret": "String",
                "o:username": "String",
                "pairingTransactionId": "Uuid"
            },
            "returns": {
                "deviceError": "$ref:DeviceError",
                "o:deviceId": "Uuid",
                "o:displayMessage": "String"
            }
        },
        "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.GetBrowserItem": {
            "description": "Get a single item from the browser. This won't give any more info on an item than a regular browseDevice call, but it allows to fetch details of an item if only the ID is known.",
            "params": {
                "deviceId": "Uuid",
                "o:itemId": "String"
            },
            "returns": {
                "deviceError": "$ref:DeviceError",
                "o:item": "$ref:BrowserItem"
            }
        },
        "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. Note that this method will include all the found devices, that is, including devices that may already have been added. Those devices will have deviceId set to the device id of the already added device. Such results may be used to reconfigure existing devices and might be filtered in cases where only unknown devices are of interest.",
            "params": {
                "deviceClassId": "Uuid",
                "o:discoveryParams": [
                    "$ref:Param"
                ]
            },
            "returns": {
                "deviceError": "$ref:DeviceError",
                "o:deviceDescriptors": [
                    "$ref:DeviceDescriptor"
                ],
                "o:displayMessage": "String"
            }
        },
        "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, optionally, parameters can be overridden here. 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:oAuthUrl": "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",
                "o:displayMessage": "String"
            }
        },
        "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.SetDeviceSettings": {
            "description": "Change the settings of a device.",
            "params": {
                "deviceId": "Uuid",
                "settings": [
                    "$ref:Param"
                ]
            },
            "returns": {
                "deviceError": "$ref:DeviceError"
            }
        },
        "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.Authenticate": {
            "description": "Authenticate a client to the api via user & password challenge. Provide a device name which allows the user to identify the client and revoke the token in case the device is lost or stolen. This will return a new token to be used to authorize a client at the API.",
            "params": {
                "deviceName": "String",
                "password": "String",
                "username": "String"
            },
            "returns": {
                "o:token": "String",
                "success": "Bool"
            }
        },
        "JSONRPC.CreateUser": {
            "description": "Create a new user in the API. Currently this is only allowed to be called once when a new nymea instance is set up. Call Authenticate after this to obtain a device token for this user.",
            "params": {
                "password": "String",
                "username": "String"
            },
            "returns": {
                "error": "$ref:UserError"
            }
        },
        "JSONRPC.Hello": {
            "description": "Initiates a connection. Use this method to perform an initial handshake of the connection. Optionally, a parameter \"locale\" is can be passed to set up the used locale for this connection. Strings such as DeviceClass displayNames etc will be localized to this locale. If this parameter is omitted, the default system locale (depending on the configuration) is used. The reply of this method contains information about this core instance such as version information, uuid and its name. The locale valueindicates the locale used for this connection. Note: This method can be called multiple times. The locale used in the last call for this connection will be used. Other values, like initialSetupRequired might change if the setup has been performed in the meantime.",
            "params": {
                "o:locale": "String"
            },
            "returns": {
                "authenticationRequired": "Bool",
                "initialSetupRequired": "Bool",
                "language": "String",
                "locale": "String",
                "name": "String",
                "protocol version": "String",
                "pushButtonAuthAvailable": "Bool",
                "server": "String",
                "uuid": "Uuid",
                "version": "String"
            }
        },
        "JSONRPC.Introspect": {
            "description": "Introspect this API.",
            "params": {},
            "returns": {
                "methods": "Object",
                "notifications": "Object",
                "types": "Object"
            }
        },
        "JSONRPC.IsCloudConnected": {
            "description": "Check whether the cloud is currently connected. \"connected\" will be true whenever connectionState equals CloudConnectionStateConnected and is deprecated. Please use the connectionState value instead.",
            "params": {},
            "returns": {
                "connected": "Bool",
                "connectionState": "$ref:CloudConnectionState"
            }
        },
        "JSONRPC.KeepAlive": {
            "description": "This is basically a Ping/Pong mechanism a client app may use to check server connectivity. Currently, the server does not actually do anything with this information and will return the call providing the given sessionId back to the caller. It is up to the client whether to use this or not and not required by the server to keep the connection alive.",
            "params": {
                "sessionId": "String"
            },
            "returns": {
                "sessionId": "String",
                "success": "Bool"
            }
        },
        "JSONRPC.RemoveToken": {
            "description": "Revoke access for a given token.",
            "params": {
                "tokenId": "Uuid"
            },
            "returns": {
                "error": "$ref:UserError"
            }
        },
        "JSONRPC.RequestPushButtonAuth": {
            "description": "Authenticate a client to the api via Push Button method. Provide a device name which allows the user to identify the client and revoke the token in case the device is lost or stolen. If push button hardware is available, this will return with success and start listening for push button presses. When the push button is pressed, the PushButtonAuthFinished notification will be sent to the requesting client. The procedure will be cancelled when the connection is interrupted. If another client requests push button authentication while a procedure is still going on, the second call will take over and the first one will be notified by the PushButtonAuthFinished signal about the error. The application should make it clear to the user to not press the button when the procedure fails as this can happen for 2 reasons: a) a second user is trying to auth at the same time and only the currently active user should press the button or b) it might indicate an attacker trying to take over and snooping in for tokens.",
            "params": {
                "deviceName": "String"
            },
            "returns": {
                "success": "Bool",
                "transactionId": "Int"
            }
        },
        "JSONRPC.SetNotificationStatus": {
            "description": "Enable/Disable notifications for this connections. Either \"enabled\" or \"namespaces\" needs to be given but not both of them. The boolean based \"enabled\" parameter will enable/disable all notifications at once. If instead the list-based \"namespaces\" parameter is provided, all given namespaceswill be enabled, the others will be disabled. The return value of \"success\" will indicate success of the operation. The \"enabled\" property in the return value is deprecated and used for legacy compatibilty only. It will be set to true if at least one namespace has been enabled.",
            "params": {
                "o:enabled": "Bool",
                "o:namespaces": [
                    "$ref:Namespace"
                ]
            },
            "returns": {
                "enabled": "Bool",
                "namespaces": [
                    "$ref:Namespace"
                ]
            }
        },
        "JSONRPC.SetupCloudConnection": {
            "description": "Sets up the cloud connection by deploying a certificate and its configuration.",
            "params": {
                "certificatePEM": "String",
                "endpoint": "String",
                "privateKey": "String",
                "publicKey": "String",
                "rootCA": "String"
            },
            "returns": {
                "success": "Bool"
            }
        },
        "JSONRPC.SetupRemoteAccess": {
            "description": "Setup the remote connection by providing AWS token information. This requires the cloud to be connected.",
            "params": {
                "idToken": "String",
                "userId": "String"
            },
            "returns": {
                "message": "String",
                "status": "Int"
            }
        },
        "JSONRPC.Tokens": {
            "description": "Return a list of TokenInfo objects of all the tokens for the current user.",
            "params": {},
            "returns": {
                "tokenInfoList": [
                    "$ref:TokenInfo"
                ]
            }
        },
        "JSONRPC.Version": {
            "description": "Version of this nymea/JSONRPC interface.",
            "params": {},
            "returns": {
                "protocol version": "String",
                "version": "String"
            }
        },
        "Logging.GetLogEntries": {
            "description": "Get the LogEntries matching the given filter. The result set will contain entries matching all filter rules combined. If multiple options are given for a single filter type, the result set will contain entries matching any of those. The offset starts at the newest entry in the result set. By default all items are returned. Example: If the specified filter returns a total amount of 100 entries:\n- a offset value of 10 would include the oldest 90 entries\n- a offset value of 0 would return all 100 entries\n\nThe offset is particularly useful in combination with the maxCount property and can be used for pagination. E.g. A result set of 10000 entries can be fetched in  batches of 1000 entries by fetching\n1) offset 0, maxCount 1000: Entries 0 to 9999\n2) offset 10000, maxCount 1000: Entries 10000 - 19999\n3) offset 20000, maxCount 1000: Entries 20000 - 29999\n...",
            "params": {
                "o:deviceIds": [
                    "Uuid"
                ],
                "o:eventTypes": [
                    "$ref:LoggingEventType"
                ],
                "o:limit": "Int",
                "o:loggingLevels": [
                    "$ref:LoggingLevel"
                ],
                "o:loggingSources": [
                    "$ref:LoggingSource"
                ],
                "o:offset": "Int",
                "o:timeFilters": [
                    {
                        "o:endDate": "Int",
                        "o:startDate": "Int"
                    }
                ],
                "o:typeIds": [
                    "Uuid"
                ],
                "o:values": [
                    "Variant"
                ]
            },
            "returns": {
                "count": "Int",
                "loggingError": "$ref:LoggingError",
                "o:logEntries": [
                    "$ref:LogEntry"
                ],
                "offset": "Int"
            }
        },
        "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. A rule can have a list of actions and exitActions. It must have at least one Action. For state based rules, actions will be executed when the system enters a state matching the stateDescriptor. The exitActions will be executed when the system leaves the described state again. For event based rules, actions will be executed when a matching event happens and if the stateEvaluator matches the system's state. ExitActions for such rules will be executed when a matching event happens and the stateEvaluator is not matching the system's state. A rule marked as executable can be executed via the API using Rules.ExecuteRule, that means, its actions will be executed regardless of the eventDescriptor and stateEvaluators.",
            "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 successful, 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 successful, 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 successful, 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"
            }
        },
        "System.CheckForUpdates": {
            "description": "Instruct the system to poll the server for updates. Normally the system should automatically do this in regular intervals, however, if the client wants to allow the user to manually check for new updates now, this can be called. Returns true if the operation has been started successfully and the update manager will become busy. In order to know whether there are updates available, clients should walk through the list of packages retrieved from GetPackages and check whether there are packages with the updateAvailable flag set to true.",
            "params": {},
            "returns": {
                "success": "Bool"
            }
        },
        "System.EnableRepository": {
            "description": "Enable or disable a repository.",
            "params": {
                "enabled": "Bool",
                "repositoryId": "String"
            },
            "returns": {
                "success": "Bool"
            }
        },
        "System.GetCapabilities": {
            "description": "Get the list of capabilites on this system. This allows reading whether things like rebooting or shutting down the system running nymea:core is supported on this host.",
            "params": {},
            "returns": {
                "powerManagement": "Bool",
                "updateManagement": "Bool"
            }
        },
        "System.GetPackages": {
            "description": "Get the list of packages currently available to the system. This might include installed available but not installed packages. Installed packages will have the installedVersion set to a non-empty value.",
            "params": {},
            "returns": {
                "packages": [
                    "$ref:Package"
                ]
            }
        },
        "System.GetRepositories": {
            "description": "Get the list of repositories currently available to the system.",
            "params": {},
            "returns": {
                "repositories": [
                    "$ref:Repository"
                ]
            }
        },
        "System.GetUpdateStatus": {
            "description": "Get the current status of the update system. \"busy\" indicates that the system is current busy with an operation regarding updates. This does not necessarily mean an actual update is running. When this is true, update related functions on the client should be marked as busy and no interaction with update components shall be allowed. An example for such a state is when the system queries the server if there are updates available, typically after a call to CheckForUpdates. \"updateRunning\" on the other hand indicates an actual update process is ongoing. The user should be informed about it, the system also might restart at any point while an update is running.",
            "params": {},
            "returns": {
                "busy": "Bool",
                "updateRunning": "Bool"
            }
        },
        "System.Reboot": {
            "description": "Initiate a reboot of the system. The return value will indicate whether the procedure has been initiated successfully.",
            "params": {},
            "returns": {
                "success": "Bool"
            }
        },
        "System.RemovePackages": {
            "description": "Starts removing a package. Returns true if the removal has been started successfully. Before calling this method, clients should check whether the package can be removed (canRemove set to true).",
            "params": {
                "packageIds": [
                    "String"
                ]
            },
            "returns": {
                "success": "Bool"
            }
        },
        "System.RollbackPackages": {
            "description": "Starts a rollback. Returns true if the rollback has been started successfully. Before calling this method, clients should check whether the package can be rolled back (canRollback set to true).",
            "params": {
                "packageIds": [
                    "String"
                ]
            },
            "returns": {
                "success": "Bool"
            }
        },
        "System.Shutdown": {
            "description": "Initiate a shutdown of the system. The return value will indicate whether the procedure has been initiated successfully.",
            "params": {},
            "returns": {
                "success": "Bool"
            }
        },
        "System.UpdatePackages": {
            "description": "Starts updating/installing packages with the given ids. Returns true if the upgrade has been started successfully. Note that it might still fail later. Before calling this method, clients should check the packages whether they are in a state where they can either be installed (no installedVersion set) or upgraded (updateAvailable set to true).",
            "params": {
                "o:packageIds": [
                    "String"
                ]
            },
            "returns": {
                "success": "Bool"
            }
        },
        "Tags.AddTag": {
            "description": "Add a Tag. A Tag must have a deviceId OR a ruleId (call this method twice if you want to attach the same tag to a device and a rule), an appId (Use the appId of your app), a tagId (e.g. \"favorites\") and a value. Upon success, a TagAdded notification will be emitted. Calling this method twice for the same ids (device/rule, appId and tagId) but with a different value will update the tag's value and the TagValueChanged notification will be emitted.",
            "params": {
                "tag": "$ref:Tag"
            },
            "returns": {
                "tagError": "$ref:TagError"
            }
        },
        "Tags.GetTags": {
            "description": "Get the Tags matching the given filter. Tags can be filtered by a deviceID, a ruleId, an appId, a tagId or a combination of any (however, combining deviceId and ruleId will return an empty result set).",
            "params": {
                "o:appId": "String",
                "o:deviceId": "Uuid",
                "o:ruleId": "Uuid",
                "o:tagId": "String"
            },
            "returns": {
                "o:tags": [
                    "$ref:Tag"
                ],
                "tagError": "$ref:TagError"
            }
        },
        "Tags.RemoveTag": {
            "description": "Remove a Tag. Tag value is optional and will be disregarded. If the ids match, the tag will be deleted and a TagRemoved notification will be emitted.",
            "params": {
                "tag": "$ref:Tag"
            },
            "returns": {
                "tagError": "$ref:TagError"
            }
        }
    },
    "notifications": {
        "Configuration.BasicConfigurationChanged": {
            "description": "Emitted whenever the basic configuration of this server changes.",
            "params": {
                "basicConfiguration": {
                    "debugServerEnabled": "Bool",
                    "language": "String",
                    "serverName": "String",
                    "serverTime": "Uint",
                    "serverUuid": "Uuid",
                    "timeZone": "String"
                }
            }
        },
        "Configuration.CloudConfigurationChanged": {
            "description": "Emitted whenever the cloud configuration is changed.",
            "params": {
                "cloudConfiguration": {
                    "enabled": "Bool"
                }
            }
        },
        "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.MqttPolicyChanged": {
            "description": "Emitted whenever a MQTT broker policy is changed.",
            "params": {
                "policy": "$ref:MqttPolicy"
            }
        },
        "Configuration.MqttPolicyRemoved": {
            "description": "Emitted whenever a MQTT broker policy is removed.",
            "params": {
                "clientId": "String"
            }
        },
        "Configuration.MqttServerConfigurationChanged": {
            "description": "Emitted whenever the MQTT broker configuration is changed.",
            "params": {
                "mqttServerConfiguration": "$ref:ServerConfiguration"
            }
        },
        "Configuration.MqttServerConfigurationRemoved": {
            "description": "Emitted whenever a MQTT server configuration is removed.",
            "params": {
                "id": "String"
            }
        },
        "Configuration.TcpServerConfigurationChanged": {
            "description": "Emitted whenever the TCP server configuration changes.",
            "params": {
                "tcpServerConfiguration": "$ref:ServerConfiguration"
            }
        },
        "Configuration.TcpServerConfigurationRemoved": {
            "description": "Emitted whenever a TCP server configuration is removed.",
            "params": {
                "id": "String"
            }
        },
        "Configuration.WebServerConfigurationChanged": {
            "description": "Emitted whenever the web server configuration changes.",
            "params": {
                "webServerConfiguration": "$ref:WebServerConfiguration"
            }
        },
        "Configuration.WebServerConfigurationRemoved": {
            "description": "Emitted whenever a Web server configuration is removed.",
            "params": {
                "id": "String"
            }
        },
        "Configuration.WebSocketServerConfigurationChanged": {
            "description": "Emitted whenever the web socket server configuration changes.",
            "params": {
                "webSocketServerConfiguration": "$ref:ServerConfiguration"
            }
        },
        "Configuration.WebSocketServerConfigurationRemoved": {
            "description": "Emitted whenever a WebSocket server configuration is removed.",
            "params": {
                "id": "String"
            }
        },
        "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 are changed (by EditDevice or ReconfigureDevice).",
            "params": {
                "device": "$ref:Device"
            }
        },
        "Devices.DeviceRemoved": {
            "description": "Emitted whenever a Device was removed.",
            "params": {
                "deviceId": "Uuid"
            }
        },
        "Devices.DeviceSettingChanged": {
            "description": "Emitted whenever the setting of a Device is changed.",
            "params": {
                "deviceId": "Uuid",
                "paramTypeId": "Uuid",
                "value": "Variant"
            }
        },
        "Devices.PluginConfigurationChanged": {
            "description": "Emitted whenever a plugin's configuration is changed.",
            "params": {
                "configuration": [
                    "$ref:Param"
                ],
                "pluginId": "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"
            }
        },
        "JSONRPC.CloudConnectedChanged": {
            "description": "Emitted whenever the cloud connection status changes.",
            "params": {
                "connected": "Bool",
                "connectionState": "$ref:CloudConnectionState"
            }
        },
        "JSONRPC.PushButtonAuthFinished": {
            "description": "Emitted when a push button authentication reaches final state. NOTE: This notification is special. It will only be emitted to connections that did actively request a push button authentication, but also it will be emitted regardless of the notification settings. ",
            "params": {
                "o:token": "String",
                "success": "Bool",
                "transactionId": "Int"
            }
        },
        "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"
            }
        },
        "System.CapabilitiesChanged": {
            "description": "Emitted whenever the system capabilities change.",
            "params": {
                "powerManagement": "Bool",
                "updateManagement": "Bool"
            }
        },
        "System.PackageAdded": {
            "description": "Emitted whenever a package is added to the list of packages.",
            "params": {
                "package": "$ref:Package"
            }
        },
        "System.PackageChanged": {
            "description": "Emitted whenever a package in the list of packages changes.",
            "params": {
                "package": "$ref:Package"
            }
        },
        "System.PackageRemoved": {
            "description": "Emitted whenever a package is removed from the list of packages.",
            "params": {
                "packageId": "String"
            }
        },
        "System.RepositoryAdded": {
            "description": "Emitted whenever a repository is added to the list of repositories.",
            "params": {
                "repository": "$ref:Repository"
            }
        },
        "System.RepositoryChanged": {
            "description": "Emitted whenever a repository in the list of repositories changes.",
            "params": {
                "repository": "$ref:Repository"
            }
        },
        "System.RepositoryRemoved": {
            "description": "Emitted whenever a repository is removed from the list of repositories.",
            "params": {
                "repositoryId": "String"
            }
        },
        "System.UpdateStatusChanged": {
            "description": "Emitted whenever the update status changes.",
            "params": {
                "busy": "Bool",
                "updateRunning": "Bool"
            }
        },
        "Tags.TagAdded": {
            "description": "Emitted whenever a tag is added to the system. ",
            "params": {
                "tag": "$ref:Tag"
            }
        },
        "Tags.TagRemoved": {
            "description": "Emitted whenever a tag is removed from the system. ",
            "params": {
                "tag": "$ref:Tag"
            }
        },
        "Tags.TagValueChanged": {
            "description": "Emitted whenever a tag's value is changed in the system. ",
            "params": {
                "tag": "$ref:Tag"
            }
        }
    },
    "types": {
        "Action": {
            "actionTypeId": "Uuid",
            "deviceId": "Uuid",
            "o:params": [
                "$ref:Param"
            ]
        },
        "ActionType": {
            "displayName": "String",
            "id": "Uuid",
            "index": "Int",
            "name": "String",
            "paramTypes": [
                "$ref:ParamType"
            ]
        },
        "BasicType": [
            "Uuid",
            "String",
            "StringList",
            "Int",
            "Uint",
            "Double",
            "Bool",
            "Variant",
            "Color",
            "Time",
            "Object"
        ],
        "BrowserIcon": [
            "BrowserIconNone",
            "BrowserIconFolder",
            "BrowserIconFile",
            "BrowserIconMusic",
            "BrowserIconVideo",
            "BrowserIconPictures",
            "BrowserIconApplication",
            "BrowserIconDocument",
            "BrowserIconPackage",
            "BrowserIconFavorites"
        ],
        "BrowserItem": {
            "actionTypeIds": [
                "Uuid"
            ],
            "browsable": "Bool",
            "description": "String",
            "disabled": "Bool",
            "displayName": "String",
            "executable": "Bool",
            "icon": "$ref:BrowserIcon",
            "id": "String",
            "o:mediaIcon": "$ref:MediaBrowserIcon",
            "thumbnail": "String"
        },
        "CalendarItem": {
            "duration": "Uint",
            "o:datetime": "Uint",
            "o:repeating": "$ref:RepeatingOption",
            "o:startTime": "Time"
        },
        "CloudConnectionState": [
            "CloudConnectionStateDisabled",
            "CloudConnectionStateUnconfigured",
            "CloudConnectionStateConnecting",
            "CloudConnectionStateConnected"
        ],
        "ConfigurationError": [
            "ConfigurationErrorNoError",
            "ConfigurationErrorInvalidTimeZone",
            "ConfigurationErrorInvalidStationName",
            "ConfigurationErrorInvalidId",
            "ConfigurationErrorInvalidPort",
            "ConfigurationErrorInvalidHostAddress",
            "ConfigurationErrorBluetoothHardwareNotAvailable",
            "ConfigurationErrorInvalidCertificate"
        ],
        "CreateMethod": [
            "CreateMethodUser",
            "CreateMethodAuto",
            "CreateMethodDiscovery"
        ],
        "Device": {
            "deviceClassId": "Uuid",
            "id": "Uuid",
            "name": "String",
            "o:parentId": "Uuid",
            "params": [
                "$ref:Param"
            ],
            "settings": [
                "$ref:Param"
            ],
            "setupComplete": "Bool",
            "states": [
                {
                    "stateTypeId": "Uuid",
                    "value": "Variant"
                }
            ]
        },
        "DeviceClass": {
            "actionTypes": [
                "$ref:ActionType"
            ],
            "browsable": "Bool",
            "browserItemActionTypes": [
                "$ref:ActionType"
            ],
            "createMethods": [
                "$ref:CreateMethod"
            ],
            "discoveryParamTypes": [
                "$ref:ParamType"
            ],
            "displayName": "String",
            "eventTypes": [
                "$ref:EventType"
            ],
            "id": "Uuid",
            "interfaces": [
                "String"
            ],
            "name": "String",
            "paramTypes": [
                "$ref:ParamType"
            ],
            "pluginId": "Uuid",
            "settingsTypes": [
                "$ref:ParamType"
            ],
            "setupMethod": "$ref:SetupMethod",
            "stateTypes": [
                "$ref:StateType"
            ],
            "vendorId": "Uuid"
        },
        "DeviceDescriptor": {
            "description": "String",
            "deviceId": "Uuid",
            "deviceParams": [
                "$ref:Param"
            ],
            "id": "Uuid",
            "title": "String"
        },
        "DeviceError": [
            "DeviceErrorNoError",
            "DeviceErrorPluginNotFound",
            "DeviceErrorVendorNotFound",
            "DeviceErrorDeviceNotFound",
            "DeviceErrorDeviceClassNotFound",
            "DeviceErrorActionTypeNotFound",
            "DeviceErrorStateTypeNotFound",
            "DeviceErrorEventTypeNotFound",
            "DeviceErrorDeviceDescriptorNotFound",
            "DeviceErrorMissingParameter",
            "DeviceErrorInvalidParameter",
            "DeviceErrorSetupFailed",
            "DeviceErrorDuplicateUuid",
            "DeviceErrorCreationMethodNotSupported",
            "DeviceErrorSetupMethodNotSupported",
            "DeviceErrorHardwareNotAvailable",
            "DeviceErrorHardwareFailure",
            "DeviceErrorAuthenticationFailure",
            "DeviceErrorDeviceInUse",
            "DeviceErrorDeviceInRule",
            "DeviceErrorDeviceIsChild",
            "DeviceErrorPairingTransactionIdNotFound",
            "DeviceErrorParameterNotWritable",
            "DeviceErrorItemNotFound",
            "DeviceErrorItemNotExecutable",
            "DeviceErrorUnsupportedFeature",
            "DeviceErrorTimeout"
        ],
        "Event": {
            "deviceId": "Uuid",
            "eventTypeId": "Uuid",
            "o:params": [
                "$ref:Param"
            ]
        },
        "EventDescriptor": {
            "o:deviceId": "Uuid",
            "o:eventTypeId": "Uuid",
            "o:interface": "String",
            "o:interfaceEvent": "String",
            "o:paramDescriptors": [
                "$ref:ParamDescriptor"
            ]
        },
        "EventType": {
            "displayName": "String",
            "id": "Uuid",
            "index": "Int",
            "name": "String",
            "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:itemId": "String",
            "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",
            "LoggingSourceBrowserActions"
        ],
        "MediaBrowserIcon": [
            "MediaBrowserIconNone",
            "MediaBrowserIconPlaylist",
            "MediaBrowserIconRecentlyPlayed",
            "MediaBrowserIconLibrary",
            "MediaBrowserIconMusicLibrary",
            "MediaBrowserIconVideoLibrary",
            "MediaBrowserIconPictureLibrary",
            "MediaBrowserIconDisk",
            "MediaBrowserIconUSB",
            "MediaBrowserIconNetwork",
            "MediaBrowserIconAux",
            "MediaBrowserIconSpotify",
            "MediaBrowserIconAmazon",
            "MediaBrowserIconTuneIn",
            "MediaBrowserIconSiriusXM",
            "MediaBrowserIconVTuner",
            "MediaBrowserIconTidal",
            "MediaBrowserIconAirable",
            "MediaBrowserIconDeezer",
            "MediaBrowserIconNapster",
            "MediaBrowserIconSoundCloud"
        ],
        "MqttPolicy": {
            "allowedPublishTopicFilters": "StringList",
            "allowedSubscribeTopicFilters": "StringList",
            "clientId": "String",
            "password": "String",
            "username": "String"
        },
        "Namespace": [
            "Actions",
            "Configuration",
            "Devices",
            "Events",
            "JSONRPC",
            "Logging",
            "NetworkManager",
            "Rules",
            "States",
            "System",
            "Tags"
        ],
        "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"
        ],
        "Package": {
            "canRemove": "Bool",
            "candidateVersion": "String",
            "changelog": "String",
            "displayName": "String",
            "id": "String",
            "installedVersion": "String",
            "rollbackAvailable": "Bool",
            "summary": "String",
            "updateAvailable": "Bool"
        },
        "Param": {
            "paramTypeId": "Uuid",
            "value": "$ref:BasicType"
        },
        "ParamDescriptor": {
            "o:paramName": "Uuid",
            "o:paramTypeId": "Uuid",
            "operator": "$ref:ValueOperator",
            "value": "$ref:BasicType"
        },
        "ParamType": {
            "displayName": "String",
            "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": {
            "displayName": "String",
            "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"
            ]
        },
        "Repository": {
            "displayName": "String",
            "enabled": "Bool",
            "id": "String"
        },
        "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": {
            "o:actionTypeId": "Uuid",
            "o:browserItemId": "String",
            "o:deviceId": "Uuid",
            "o:interface": "String",
            "o:interfaceAction": "String",
            "o:ruleActionParams": [
                "$ref:RuleActionParam"
            ]
        },
        "RuleActionParam": {
            "o:eventParamTypeId": "Uuid",
            "o:eventTypeId": "Uuid",
            "o:paramName": "String",
            "o:paramTypeId": "Uuid",
            "o:stateDeviceId": "Uuid",
            "o:stateTypeId": "Uuid",
            "o:value": "$ref:BasicType"
        },
        "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",
            "RuleErrorInterfaceNotFound"
        ],
        "ServerConfiguration": {
            "address": "String",
            "authenticationEnabled": "Bool",
            "id": "String",
            "port": "Uint",
            "sslEnabled": "Bool"
        },
        "SetupMethod": [
            "SetupMethodJustAdd",
            "SetupMethodDisplayPin",
            "SetupMethodEnterPin",
            "SetupMethodPushButton",
            "SetupMethodUserAndPassword",
            "SetupMethodOAuth"
        ],
        "State": {
            "deviceId": "Uuid",
            "stateTypeId": "Uuid",
            "value": "Variant"
        },
        "StateDescriptor": {
            "o:deviceId": "Uuid",
            "o:interface": "String",
            "o:interfaceState": "String",
            "o:stateTypeId": "Uuid",
            "operator": "$ref:ValueOperator",
            "value": "Variant"
        },
        "StateEvaluator": {
            "o:childEvaluators": [
                "$ref:StateEvaluator"
            ],
            "o:operator": "$ref:StateOperator",
            "o:stateDescriptor": "$ref:StateDescriptor"
        },
        "StateOperator": [
            "StateOperatorAnd",
            "StateOperatorOr"
        ],
        "StateType": {
            "defaultValue": "Variant",
            "displayName": "String",
            "id": "Uuid",
            "index": "Int",
            "name": "String",
            "o:maxValue": "Variant",
            "o:minValue": "Variant",
            "o:possibleValues": [
                "Variant"
            ],
            "o:unit": "$ref:Unit",
            "type": "$ref:BasicType"
        },
        "Tag": {
            "appId": "String",
            "o:deviceId": "Uuid",
            "o:ruleId": "Uuid",
            "o:value": "String",
            "tagId": "String"
        },
        "TagError": [
            "TagErrorNoError",
            "TagErrorDeviceNotFound",
            "TagErrorRuleNotFound",
            "TagErrorTagNotFound"
        ],
        "TimeDescriptor": {
            "o:calendarItems": [
                "$ref:CalendarItem"
            ],
            "o:timeEventItems": [
                "$ref:TimeEventItem"
            ]
        },
        "TimeEventItem": {
            "o:datetime": "Uint",
            "o:repeating": "$ref:RepeatingOption",
            "o:time": "Time"
        },
        "TokenInfo": {
            "creationTime": "Uint",
            "deviceName": "String",
            "id": "Uuid",
            "userName": "String"
        },
        "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",
            "UnitHertz",
            "UnitAmpere",
            "UnitMilliAmpere",
            "UnitVolt",
            "UnitMilliVolt",
            "UnitVoltAmpere",
            "UnitVoltAmpereReactive",
            "UnitAmpereHour",
            "UnitMicroSiemensPerCentimeter",
            "UnitDuration"
        ],
        "UserError": [
            "UserErrorNoError",
            "UserErrorBackendError",
            "UserErrorInvalidUserId",
            "UserErrorDuplicateUserId",
            "UserErrorBadPassword",
            "UserErrorTokenNotFound",
            "UserErrorPermissionDenied"
        ],
        "ValueOperator": [
            "ValueOperatorEquals",
            "ValueOperatorNotEquals",
            "ValueOperatorLess",
            "ValueOperatorGreater",
            "ValueOperatorLessOrEqual",
            "ValueOperatorGreaterOrEqual"
        ],
        "Vendor": {
            "displayName": "String",
            "id": "Uuid",
            "name": "String"
        },
        "WebServerConfiguration": {
            "address": "String",
            "authenticationEnabled": "Bool",
            "id": "String",
            "port": "Uint",
            "sslEnabled": "Bool"
        },
        "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"
        }
    }
}

*/