• JSON-RPC API
  • JSON-RPC API

    Communicating 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 server will send immediately a handshake message. The handshake message is a JSON object and contains all relevant information about the server and the API in order to start communicationg with the server.

    Here is an example of a handshake:

    {
        "id": 0,
        "name": "My nymea",
        "protocol version": "1.2",
        "authenticationRequired": false,
        "initialSetupRequired": false,
        "pushButtonAuthAvailable": false,
        "server": "nymea",
        "language": "de_DE",
        "uuid": "{42842b0f-a7bb-4a94-b624-a55f31c5603e}",
        "version": "0.8.3"
    }
    idintegerThe id in the handshake has always the value 0. This is the first message during connection.
    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.
    languagestringThis property holds the language of the server. The language can be changed in the settings using Configuration.SetLanguage.
    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.

    Sending a request

    Once connected to the socket and received the handshake, the 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.

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

    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.Hello method has no parameters, so we don't need to add that property to our request.

    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":{"authenticationRequired":false,"id":0,"initialSetupRequired":false,"language":"de_DE","name":"My nymea","protocol version":"1.2","pushButtonAuthAvailable":false,"server":"nymea","uuid":"{42842b0f-a7bb-4a94-b624-a55f31c5603e}","version":"0.8.3"},"status":"success"}

    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 have to be enabled again on 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.

    Authentication

    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.

    API

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

    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

    BasicTag

    [
        "BasicTagService",
        "BasicTagDevice",
        "BasicTagSensor",
        "BasicTagActuator",
        "BasicTagLighting",
        "BasicTagEnergy",
        "BasicTagMultimedia",
        "BasicTagWeather",
        "BasicTagGateway",
        "BasicTagHeating",
        "BasicTagCooling",
        "BasicTagNotification",
        "BasicTagSecurity",
        "BasicTagTime",
        "BasicTagShading",
        "BasicTagAppliance",
        "BasicTagCamera",
        "BasicTagLock"
    ]

    BasicType

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

    CalendarItem

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

    See also: RepeatingOption

    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"
        ],
        "setupComplete": "Bool",
        "states": [
            {
                "stateTypeId": "Uuid",
                "value": "Variant"
            }
        ]
    }

    See also: Param

    DeviceClass

    {
        "actionTypes": [
            "$ref:ActionType"
        ],
        "basicTags": [
            "$ref:BasicTag"
        ],
        "createMethods": [
            "$ref:CreateMethod"
        ],
        "deviceIcon": "$ref:DeviceIcon",
        "discoveryParamTypes": [
            "$ref:ParamType"
        ],
        "displayName": "String",
        "eventTypes": [
            "$ref:EventType"
        ],
        "id": "Uuid",
        "interfaces": [
            "String"
        ],
        "name": "String",
        "o:criticalStateTypeId": "Uuid",
        "o:primaryActionTypeId": "Uuid",
        "o:primaryStateTypeId": "Uuid",
        "paramTypes": [
            "$ref:ParamType"
        ],
        "pluginId": "Uuid",
        "setupMethod": "$ref:SetupMethod",
        "stateTypes": [
            "$ref:StateType"
        ],
        "vendorId": "Uuid"
    }

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

    DeviceDescriptor

    {
        "description": "String",
        "id": "Uuid",
        "title": "String"
    }

    DeviceError

    [
        "DeviceErrorNoError",
        "DeviceErrorPluginNotFound",
        "DeviceErrorVendorNotFound",
        "DeviceErrorDeviceNotFound",
        "DeviceErrorDeviceClassNotFound",
        "DeviceErrorActionTypeNotFound",
        "DeviceErrorStateTypeNotFound",
        "DeviceErrorEventTypeNotFound",
        "DeviceErrorDeviceDescriptorNotFound",
        "DeviceErrorMissingParameter",
        "DeviceErrorInvalidParameter",
        "DeviceErrorSetupFailed",
        "DeviceErrorDuplicateUuid",
        "DeviceErrorCreationMethodNotSupported",
        "DeviceErrorSetupMethodNotSupported",
        "DeviceErrorHardwareNotAvailable",
        "DeviceErrorHardwareFailure",
        "DeviceErrorAuthentificationFailure",
        "DeviceErrorAsync",
        "DeviceErrorDeviceInUse",
        "DeviceErrorDeviceInRule",
        "DeviceErrorDeviceIsChild",
        "DeviceErrorPairingTransactionIdNotFound",
        "DeviceErrorParameterNotWritable"
    ]

    DeviceIcon

    [
        "DeviceIconNone",
        "DeviceIconBed",
        "DeviceIconBlinds",
        "DeviceIconCeilingLamp",
        "DeviceIconCouch",
        "DeviceIconDeskLamp",
        "DeviceIconDesk",
        "DeviceIconHifi",
        "DeviceIconPower",
        "DeviceIconEnergy",
        "DeviceIconRadio",
        "DeviceIconSmartPhone",
        "DeviceIconSocket",
        "DeviceIconStandardLamp",
        "DeviceIconSun",
        "DeviceIconTablet",
        "DeviceIconThermometer",
        "DeviceIconTune",
        "DeviceIconTv",
        "DeviceIconBattery",
        "DeviceIconDishwasher",
        "DeviceIconWashingMachine",
        "DeviceIconLaundryDryer",
        "DeviceIconIrHeater",
        "DeviceIconRadiator",
        "DeviceIconSwitch",
        "DeviceIconMotionDetectors",
        "DeviceIconWeather",
        "DeviceIconTime",
        "DeviceIconLightBulb",
        "DeviceIconGateway",
        "DeviceIconMail",
        "DeviceIconNetwork",
        "DeviceIconCloud",
        "DeviceIconGarage",
        "DeviceIconRollerShutter"
    ]

    Event

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

    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",
        "o:graphRelevant": "Bool",
        "o:ruleRelevant": "Bool",
        "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: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"
    ]

    NetworkDeviceState

    [
        "NetworkDeviceStateUnknown",
        "NetworkDeviceStateUnmanaged",
        "NetworkDeviceStateUnavailable",
        "NetworkDeviceStateDisconnected",
        "NetworkDeviceStatePrepare",
        "NetworkDeviceStateConfig",
        "NetworkDeviceStateNeedAuth",
        "NetworkDeviceStateIpConfig",
        "NetworkDeviceStateIpCheck",
        "NetworkDeviceStateSecondaries",
        "NetworkDeviceStateActivated",
        "NetworkDeviceStateDeactivating",
        "NetworkDeviceStateFailed"
    ]

    NetworkManagerError

    [
        "NetworkManagerErrorNoError",
        "NetworkManagerErrorUnknownError",
        "NetworkManagerErrorWirelessNotAvailable",
        "NetworkManagerErrorAccessPointNotFound",
        "NetworkManagerErrorNetworkInterfaceNotFound",
        "NetworkManagerErrorInvalidNetworkDeviceType",
        "NetworkManagerErrorWirelessNetworkingDisabled",
        "NetworkManagerErrorWirelessConnectionFailed",
        "NetworkManagerErrorNetworkingDisabled",
        "NetworkManagerErrorNetworkManagerNotAvailable"
    ]

    NetworkManagerState

    [
        "NetworkManagerStateUnknown",
        "NetworkManagerStateAsleep",
        "NetworkManagerStateDisconnected",
        "NetworkManagerStateDisconnecting",
        "NetworkManagerStateConnecting",
        "NetworkManagerStateConnectedLocal",
        "NetworkManagerStateConnectedSite",
        "NetworkManagerStateConnectedGlobal"
    ]

    Param

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

    See also: BasicType

    ParamDescriptor

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

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

    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

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

    State

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

    StateDescriptor

    {
        "deviceId": "Uuid",
        "operator": "$ref:ValueOperator",
        "stateTypeId": "Uuid",
        "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:graphRelevant": "Bool",
        "o:maxValue": "Variant",
        "o:minValue": "Variant",
        "o:possibleValues": [
            "Variant"
        ],
        "o:ruleRelevant": "Bool",
        "o:unit": "$ref:Unit",
        "type": "$ref:BasicType"
    }

    See also: Unit, BasicType

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

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

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

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

    Sets the server language to the given language. See also: "GetAvailableLanguages"

    Params
    {
        "language": "String"
    }
    Returns
    {
        "configurationError": "$ref:ConfigurationError"
    }

    See also: ConfigurationError

    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. Use deviceDescriptorId or deviceParams, depending on the createMethod of the device class. CreateMethodJustAdd takes the parameters you want to have with that device. CreateMethodDiscovery requires the use of a deviceDescriptorId.

    Params
    {
        "deviceClassId": "Uuid",
        "name": "String",
        "o:deviceDescriptorId": "Uuid",
        "o:deviceParams": [
            "$ref:Param"
        ]
    }
    Returns
    {
        "deviceError": "$ref:DeviceError",
        "o:deviceId": "Uuid"
    }

    See also: DeviceError, Param

    Devices.ConfirmPairing

    Confirm an ongoing pairing. In case of SetupMethodEnterPin also provide the pin in the params.

    Params
    {
        "o:secret": "String",
        "pairingTransactionId": "Uuid"
    }
    Returns
    {
        "deviceError": "$ref:DeviceError",
        "o:deviceId": "Uuid"
    }

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

    Params
    {
        "deviceClassId": "Uuid",
        "o:discoveryParams": [
            "$ref:Param"
        ]
    }
    Returns
    {
        "deviceError": "$ref:DeviceError",
        "o:deviceDescriptors": [
            "$ref:DeviceDescriptor"
        ]
    }

    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. If success is true, the return values will contain a pairingTransactionId, a displayMessage and the setupMethod. Depending on the setupMethod you should either proceed with AddConfiguredDevice or PairDevice.

    Params
    {
        "deviceClassId": "Uuid",
        "name": "String",
        "o:deviceDescriptorId": "Uuid",
        "o:deviceParams": [
            "$ref:Param"
        ]
    }
    Returns
    {
        "deviceError": "$ref:DeviceError",
        "o:displayMessage": "String",
        "o:pairingTransactionId": "Uuid",
        "o:setupMethod": "$ref:SetupMethod"
    }

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

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

    Upon first connection, nymea will automatically send a welcome message containing information about the setup. If this message is lost for whatever reason (connections with multiple hops might drop this if nymea sends it too early), the exact same message can be retrieved multiple times by calling this Hello method. Note that the contents might change if the system changed its state in the meantime, e.g. initialSetupRequired might turn false if the initial setup has been performed in the meantime.

    Params
    {}
    Returns
    {
        "authenticationRequired": "Bool",
        "id": "Int",
        "initialSetupRequired": "Bool",
        "language": "String",
        "name": "String",
        "protocol version": "String",
        "pushButtonAuthAvailable": "Bool",
        "server": "String",
        "uuid": "Uuid",
        "version": "String"
    }

    JSONRPC.Introspect

    Introspect this API.

    Params
    {}
    Returns
    {
        "methods": "Object",
        "types": "Object"
    }

    JSONRPC.IsCloudConnected

    Check whether the cloud is currently connected.

    Params
    {}
    Returns
    {
        "connected": "Bool"
    }

    JSONRPC.KeepAlive

    Keep alive a remote connection. The sessionId is the MQTT topic which has been used to establish the session. It will return false if no ongoing session with the given ID can be found.

    Params
    {
        "sessionId": "String"
    }
    Returns
    {
        "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.

    Params
    {
        "enabled": "Bool"
    }
    Returns
    {
        "enabled": "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. Each list element of a given filter will be connected with OR to each other. Each of the given filters will be connected with AND to each other.

    Params
    {
        "o:deviceIds": [
            "Uuid"
        ],
        "o:eventTypes": [
            "$ref:LoggingEventType"
        ],
        "o:loggingLevels": [
            "$ref:LoggingLevel"
        ],
        "o:loggingSources": [
            "$ref:LoggingSource"
        ],
        "o:timeFilters": [
            {
                "o:endDate": "Int",
                "o:startDate": "Int"
            }
        ],
        "o:typeIds": [
            "Uuid"
        ],
        "o:values": [
            "Variant"
        ]
    }
    Returns
    {
        "loggingError": "$ref:LoggingError",
        "o:logEntries": [
            "$ref:LogEntry"
        ]
    }

    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.

    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

    Notifications

    Configuration.BasicConfigurationChanged

    Emitted whenever the basic configuration of this server changes.

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

    Configuration.CloudConfigurationChanged

    Emitted whenever the cloud configuration is changed.

    Params
    {
        "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.TcpServerConfigurationChanged

    Emitted whenever the TCP server configuration changes.

    Params
    {
        "host": "String",
        "port": "Uint"
    }

    Configuration.WebServerConfigurationChanged

    Emitted whenever the web server configuration changes.

    Params
    {
        "host": "String",
        "port": "Uint"
    }

    Configuration.WebSocketServerConfigurationChanged

    Emitted whenever the web socket server configuration changes.

    Params
    {
        "host": "String",
        "port": "Uint"
    }

    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 changed (by EditDevice or ReconfigureDevice).

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

    See also: Device

    Devices.DeviceRemoved

    Emitted whenever a Device was removed.

    Params
    {
        "deviceId": "Uuid"
    }

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

    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",
        "status": "$ref:UserError",
        "transactionId": "Int"
    }

    See also: UserError

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

    Full introspect

    {
        "methods": {
            "Actions.ExecuteAction": {
                "description": "Execute a single action.",
                "params": {
                    "actionTypeId": "Uuid",
                    "deviceId": "Uuid",
                    "o:params": [
                        "$ref:Param"
                    ]
                },
                "returns": {
                    "deviceError": "$ref:DeviceError"
                }
            },
            "Actions.GetActionType": {
                "description": "Get the ActionType for the given ActionTypeId",
                "params": {
                    "actionTypeId": "Uuid"
                },
                "returns": {
                    "deviceError": "$ref:DeviceError",
                    "o:actionType": {
                        "displayName": "String",
                        "id": "Uuid",
                        "index": "Int",
                        "name": "String",
                        "paramTypes": [
                            "$ref:ParamType"
                        ]
                    }
                }
            },
            "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": "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.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": "Sets the server language to the given language. See also: \"GetAvailableLanguages\"",
                "params": {
                    "language": "String"
                },
                "returns": {
                    "configurationError": "$ref:ConfigurationError"
                }
            },
            "Configuration.SetServerName": {
                "description": "Set the name of the server. Default is 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. Use deviceDescriptorId or deviceParams, depending on the createMethod of the device class. CreateMethodJustAdd takes the parameters you want to have with that device. CreateMethodDiscovery requires the use of a deviceDescriptorId.",
                "params": {
                    "deviceClassId": "Uuid",
                    "name": "String",
                    "o:deviceDescriptorId": "Uuid",
                    "o:deviceParams": [
                        "$ref:Param"
                    ]
                },
                "returns": {
                    "deviceError": "$ref:DeviceError",
                    "o:deviceId": "Uuid"
                }
            },
            "Devices.ConfirmPairing": {
                "description": "Confirm an ongoing pairing. In case of SetupMethodEnterPin also provide the pin in the params.",
                "params": {
                    "o:secret": "String",
                    "pairingTransactionId": "Uuid"
                },
                "returns": {
                    "deviceError": "$ref:DeviceError",
                    "o:deviceId": "Uuid"
                }
            },
            "Devices.EditDevice": {
                "description": "Edit the name of a device. This method does not change the configuration of the device.",
                "params": {
                    "deviceId": "Uuid",
                    "name": "String"
                },
                "returns": {
                    "deviceError": "$ref:DeviceError"
                }
            },
            "Devices.GetActionTypes": {
                "description": "Get action types for a specified deviceClassId.",
                "params": {
                    "deviceClassId": "Uuid"
                },
                "returns": {
                    "actionTypes": [
                        "$ref:ActionType"
                    ]
                }
            },
            "Devices.GetConfiguredDevices": {
                "description": "Returns a list of configured devices, optionally filtered by deviceId.",
                "params": {
                    "o:deviceId": "Uuid"
                },
                "returns": {
                    "devices": [
                        "$ref:Device"
                    ]
                }
            },
            "Devices.GetDiscoveredDevices": {
                "description": "Performs a device discovery and returns the results. This function may take a while to return.",
                "params": {
                    "deviceClassId": "Uuid",
                    "o:discoveryParams": [
                        "$ref:Param"
                    ]
                },
                "returns": {
                    "deviceError": "$ref:DeviceError",
                    "o:deviceDescriptors": [
                        "$ref:DeviceDescriptor"
                    ]
                }
            },
            "Devices.GetEventTypes": {
                "description": "Get event types for a specified deviceClassId.",
                "params": {
                    "deviceClassId": "Uuid"
                },
                "returns": {
                    "eventTypes": [
                        "$ref:EventType"
                    ]
                }
            },
            "Devices.GetPluginConfiguration": {
                "description": "Get a plugin's params.",
                "params": {
                    "pluginId": "Uuid"
                },
                "returns": {
                    "deviceError": "$ref:DeviceError",
                    "o:configuration": [
                        "$ref:Param"
                    ]
                }
            },
            "Devices.GetPlugins": {
                "description": "Returns a list of loaded plugins.",
                "params": {},
                "returns": {
                    "plugins": [
                        "$ref:Plugin"
                    ]
                }
            },
            "Devices.GetStateTypes": {
                "description": "Get state types for a specified deviceClassId.",
                "params": {
                    "deviceClassId": "Uuid"
                },
                "returns": {
                    "stateTypes": [
                        "$ref:StateType"
                    ]
                }
            },
            "Devices.GetStateValue": {
                "description": "Get the value of the given device and the given stateType",
                "params": {
                    "deviceId": "Uuid",
                    "stateTypeId": "Uuid"
                },
                "returns": {
                    "deviceError": "$ref:DeviceError",
                    "o:value": "Variant"
                }
            },
            "Devices.GetStateValues": {
                "description": "Get all the state values of the given device.",
                "params": {
                    "deviceId": "Uuid"
                },
                "returns": {
                    "deviceError": "$ref:DeviceError",
                    "o:values": [
                        {
                            "stateTypeId": "Uuid",
                            "value": "Variant"
                        }
                    ]
                }
            },
            "Devices.GetSupportedDevices": {
                "description": "Returns a list of supported Device classes, optionally filtered by vendorId.",
                "params": {
                    "o:vendorId": "Uuid"
                },
                "returns": {
                    "deviceClasses": [
                        "$ref:DeviceClass"
                    ]
                }
            },
            "Devices.GetSupportedVendors": {
                "description": "Returns a list of supported Vendors.",
                "params": {},
                "returns": {
                    "vendors": [
                        "$ref:Vendor"
                    ]
                }
            },
            "Devices.PairDevice": {
                "description": "Pair a device. Use this for DeviceClasses with a setupMethod different than SetupMethodJustAdd. Use deviceDescriptorId or deviceParams, depending on the createMethod of the device class. CreateMethodJustAdd takes the parameters you want to have with that device. CreateMethodDiscovery requires the use of a deviceDescriptorId. If success is true, the return values will contain a pairingTransactionId, a displayMessage and the setupMethod. Depending on the setupMethod you should either proceed with AddConfiguredDevice or PairDevice.",
                "params": {
                    "deviceClassId": "Uuid",
                    "name": "String",
                    "o:deviceDescriptorId": "Uuid",
                    "o:deviceParams": [
                        "$ref:Param"
                    ]
                },
                "returns": {
                    "deviceError": "$ref:DeviceError",
                    "o:displayMessage": "String",
                    "o:pairingTransactionId": "Uuid",
                    "o:setupMethod": "$ref:SetupMethod"
                }
            },
            "Devices.ReconfigureDevice": {
                "description": "Edit the parameter configuration of the device. The device params will be set to the passed parameters and the setup device will be called. If the device is discoverable, you can perform a GetDiscoveredDevices before calling this method and pass the new DeviceDescriptor (rediscover). Only writable parameters can be changed. By default, every Param is writable.",
                "params": {
                    "deviceId": "Uuid",
                    "o:deviceDescriptorId": "Uuid",
                    "o:deviceParams": [
                        "$ref:Param"
                    ]
                },
                "returns": {
                    "deviceError": "$ref:DeviceError"
                }
            },
            "Devices.RemoveConfiguredDevice": {
                "description": "Remove a device from the system.",
                "params": {
                    "deviceId": "Uuid",
                    "o:removePolicy": "$ref:RemovePolicy",
                    "o:removePolicyList": [
                        {
                            "policy": "$ref:RemovePolicy",
                            "ruleId": "Uuid"
                        }
                    ]
                },
                "returns": {
                    "deviceError": "$ref:DeviceError",
                    "o:ruleIds": [
                        "Uuid"
                    ]
                }
            },
            "Devices.SetPluginConfiguration": {
                "description": "Set a plugin's params.",
                "params": {
                    "configuration": [
                        "$ref:Param"
                    ],
                    "pluginId": "Uuid"
                },
                "returns": {
                    "deviceError": "$ref:DeviceError"
                }
            },
            "Events.GetEventType": {
                "description": "Get the EventType for the given eventTypeId.",
                "params": {
                    "eventTypeId": "Uuid"
                },
                "returns": {
                    "deviceError": "$ref:DeviceError",
                    "o:eventType": "$ref:EventType"
                }
            },
            "JSONRPC.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": "Upon first connection, nymea will automatically send a welcome message containing information about the setup. If this message is lost for whatever reason (connections with multiple hops might drop this if nymea sends it too early), the exact same message can be retrieved multiple times by calling this Hello method. Note that the contents might change if the system changed its state in the meantime, e.g. initialSetupRequired might turn false if the initial setup has been performed in the meantime.",
                "params": {},
                "returns": {
                    "authenticationRequired": "Bool",
                    "id": "Int",
                    "initialSetupRequired": "Bool",
                    "language": "String",
                    "name": "String",
                    "protocol version": "String",
                    "pushButtonAuthAvailable": "Bool",
                    "server": "String",
                    "uuid": "Uuid",
                    "version": "String"
                }
            },
            "JSONRPC.Introspect": {
                "description": "Introspect this API.",
                "params": {},
                "returns": {
                    "methods": "Object",
                    "types": "Object"
                }
            },
            "JSONRPC.IsCloudConnected": {
                "description": "Check whether the cloud is currently connected.",
                "params": {},
                "returns": {
                    "connected": "Bool"
                }
            },
            "JSONRPC.KeepAlive": {
                "description": "Keep alive a remote connection. The sessionId is the MQTT topic which has been used to establish the session. It will return false if no ongoing session with the given ID can be found.",
                "params": {
                    "sessionId": "String"
                },
                "returns": {
                    "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.",
                "params": {
                    "enabled": "Bool"
                },
                "returns": {
                    "enabled": "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. Each list element of a given filter will be connected with OR to each other. Each of the given filters will be connected with AND to each other.",
                "params": {
                    "o:deviceIds": [
                        "Uuid"
                    ],
                    "o:eventTypes": [
                        "$ref:LoggingEventType"
                    ],
                    "o:loggingLevels": [
                        "$ref:LoggingLevel"
                    ],
                    "o:loggingSources": [
                        "$ref:LoggingSource"
                    ],
                    "o:timeFilters": [
                        {
                            "o:endDate": "Int",
                            "o:startDate": "Int"
                        }
                    ],
                    "o:typeIds": [
                        "Uuid"
                    ],
                    "o:values": [
                        "Variant"
                    ]
                },
                "returns": {
                    "loggingError": "$ref:LoggingError",
                    "o:logEntries": [
                        "$ref:LogEntry"
                    ]
                }
            },
            "NetworkManager.ConnectWifiNetwork": {
                "description": "Connect to the wifi network with the given ssid and password.",
                "params": {
                    "interface": "String",
                    "o:password": "String",
                    "ssid": "String"
                },
                "returns": {
                    "networkManagerError": "$ref:NetworkManagerError"
                }
            },
            "NetworkManager.DisconnectInterface": {
                "description": "Disconnect the given network interface. The interface will remain disconnected until the user connect it again.",
                "params": {
                    "interface": "String"
                },
                "returns": {
                    "networkManagerError": "$ref:NetworkManagerError"
                }
            },
            "NetworkManager.EnableNetworking": {
                "description": "Enable or disable networking in the NetworkManager.",
                "params": {
                    "enable": "Bool"
                },
                "returns": {
                    "networkManagerError": "$ref:NetworkManagerError"
                }
            },
            "NetworkManager.EnableWirelessNetworking": {
                "description": "Enable or disable wireless networking in the NetworkManager.",
                "params": {
                    "enable": "Bool"
                },
                "returns": {
                    "networkManagerError": "$ref:NetworkManagerError"
                }
            },
            "NetworkManager.GetNetworkDevices": {
                "description": "Get the list of current network devices.",
                "params": {},
                "returns": {
                    "networkManagerError": "$ref:NetworkManagerError",
                    "wiredNetworkDevices": [
                        "$ref:WiredNetworkDevice"
                    ],
                    "wirelessNetworkDevices": [
                        "$ref:WirelessNetworkDevice"
                    ]
                }
            },
            "NetworkManager.GetNetworkStatus": {
                "description": "Get the current network manager status.",
                "params": {},
                "returns": {
                    "networkManagerError": "$ref:NetworkManagerError",
                    "o:status": {
                        "networkingEnabled": "Bool",
                        "state": "$ref:NetworkManagerState",
                        "wirelessNetworkingEnabled": "Bool"
                    }
                }
            },
            "NetworkManager.GetWirelessAccessPoints": {
                "description": "Get the current list of wireless network access points for the given interface. The interface has to be a WirelessNetworkDevice.",
                "params": {
                    "interface": "String"
                },
                "returns": {
                    "networkManagerError": "$ref:NetworkManagerError",
                    "o:wirelessAccessPoints": [
                        "$ref:WirelessAccessPoint"
                    ]
                }
            },
            "NetworkManager.ScanWifiNetworks": {
                "description": "Start a wifi scan for searching new networks.",
                "params": {
                    "interface": "String"
                },
                "returns": {
                    "networkManagerError": "$ref:NetworkManagerError"
                }
            },
            "Rules.AddRule": {
                "description": "Add a rule. You can describe rules by one or many EventDesciptors and a StateEvaluator. Note that only one of either eventDescriptor or eventDescriptorList may be passed at a time. A rule can be created but left disabled, meaning it won't actually be executed until set to enabled. If not given, enabled defaults to true.",
                "params": {
                    "actions": [
                        "$ref:RuleAction"
                    ],
                    "name": "String",
                    "o:enabled": "Bool",
                    "o:eventDescriptors": [
                        "$ref:EventDescriptor"
                    ],
                    "o:executable": "Bool",
                    "o:exitActions": [
                        "$ref:RuleAction"
                    ],
                    "o:stateEvaluator": "$ref:StateEvaluator",
                    "o:timeDescriptor": "$ref:TimeDescriptor"
                },
                "returns": {
                    "o:ruleId": "Uuid",
                    "ruleError": "$ref:RuleError"
                }
            },
            "Rules.DisableRule": {
                "description": "Disable a rule. The rule won't be triggered by it's events or state changes while it is disabled. If 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"
                }
            }
        },
        "notifications": {
            "Configuration.BasicConfigurationChanged": {
                "description": "Emitted whenever the basic configuration of this server changes.",
                "params": {
                    "debugServerEnabled": "Bool",
                    "serverName": "String",
                    "serverTime": "Uint",
                    "serverUuid": "Uuid",
                    "timeZone": "String"
                }
            },
            "Configuration.CloudConfigurationChanged": {
                "description": "Emitted whenever the cloud configuration is changed.",
                "params": {
                    "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.TcpServerConfigurationChanged": {
                "description": "Emitted whenever the TCP server configuration changes.",
                "params": {
                    "host": "String",
                    "port": "Uint"
                }
            },
            "Configuration.WebServerConfigurationChanged": {
                "description": "Emitted whenever the web server configuration changes.",
                "params": {
                    "host": "String",
                    "port": "Uint"
                }
            },
            "Configuration.WebSocketServerConfigurationChanged": {
                "description": "Emitted whenever the web socket server configuration changes.",
                "params": {
                    "host": "String",
                    "port": "Uint"
                }
            },
            "Devices.DeviceAdded": {
                "description": "Emitted whenever a Device was added.",
                "params": {
                    "device": "$ref:Device"
                }
            },
            "Devices.DeviceChanged": {
                "description": "Emitted whenever the params or name of a Device changed (by EditDevice or ReconfigureDevice).",
                "params": {
                    "device": "$ref:Device"
                }
            },
            "Devices.DeviceRemoved": {
                "description": "Emitted whenever a Device was removed.",
                "params": {
                    "deviceId": "Uuid"
                }
            },
            "Devices.StateChanged": {
                "description": "Emitted whenever a State of a device changes.",
                "params": {
                    "deviceId": "Uuid",
                    "stateTypeId": "Uuid",
                    "value": "Variant"
                }
            },
            "Events.EventTriggered": {
                "description": "Emitted whenever an Event is triggered.",
                "params": {
                    "event": "$ref:Event"
                }
            },
            "JSONRPC.CloudConnectedChanged": {
                "description": "Emitted whenever the cloud connection status changes.",
                "params": {
                    "connected": "Bool"
                }
            },
            "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",
                    "status": "$ref:UserError",
                    "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"
                }
            }
        },
        "types": {
            "Action": {
                "actionTypeId": "Uuid",
                "deviceId": "Uuid",
                "o:params": [
                    "$ref:Param"
                ]
            },
            "ActionType": {
                "displayName": "String",
                "id": "Uuid",
                "index": "Int",
                "name": "String",
                "paramTypes": [
                    "$ref:ParamType"
                ]
            },
            "BasicTag": [
                "BasicTagService",
                "BasicTagDevice",
                "BasicTagSensor",
                "BasicTagActuator",
                "BasicTagLighting",
                "BasicTagEnergy",
                "BasicTagMultimedia",
                "BasicTagWeather",
                "BasicTagGateway",
                "BasicTagHeating",
                "BasicTagCooling",
                "BasicTagNotification",
                "BasicTagSecurity",
                "BasicTagTime",
                "BasicTagShading",
                "BasicTagAppliance",
                "BasicTagCamera",
                "BasicTagLock"
            ],
            "BasicType": [
                "Uuid",
                "String",
                "Int",
                "Uint",
                "Double",
                "Bool",
                "Variant",
                "Color",
                "Time",
                "Object"
            ],
            "CalendarItem": {
                "duration": "Uint",
                "o:datetime": "Uint",
                "o:repeating": "$ref:RepeatingOption",
                "o:startTime": "Time"
            },
            "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"
                ],
                "setupComplete": "Bool",
                "states": [
                    {
                        "stateTypeId": "Uuid",
                        "value": "Variant"
                    }
                ]
            },
            "DeviceClass": {
                "actionTypes": [
                    "$ref:ActionType"
                ],
                "basicTags": [
                    "$ref:BasicTag"
                ],
                "createMethods": [
                    "$ref:CreateMethod"
                ],
                "deviceIcon": "$ref:DeviceIcon",
                "discoveryParamTypes": [
                    "$ref:ParamType"
                ],
                "displayName": "String",
                "eventTypes": [
                    "$ref:EventType"
                ],
                "id": "Uuid",
                "interfaces": [
                    "String"
                ],
                "name": "String",
                "o:criticalStateTypeId": "Uuid",
                "o:primaryActionTypeId": "Uuid",
                "o:primaryStateTypeId": "Uuid",
                "paramTypes": [
                    "$ref:ParamType"
                ],
                "pluginId": "Uuid",
                "setupMethod": "$ref:SetupMethod",
                "stateTypes": [
                    "$ref:StateType"
                ],
                "vendorId": "Uuid"
            },
            "DeviceDescriptor": {
                "description": "String",
                "id": "Uuid",
                "title": "String"
            },
            "DeviceError": [
                "DeviceErrorNoError",
                "DeviceErrorPluginNotFound",
                "DeviceErrorVendorNotFound",
                "DeviceErrorDeviceNotFound",
                "DeviceErrorDeviceClassNotFound",
                "DeviceErrorActionTypeNotFound",
                "DeviceErrorStateTypeNotFound",
                "DeviceErrorEventTypeNotFound",
                "DeviceErrorDeviceDescriptorNotFound",
                "DeviceErrorMissingParameter",
                "DeviceErrorInvalidParameter",
                "DeviceErrorSetupFailed",
                "DeviceErrorDuplicateUuid",
                "DeviceErrorCreationMethodNotSupported",
                "DeviceErrorSetupMethodNotSupported",
                "DeviceErrorHardwareNotAvailable",
                "DeviceErrorHardwareFailure",
                "DeviceErrorAuthentificationFailure",
                "DeviceErrorAsync",
                "DeviceErrorDeviceInUse",
                "DeviceErrorDeviceInRule",
                "DeviceErrorDeviceIsChild",
                "DeviceErrorPairingTransactionIdNotFound",
                "DeviceErrorParameterNotWritable"
            ],
            "DeviceIcon": [
                "DeviceIconNone",
                "DeviceIconBed",
                "DeviceIconBlinds",
                "DeviceIconCeilingLamp",
                "DeviceIconCouch",
                "DeviceIconDeskLamp",
                "DeviceIconDesk",
                "DeviceIconHifi",
                "DeviceIconPower",
                "DeviceIconEnergy",
                "DeviceIconRadio",
                "DeviceIconSmartPhone",
                "DeviceIconSocket",
                "DeviceIconStandardLamp",
                "DeviceIconSun",
                "DeviceIconTablet",
                "DeviceIconThermometer",
                "DeviceIconTune",
                "DeviceIconTv",
                "DeviceIconBattery",
                "DeviceIconDishwasher",
                "DeviceIconWashingMachine",
                "DeviceIconLaundryDryer",
                "DeviceIconIrHeater",
                "DeviceIconRadiator",
                "DeviceIconSwitch",
                "DeviceIconMotionDetectors",
                "DeviceIconWeather",
                "DeviceIconTime",
                "DeviceIconLightBulb",
                "DeviceIconGateway",
                "DeviceIconMail",
                "DeviceIconNetwork",
                "DeviceIconCloud",
                "DeviceIconGarage",
                "DeviceIconRollerShutter"
            ],
            "Event": {
                "deviceId": "Uuid",
                "eventTypeId": "Uuid",
                "o:params": [
                    "$ref:Param"
                ]
            },
            "EventDescriptor": {
                "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",
                "o:graphRelevant": "Bool",
                "o:ruleRelevant": "Bool",
                "paramTypes": [
                    "$ref:ParamType"
                ]
            },
            "InputType": [
                "InputTypeNone",
                "InputTypeTextLine",
                "InputTypeTextArea",
                "InputTypePassword",
                "InputTypeSearch",
                "InputTypeMail",
                "InputTypeIPv4Address",
                "InputTypeIPv6Address",
                "InputTypeUrl",
                "InputTypeMacAddress"
            ],
            "LogEntry": {
                "loggingLevel": "$ref:LoggingLevel",
                "o:active": "Bool",
                "o:deviceId": "Uuid",
                "o:errorCode": "String",
                "o:eventType": "$ref:LoggingEventType",
                "o:typeId": "Uuid",
                "o:value": "String",
                "source": "$ref:LoggingSource",
                "timestamp": "Int"
            },
            "LoggingError": [
                "LoggingErrorNoError",
                "LoggingErrorLogEntryNotFound",
                "LoggingErrorInvalidFilterParameter"
            ],
            "LoggingEventType": [
                "LoggingEventTypeTrigger",
                "LoggingEventTypeActiveChange",
                "LoggingEventTypeEnabledChange",
                "LoggingEventTypeActionsExecuted",
                "LoggingEventTypeExitActionsExecuted"
            ],
            "LoggingLevel": [
                "LoggingLevelInfo",
                "LoggingLevelAlert"
            ],
            "LoggingSource": [
                "LoggingSourceSystem",
                "LoggingSourceEvents",
                "LoggingSourceActions",
                "LoggingSourceStates",
                "LoggingSourceRules"
            ],
            "NetworkDeviceState": [
                "NetworkDeviceStateUnknown",
                "NetworkDeviceStateUnmanaged",
                "NetworkDeviceStateUnavailable",
                "NetworkDeviceStateDisconnected",
                "NetworkDeviceStatePrepare",
                "NetworkDeviceStateConfig",
                "NetworkDeviceStateNeedAuth",
                "NetworkDeviceStateIpConfig",
                "NetworkDeviceStateIpCheck",
                "NetworkDeviceStateSecondaries",
                "NetworkDeviceStateActivated",
                "NetworkDeviceStateDeactivating",
                "NetworkDeviceStateFailed"
            ],
            "NetworkManagerError": [
                "NetworkManagerErrorNoError",
                "NetworkManagerErrorUnknownError",
                "NetworkManagerErrorWirelessNotAvailable",
                "NetworkManagerErrorAccessPointNotFound",
                "NetworkManagerErrorNetworkInterfaceNotFound",
                "NetworkManagerErrorInvalidNetworkDeviceType",
                "NetworkManagerErrorWirelessNetworkingDisabled",
                "NetworkManagerErrorWirelessConnectionFailed",
                "NetworkManagerErrorNetworkingDisabled",
                "NetworkManagerErrorNetworkManagerNotAvailable"
            ],
            "NetworkManagerState": [
                "NetworkManagerStateUnknown",
                "NetworkManagerStateAsleep",
                "NetworkManagerStateDisconnected",
                "NetworkManagerStateDisconnecting",
                "NetworkManagerStateConnecting",
                "NetworkManagerStateConnectedLocal",
                "NetworkManagerStateConnectedSite",
                "NetworkManagerStateConnectedGlobal"
            ],
            "Param": {
                "paramTypeId": "Uuid",
                "value": "$ref:BasicType"
            },
            "ParamDescriptor": {
                "operator": "$ref:ValueOperator",
                "paramTypeId": "Uuid",
                "value": "$ref:BasicType"
            },
            "ParamType": {
                "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"
                ]
            },
            "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: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: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"
            ],
            "State": {
                "deviceId": "Uuid",
                "stateTypeId": "Uuid",
                "value": "Variant"
            },
            "StateDescriptor": {
                "deviceId": "Uuid",
                "operator": "$ref:ValueOperator",
                "stateTypeId": "Uuid",
                "value": "Variant"
            },
            "StateEvaluator": {
                "o:childEvaluators": [
                    "$ref:StateEvaluator"
                ],
                "o:operator": "$ref:StateOperator",
                "o:stateDescriptor": "$ref:StateDescriptor"
            },
            "StateOperator": [
                "StateOperatorAnd",
                "StateOperatorOr"
            ],
            "StateType": {
                "defaultValue": "Variant",
                "displayName": "String",
                "id": "Uuid",
                "index": "Int",
                "name": "String",
                "o:graphRelevant": "Bool",
                "o:maxValue": "Variant",
                "o:minValue": "Variant",
                "o:possibleValues": [
                    "Variant"
                ],
                "o:ruleRelevant": "Bool",
                "o:unit": "$ref:Unit",
                "type": "$ref:BasicType"
            },
            "TimeDescriptor": {
                "o:calendarItems": [
                    "$ref:CalendarItem"
                ],
                "o:timeEventItems": [
                    "$ref:TimeEventItem"
                ]
            },
            "TimeEventItem": {
                "o:datetime": "Uint",
                "o:repeating": "$ref:RepeatingOption",
                "o:time": "Time"
            },
            "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",
                "UnitHerz",
                "UnitAmpere",
                "UnitMilliAmpere",
                "UnitVolt",
                "UnitMilliVolt",
                "UnitVoltAmpere",
                "UnitVoltAmpereReactive",
                "UnitAmpereHour"
            ],
            "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"
            }
        }
    }