The discover() method

Starts the discovery process that will provide ThingDescriptions that match the optional argument filter of type ThingFilter. Returns an [Observable](https://github.com/tc39/proposal-observable) object that can be subscribed to and unsubscribed from. The handler function provided to the Observable during subscription will receive an argument of type USVString representing a ThingDescription.

          typedef DOMString DiscoveryMethod;
        

          dictionary ThingFilter {
            (DiscoveryMethod or DOMString) method = "any";
            USVString? url;
            USVString? query;
            ThingFragment? fragment;
          };
        

The discover(filter) method MUST run the following steps:

1. If invoking discover() is not allowed for the current scripting context for security reasons, throw SecurityError and terminate these steps.
2. Return an Observable obs and execute the next steps in parallel.
3. If obs.subscribe(handler, errorHandler, complete) is called, execute the following sub-steps:
   1. If the first argument handler is not defined or it is not a function, throw TypeError and terminate the algorithm. Otherwise configure handler to be invoked when a discovery hit happens.
   2. If the second argument errorHandler is defined, but it is not a function, throw TypeError and terminate these steps. Otherwise if defined, save it to be invoked in error conditions.
   3. If the third argument onComplete is defined, but it is not a function, throw TypeError and terminate these steps. Otherwise if defined, save it to be invoked when the discovery process finished for other reasons than having been canceled.
   4. If filter.query is defined, pass it as an opaque string to the underlying implementation to be matched against discovered items. The underlying implementation is responsible to parse it e.g. as a SPARQL or JSON query and match it against the Thing Descriptions found during the discovery process. If queries are not supported, implementations SHOULD throw a NotSupported error and terminate these steps.
   5. If filter.fragment is defined, and if it contains other properties than the ones defined in ThingFragment, throw TypeError and terminate these steps. Otherwise save the object for matching the discovered items against it.
   6. Request the underlying platform to start the discovery process, with the following parameters:
      • If filter.method is not defined or the value is "any", use the widest discovery method supported by the underlying platform.
      • Otherwise if filter.method is "local", use the local Thing Directory for discovery. Usually that defines Things deployed in the same device, or connected to the device in slave mode (e.g. sensors connected via Bluetooth or a serial connection).
      • Otherwise if filter.method is "directory", use the remote Thing Directory specified in filter.url.
      • Otherwise if filter.method is "multicast", use all the multicast discovery protocols supported by the underlying platform.
4. Whenever a new item td is discovered by the underlying platform, run the following sub-steps:
   1. If filter.query is defined, check if td is a match for the query. The matching algorithm is encapsulated by implementations. If that returns false, discard td and continue the discovery process.
   2. If filter.fragment is defined, for each property defined in it, check if that property exists in td and has the same value. If this is false in any checks, discard td and continue the discovery process.
   3. Otherwise if td has not been discarded in the previous steps, invoke the handler function with td as parameter.
5. Whenever an error occurs during the discovery process, and if errorHandler is defined, invoke it with an argument of type Error whose message property is set to UnknownError unless there was an error code provided by the Protocol Bindings, in which case set it to that value.
6. When the discovery process is finished, and if onComplete is defined, invoke it run the cancel discovery steps.
7. When the obs.unsubscribe() method is called, run the following cancel discovery steps:
   1. Request the underlying platform to stop the discovery process. If this returns an error, or if it is not possible, for instance when discovery is based on open ended multicast requests, the implementation SHOULD discard subsequent discovered items.
   2. Set obs.closed to false.

The fetch() method

Accepts an url argument of type USVString that represents a URL (e.g. "file://..." or "https://...") and returns a Promise that resolves with a ThingDescription (a serialized JSON-LD document of type USVString).

The fetch(url) method MUST run the following steps:

1. Return a Promise promise and execute the next steps in parallel.
2. If invoking fetch() is not allowed for the current scripting context for security reasons, reject promise with SecurityError and terminate these steps.
3. If the argument url is not a URL, reject promise with TypeError and terminate these steps.
4. Make a request to fetch the content of url as described by the Protocol Bindings and wait for the reply. Implementations encapsulate the fetching process and the accepted media types (such as application/td+json), as far as a valid Thing Description can be obtained as defined in [[!WOT-TD]]. Let td be the Thing Description string-serialized from the returned content, as specified in the Thing Description serialization.
5. If there was an error during the request, reject promise with an Error object error with error.message set to the error code seen by the Protocol Bindings and terminate these steps.
6. Otherwise resolve promise with td and terminate these steps.

The consume() method

Accepts an td argument of type ThingDescription and returns a ConsumedThing object instantiated based on parsing that description.

The consume(td) method must run the following steps:

1. If the argument td is not a string, throw a TypeError and terminate these steps.
2. Let stub be the result of running the TD parsing algorithm with td as argument. If that throws an error, re-throw the error and terminate these steps.
3. If stub does not have an own property that is defined in ThingFragment with a default value, add that property and value to stub.
4. Create a ConsumedThing object thing initialized from stub that implements Observable.
5. Add the read() and write() methods to the ThingProperty elements so that they make requests to access the remote Things and wait for the reply, as defined by the Protocol Bindings. Also, all ThingProperty elements SHOULD implement Observable, i.e. define a subscribe() method that should make request to observe the given Properties as defined by the Protocol Bindings.
6. Add the invoke() methods to the ThingAction elements so that they make requests to the remote Thing to invoke its actions, as defined by the Protocol Bindings.
7. Add the subscribe() method to all ThingEvent elements so that they make requests to subscribe to the events defined by the remote Thing, as defined by the Protocol Bindings.
8. Return thing.

The produce() method

Accepts a model argument of type ThingModel and returns an ExposedThing object.

The produce(model) method MUST run the following steps:

1. If invoking produce() is not allowed for the current scripting context for security reasons, throw SecurityError and terminate these steps.
2. If the argument model is a string, then run the TD parsing algorithm with model passed as parameter. If it throws an error, re-throw that error and terminate this algorithm. Otherwise let model be the returned value.
3. If model is not an object, throw TypeError and terminate these steps.
4. If model does not have an own property that is defined in ThingFragment with a default value, add that property and value to model.
5. Create an ExposedThing object thing initialized from model.
6. For each property of ExposedThing defined in ThingFragment, initialize the property based on the provided initial or default values provided to the local WoT Runtime implementation, for instance initialize:
   1. the id property to be the final unique identifier of the Thing,
   2. the security object of type SecurityScheme to represent the actual security scheme and its properties as set up by the implementation,
   3. the properties property to be an object with all properties being ThingProperty objects in which the read() and write() methods are provided to define local methods to get and set the Property values,
   4. the actions property to be an object with all properties being ThingAction objects in which the invoke() method is provided to define a local method to run the defined Actions,
   5. the events property to be an object with all properties being ExposedEvent objects in which the emit() method is provided to define a local way to trigger sending notifications to all subscribed clients,
   6. and initialize the other properties as initialized from model.
   7. Return thing.

   The TD parsing algorithm takes a string td as argument and runs the following steps:

   1. Parse td according to the WoT Thing Description in order to produce a JSON object json. Update thing with the properties and values defined in json.
   2. If there was an error during the parsing, throw that error and terminate these steps.
   3. Otherwise return json.

The register() method

Takes two mandatory arguments:

• directory denoting a Thing Directory, and
• thing denoting an ExposedThing object.

Generate the Thing Description as td, given the Properties, Actions and Events defined for this ExposedThing object. Then make a request to register td to the given WoT Thing Directory.

The unregister() method

Takes two mandatory arguments:

• directory denoting a Thing Directory, and
• thing denoting an ExposedThing object.

Makes a request to unregister the thing from the given WoT Thing Directory.

Examples

        let discoveryFilter = {
          method: "directory",
          url: "http://directory.wotservice.org"
        };
        let subscription = wot.discover(discoveryFilter).subscribe(
          td => {
            console.log("Found Thing " + td.name);
            // fetch the TD and create a ConsumedThing
            let thing = wot.consume(td);
          },
          error => { console.log("Discovery finished because an error: " + error.message); },
          () => { console.log("Discovery finished successfully");}
        );
        setTimeout( () => {
            subscription.unsubscribe();
            console.log("Discovery timeout");
          },
          5000);
      

        let subscription = wot.discover({ method: "local" }).subscribe(
          td => { console.log("Found local Thing " + td.name); },
          error => { console.log("Discovery error: " + error.message); },
          () => { console.log("Discovery finished successfully");}
        );
      

        let subscription = wot.discover({ method: "local" }).subscribe({
          td => { console.log("Found local Thing " + td.name); },
          error: err => { console.log("Discovery error: " + err.message); },
          complete: () => { console.log("Discovery finished successfully");}
        });
      

Examples

Below a ConsumedThing interface example is given.

        try {
          let subscription = wot.discover({ method: "local" }).subscribe(
            td => {
              let thing = wot.consume(td);
              console.log("Thing " + thing.name + " has been consumed.");
              let subscription = thing["temperature"].subscribe(function(value) {
                  console.log("Temperature: " + value);
                });
              thing.actions["startMeasurement"].invoke({ units: "Celsius" })
                .then(() => { console.log("Temperature measurement started."); })
                .catch(e => {
                   console.log("Error starting measurement.");
                   subscription.unsubscribe();
                 })
            },
            error => { console.log("Discovery error: " + error.message); },
            () => { console.log("Discovery finished successfully");}
          );
        } catch(error) {
          console.log("Error: " + error.message);
        };
      

The expose() method

Start serving external requests for the Thing, so that WoT Interactions using Properties, Actions and Events will be possible.

The expose() method MUST run the following steps:

1. Return a Promise promise and execute the next steps in parallel.
2. If invoking expose() is not allowed for the current scripting context for security reasons, reject promise with SecurityError and terminate these steps.
3. Make a request to the underlying platform to attach protocol handlers and start serving external requests for WoT Interactions (read, write and observe Properties, invoke Actions and manage Event subscriptions), based on the Protocol Bindings.
4. If there was an error during the request, reject promise with an Error object error with error.message set to the error code seen by the Protocol Bindings and terminate these steps.
5. Otherwise resolve promise with td and terminate these steps.

The destroy() method

Stop serving external requests for the Thing and destroy the object. Note that eventual unregistering should be done before invoking this method.

The destroy() method MUST run the following steps:

1. Return a Promise promise and execute the next steps in parallel.
2. If invoking destroy() is not allowed for the current scripting context for security reasons, reject promise with SecurityError and terminate these steps.
3. Make a request to the underlying platform to stop serving external requests for WoT Interactions, based on the Protocol Bindings.
4. If there was an error during the request, reject promise with an Error object error with error.message set to the error code seen by the Protocol Bindings and terminate these steps.
5. Otherwise resolve promise with td and terminate these steps.

The addProperty() method

Adds a Property with name defined by the name argument, the data schema provided by the property argument of type PropertyFragment, and optionally an initial value provided in the argument initValue whose type should match the one defined in the type property according to the value-matching algorithm. If initValue is not provided, it SHOULD be initialized as undefined. Implementations SHOULD update the Thing Description. Throws on error. Returns a reference to the same object for supporting chaining.

The removeProperty() method

Removes the Property specified by the name argument and updates the Thing Description. Throws on error. Returns a reference to the same object for supporting chaining.

The addAction() method

Adds to the actions property of a Thing object an Action with name defined by the name argument, defines input and output data format by the init argument of type ActionFragment, and adds the function provided in the action argument as a handler, then updates the Thing Description. Throws on error. Returns a reference to the same object for supporting chaining.

The provided action callback function will implement invoking an Action and SHOULD be called by implementations when a request for invoking the Action is received from the underlying platform. The callback will receive a parameters dictionary argument according to the definition in the init.input argument and will return a value of type defined by the init.output argument according to the value-matching algorithm.

There SHOULD be exactly one handler for any given Action. If no handler is initialized for any given Action, implementations SHOULD throw a TypeError.

The removeAction() method

Removes the Action specified by the name argument and updates the Thing Description. Throws on error. Returns a reference to the same object for supporting chaining.

The addEvent() method

Adds an event with name defined by the name argument and qualifiers and initialization value provided by the event argument of type EventFragmentto the Thing object and updates the Thing Description. Throws on error. Returns a reference to the same object for supporting chaining.

The removeEvent() method

Removes the event specified by the name argument and updates the Thing Description. Returns a reference to the same object for supporting chaining.

The PropertyReadHandler callback

A function that is called when an external request for reading a Property is received. It should return a Promise and resolves it with the value of the Property matching the name argument to the setPropertyReadHandler function, or rejects with an error if the property is not found or the value cannot be retrieved.

The PropertyWriteHandler callback

A function that is called when an external request for writing a Property is received. It is given the requested new value as argument and should return a Promise which is resolved when the value of the Property that matches the name argument has been updated with value, or rejects with an error if the property is not found or the value cannot be updated.

Note that this function is invoked by implementations before the property is updated and it actually defines what to do when a write request is received. The code in this callback function can invoke the read() method to find out the old value of the property, if needed. Therefore the old value is not provided to this function.

The ActionHandler callback

A function called with a parameters dictionary argument assembled by the WoT runtime based on the Thing Description and the external client request. It returns a Promise that rejects with an error or resolves if the action is successful or ongoing (may also resolve with a control object such as an Observable for actions that need progress notifications or that can be canceled).

The setPropertyReadHandler() method

Takes name as string argument and readHandler as argument of type PropertyReadHandler. Sets the handler function for reading the specified Property matched by name. Throws on error. Returns a reference to the same object for supporting chaining.

The readHandler callback function will implement reading a Property and SHOULD be called by implementations when a request for reading a Property is received from the underlying platform.

There SHOULD be at most one handler for any given Property and newly added handlers replace the old handlers. If no handler is initialized for any given Property, implementations SHOULD implement a default property read handler.

When an external request for reading Property propertyName is received, the runtime SHOULD execute the following steps:

1. Return a Promise promise and execute the next steps in parallel.
2. If a Property with propertyName does not exist, reject promise with a ReferenceError and terminate these steps.
3. Otherwise, if no read handler has been defined for propertyName, resolve promise with the value of the Property named propertyName provided by the runtime implementation and terminate these steps.
4. Otherwise, invoke the read handler associated with propertyName. If it rejects, then reject promise with the same error, and resolve promise with the same value.

The setPropertyWriteHandler() method

Takes name as string argument and writeHandler as argument of type PropertyWriteHandler. Sets the handler function for writing the specified Property matched by name. Throws on error. Returns a reference to the same object for supporting chaining.

There SHOULD be at most one write handler for any given Property and newly added handlers replace the old handlers. If no write handler is initialized for any given Property, implementations SHOULD implement default property update and notifying observers on change.

When an external request for writing a Property propertyName with a new value value is received, the runtime SHOULD execute the following steps:

1. Return a Promise promise and execute the next steps in parallel.
2. If a Property with propertyName does not exist, reject promise with a ReferenceError and terminate these steps.
3. Otherwise, if no write handler has been defined for propertyName, the runtime implementation SHOULD update the Property value with value, resolve promise and terminate these steps.
4. Otherwise, invoke the write handler associated with propertyName providing value as argument. If it rejects, then reject promise with the same error, and resolve promise with the same value.

The setActionHandler() method

Takes name as string argument and action as argument of type ActionHandler. Sets the handler function for the specified Action matched by name. Throws on error. Returns a reference to the same object for supporting chaining.

The action callback function will implement an Action and SHOULD be called by implementations when a request for invoking the Action is received from the underlying platform.

There SHOULD be at most one handler for any given Action and newly added handlers replace the old handlers.

When an external request for invoking the Action identified by name is received, the runtime SHOULD execute the following steps:

1. Return a Promise promise and execute the next steps in parallel.
2. If an Action identified by name does not exist, reject promise with a ReferenceError and terminate these steps.
3. Otherwise, if no action handler has been defined for name, reject promise with a ReferenceError and terminate these steps.
4. Otherwise, invoke the Action handler associated with name. If it rejects with error, then reject promise with the same error, otherwise if it resolves with value, then resolve promise with the same value.

Examples

Below some ExposedThing interface examples are given.

        try {
          var temperatureValueDefinition = {
            type: "number",
            minimum: -50,
            maximum: 10000
          };
          var temperaturePropertyDefinition = temperatureValueDefinition;
          // add the 'forms' property
          temperaturePropertyDefinition.forms = [ ... ];
          var thing = WoT.produce({
            name: "tempSensor",
            properties: {
              temperature: temperaturePropertyDefinition
            },
            actions: {
              reset: {
                description: "Reset the temperature sensor",
                input: {
                  temperature: temperatureValueDefinition
                },
                output: null,
                forms: []
              },
            },
            events: {
              onchange: temperatureValueDefinition
            },
            links: []
          });
          await thing.expose();
          await wot.register("https://mydirectory.org", thing);
          // define Thing business logic
          setInterval( async () => {
            let mock = Math.random()*100;
            let old = await thing["temperature"].read();
            if (old < mock) {
              await thing["temperature"].write(mock);
              thing.emitEvent("onchange", mock);
            }
          }, 1000);
        } catch (err) {
           console.log("Error creating ExposedThing: " + err);
        }
      

        try {
          var statusValueDefinition = {
            type: "object",
            properties: {
              brightness: {
                type: "number",
                minimum: 0.0,
                maximum: 100.0,
                required: true
              },
              rgb: {
                type: "array",
                "minItems": 3,
                "maxItems": 3,
                items : {
                    "type" : "number",
                    "minimum": 0,
                    "maximum": 255
                }
              }
          };
          var statusPropertyDefinition = statusValueDefinition;
          // add the 'forms' property
          statusPropertyDefinition["forms"] = [];
          var thing = WoT.produce({
            name: "mySensor",
            properties: {
              brightness: {
                type: "number",
                minimum: 0.0,
                maximum: 100.0,
                required: true,
              },
              status: statusPropertyDefinition
            },
            actions: {
              status: {
                description: "Get status object",
                input: null,
                output: {
                  status : statusValueDefinition;
                },
                forms: []
              },
            },
            events: {
              onstatuschange: statusValueDefinition;
            },
            links: []
          });
          thing.expose().then(() => {
              thing.register();
          });
        } catch (err) {
           console.log("Error creating ExposedThing: " + err);
        }
      

        let thingDescription = '{ \
          "name": "mySensor", \
          "@context": [ "http://www.w3.org/ns/td",\
             "https://w3c.github.io/wot/w3c-wot-common-context.jsonld" ],\
          "@type": [ "Thing", "Sensor" ], \
          "geo:location": "testspace", \
          "properties": { \
            "prop1": { \
              "type": "number",\
              "@type": [ "Property", "Temperature" ], \
              "saref:TemperatureUnit": "degree_Celsius" \
          } } }';
        try {
          // note that produce() fails if thingDescription contains error
          let thing = WoT.produce(thingDescription);
          // Interactions were added from TD
          // WoT adds generic handler for reading any property
          // define a specific handler for one property
          let name = "examplePropertyName";
          thing.setPropertyReadHandler(name, () => {
            console.log("Handling read request for " + name);
            return new Promise((resolve, reject) => {
                let examplePropertyValue = 5;
                resolve(examplePropertyValue);
              },
              e => {
                console.log("Error");
              });
          });
          thing.expose();
        } catch(err) {
           console.log("Error creating ExposedThing: " + err);
        }
      

        // fetch an external TD, e.g., to set up a proxy for that Thing
        WoT.fetch("http://myservice.org/mySensor/description").then(td => {
          // WoT.produce() ignores instance-specific metadata (security, form)
          let thing = WoT.produce(td);
          // Interactions were added from TD
          // add server functionality
          // ...
        });
      

The DataSchema dictionary and its subclasses

Value types basically represent types that may be used in JSON object definitions and are used in ThingFragment to define Properties, Events and Action parameters. Value types are represented as dictionary objects whose properties and possible sub-classes are defined in the DataSchema section of [[!WOT-TD]].

One property of all DataSchema dictionary is the type property whose value is from a set of enumerated strings defined in the DataSchema section of [[!WOT-TD]] and is referred as DataType in this specification.

Based on type, the following sub-classes of DataSchema are defined in [[!WOT-TD]]: BooleanSchema, NumberSchema, IntegerSchema, StringSchema, ObjectSchema, ArraySchema.

The SecurityScheme dictionary and its subclasses

Security metadata is represented as dictionary objects whose properties and sub-classes are defined in the SecurityScheme section of [[!WOT-TD]].

One property of the SecurityScheme dictionary is the scheme property whose value is from a set of enumerated strings defined in the SecurityScheme section of [[!WOT-TD]]. Based on type, multiple subclasses of SecurityScheme are defined.

The Link dictionary

Represents a Web Link with properties defined in the Link section of [[!WOT-TD]].

The Form dictionary

Represents metadata describing service details, with properties defined in the Form section of [[!WOT-TD]].

The InteractionFragment dictionary

Represents the common properties of WoT Interactions, one of Property, Action or Event, as defined in the InteractionPattern section of [[!WOT-TD]]. Its subclasses are referred as PropertyFragment, ActionFragment and EventFragment.

The PropertyFragment dictionary

Represents the Property interaction data that initializes a ThingProperty object. Its properties are defined in the Property and InteractionPattern sections of [[!WOT-TD]].

The ActionFragment dictionary

Represents the Action interaction data that initializes a ThingAction object. Its properties are defined in the Action and InteractionPattern sections of [[!WOT-TD]].

The EventFragment dictionary

Represents the Event interaction data that initializes a ThingEvent object. Its properties are defined in the Event section of [[!WOT-TD]].

The ThingFragment dictionary

The ThingFragment dictionary is defined as Thing in [[!WOT-TD]]. It is a dictionary that contains properties representing semantic metadata and interactions (Properties, Actions and Events). It is used for initializing an internal representation of a Thing Description and its properties may be used in ThingFilter.

The ThingDescription type

Serialized representation of the Thing Description (a JSON-LD document).

In this version of the API, Thing Descriptions are represented as an opaque USVString that can be transmitted between devices.

The Interaction interface

The Interaction interface is an abstract class to represent Thing interactions: Properties, Actions and Events.

The InteractionFragment dictionary holds the common properties of PropertyFragment, ActionFragment and EventFragment dictionaries used for initializing ThingProperty, ThingAction and ThingEvent objects in a ThingFragment dictionary used for creating an ExposedThing object.

        interface Interaction {
          readonly attribute (Form or FrozenArray<Form>) forms;
        };
        Interaction includes InteractionFragment;
      

The forms read-only property represents the protocol bindings initialization data and is initialized by the WoT Runtime.

The ThingProperty interface

The ThingProperty interface is used in ConsumedThing and ExposedThing objects to represent Thing Property interactions.

The PropertyFragment dictionary is used for initializing Property objects in a ThingFragment dictionary used for creating an ExposedThing object. It MUST implement one of the DataSchema dictionaries.

        interface ThingProperty: Interaction {
          // getter for PropertyFragment properties
          getter any(DOMString name);
          // get and set interface for the Property
          Promise<any> read();
          Promise<void> write(any value);
        };
        ThingProperty includes PropertyFragment;
        ThingProperty includes Observable;
      

The ThingProperty interface contains all the properties defined on PropertyFragment as read-only properties.

The type read-only property represents the type definition for the Property as a DataSchema dictionary object.

The writable read-only property tells whether the Property value can be updated. If it is false, then the set(value) method SHOULD always reject.

The observable read-only property tells whether the Property supports subscribing to value change notifications. If it is false, then the subscribe() method SHOULD always fail.

The constant read-only property - defined in DataSchema - tells whether the Property value is a constant. If true, the set() and subscribe() methods SHOULD always fail.

The required read-only property - defined in DataSchema - tells whether the Property should be always present on the ExposedThing object.

The read() method will fetch the value of the Property. Returns a Promise that resolves with the value, or rejects with an error.

The write() method will attempt to set the value of the Propertyspecified in the value argument whose type SHOULD match the one specified by the type property. Returns a Promise that resolves on success, or rejects on an error.

The ThingAction interface

        interface ThingAction: Interaction {
          Promise<any> invoke(optional any inputValue);
        };
        ThingAction includes ActionFragment;
      

The invoke() method when invoked, starts the Action interaction with the input value provided by the inputValue argument. If inputValue is null, the action does not take any arguments and rejects if any arguments are provided. If the value is undefined, the action will ignore any arguments provided. Otherwise the type of inputValue SHOULD match the DataSchema definition in the input property. Returns a Promise that will reject with an error or will resolve with a value of type defined by the output property.

The ThingEvent interface

        interface ThingEvent: Interaction {
        };
        ThingEvent includes EventFragment;
        ThingEvent includes ThingProperty;
      

Since ThingEvent implements Observable through the ThingProperty interface, event subscription is done by invoking the subscribe() method on the event object that returns a cancelable Subscription.

The ExposedEvent interface

        interface ExposedEvent: ThingEvent {
          void emit(any payload);
        };
      

The value-matching algorithm

The value-matching algorithm is applied to a value input in relation to a valueType property of type DataSchema, for instance the value and type properties of a PropertyFragment object, or the inputValue parameter to the invoke() method of a ThingAction object in relation to the same object. It executes the following steps:

1. If valueType.type is not defined, or does not fully match a string enumerated in DataType, return false.
2. Otherwise, if valueType.type is "null": if value is null, return true, otherwise return false.
3. Otherwise, if valueType.type is "boolean": if value is either true or false, then return true, otherwise return false.
4. Otherwise, if valueType.type is "integer": if value is not an integer type defined by the underlying platform (such as long or long long), then return false, otherwise execute the following sub-steps:
   1. If valueType.minimum is defined and value is not greater or equal than that value, return false.
   2. If valueType.maximum is defined and value is not less or equal than that value, return false.
   3. Return true.
5. Otherwise, if valueType.type is "number", if value is not an integer or floating point type defined by the underlying platform (such as long or long long or double), then return false, otherwise otherwise execute the following sub-steps:
   1. If valueType.minimum is defined and value is not greater or equal than that value, return false.
   2. If valueType.maximum is defined and value is not less or equal than that value, return false.
   3. Return true.
6. Otherwise, if valueType.type is "string": if value is not a string type defined by the underlying platform, then return false, otherwise return true. In this case the algorithm expects a third parameter valueType.enum and runs the following sub-steps:
   • If valueType.enum is an array of strings, then if value fully matches one of the strings defined in the array, return true.
   • Otherwise, return false.
7. Otherwise, if valueType.type is "array", execute the following sub-steps:
   1. If value is not an array, return false.
   2. If valueType.minItems is defined, and value does not contain at least valueType.minItems elements, return false.
   3. If valueType.maxItems is defined, and value contains more than valueType.maxItems elements, return false.
   4. Otherwise, if valueType.items is undefined, return false.
   5. Otherwise, if valueType.items is null, return true (i.e. any type is accepted as array element, including heterogenous arrays).
   6. Otherwise, for each element of the array value run the value-matching algorithm against the valueType.items object. If any of these runs returns false, then return false.
   7. Otherwise, return true.
8. Otherwise, if type is "object", execute the following sub-steps:
   1. If value is not an Object, return false.
   2. If valueType.properties is not defined, return false.
   3. If valueType.properties is null, return true (i.e. accept any object value).
   4. For each string in the valueType.required array, if it does not match a property name in the value.properties object or in the value object, then return false.
   5. For each property with name propName and value propDataSchema found in valueType.properties, run the following sub-steps:
      1. If the result of applying the value-matching algorithm on the value value[propName] and propDataSchema is false, then return false.
   6. Return true.

Scripts Security and Privacy Risks

This section contains specific risks relevant for script developers.

WoT Runtime Security and Privacy Risks

This section contains specific risks relevant for the WoT Runtime itself. While the following risks are strictly speaking out of the scope for the WoT Scripting API, a script needs a secure runtime to execute and therefore we present these risks and recommended mitigations here.