Interface: Scene.IObject

 class Clickable {
   public events = {
     clicked: true,
   };
 }
 // create an `IObject`, add an `INode` and an `IComponent` to the node, see the relevant functions (createObject, addNode, addComponent)
 const [object, node, component];

 // create the path
 const emitPath = object.addEmitPath(component, 'clicked');

 // bind the emit path so that it triggers the `emitPath`'s associated component's onEvent when an event is emitted
 object.bindPath(eventPath, emitPath);

 // observe emissions of 'clicked' events in component
 object.spyOnEvent({
   path: emitPath,
   onEvent(eventData) {
     console.log(`a 'clicked' event was emitted with the data: ${eventData}`);
   },
 });

 class Renderable {
   public events = {
     rerender: true,
   };
 }
 // create an `IObject`, add an `INode` and an `IComponent` to the node, see the relevant functions (createObject, addNode, addComponent)
 const [object, node, component];

 // create the path
 const eventPath = object.addEventPath(component, 'rerender');

 // bind the event path so that it triggers the component's onEvent when `emitPath` emits an event
 object.bindPath(eventPath, emitPath);

 class Counter {
   public inputs = {
     count: 1,
   };
 }
 // create an `IObject`, add an `INode` and an `IComponent` to the node, see the relevant functions (createObject, addNode, addComponent)
 const [object, node, component];

 // create the path
 const inputPath = object.addInputPath(component, 'count');

 // observe changes to the value of `inputs.count` in component
 object.spyOnEvent({
   path: inputPath,
   onEvent(newValue) {
     console.log(`component.input.count's new value is ${newValue}`);
   },
 });
 // read and change the value of the input in the component
 const countValue = inputPath.get();
 inputPath.set(count + 1);

// bind the path to the value from another (output) path
 object.bindPath(inputPath, outputPath);

 class NumberGenerator {
   public outputs = {
     current: 1,
   };
 }
 // create an `IObject`, add an `INode` and an `IComponent` to the node, see the relevant functions (createObject, addNode, addComponent)
 const [object, node, component];

 // create the path
 const outputPath = object.addOutputPath(component, 'current');

 // observe changes to the value of `outputs.current` in component
 object.spyOnEvent({
   path: outputPath,
   onEvent(newValue) {
     console.log(`component.output.current's new value is ${newValue}`);
   },
 });
 // read and bind the value of the output to another component's input value
 const currentValue = outputPath.get();
 object.bindPath(inputPath, outputPath);

const [sceneObject] = await sdk.Scene.createObjects(1);
const node = sceneObject.addNode();

// mp.objLoader has an outputs.visible property
const comp1 = node.addComponent('mp.objLoader');
const outputPath = sceneObject.addOutputPath(comp1, 'visible', 'objLoader-visible');

// myComponent has an inputs.toggleState property
const comp2 = node.addComponent('myComponent');
const inputPath = sceneObject.addInputPath(comp2, 'toggleState', 'myComponent-toggle');
sceneObject.bindPath(inputPath, outputPath);

node.start();
// comp1.inputs.visible will now always equal comp2.outputs.toggleState

const [sceneObject] = await sdk.Scene.createObject(1);
const node = sceneObject.createNode();

// myReceiver has an `onEvent` lifecycle function and an `events['do.update']` property
const receiver = node.addComponent(`myReceiver');
const eventPath = sceneObject.addEventPath(receiver, 'do.update', 'my-reciever-update');

// myEmitter calls notify with an 'updated' event and has an `emits['updated']` property
const emitter = node.addComponent('myEmitter');
const emitPath = sceneObject.addEmitPath(emitter, 'updated', 'my-component-updated');
sceneObject.bindPath(eventPath, emitPath);

node.start();
// receiver.onEvent('do.update', ...) will now be called whenever emitter calls notify('updated')

// This example sets the values of all input paths provided by deserialized scene object.

const deserialized = await sdk.Scene.deserialize(myString);
const paths = deserialized.pathIterator();
for (const { desc, path } of paths) {
  if (desc.type === Scene.PathType.INPUT) {
    // we know this path is an input path
    const inputPath = desc.path as Scene.InputPath;

    // Now you can set the value at the path
    // You can cache the returned input path to use it later.
    inputPath.set(10);
  }
}

const [sceneObject] = await sdk.Scene.createObjects(1);
const node = sceneObject.createNode();

// mp.objLoader has an outputs.visible property
const comp1 = node.addComponent('mp.objLoader');
const outputPath = sceneObject.addOutputPath(comp1, 'visible', 'objLoader-visible');

const outputSpy = {
  path: outputPath,
  onEvent(type, data) {
    console.log('outputs updated', type, data);
  }
};

sceneObject.spyOnEvent(outputSpy);

node.start();
// outputSpy.onEvent('outputsUpdated', comp1.outputs.visible) will now be called whenever comp1.outputs.visible changes