@lakutata/dbus 2.3.1 → 3.0.0-beta.0

package/dist/cjs/components/DBusClientComponent.js

@@ -0,0 +1,272 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DBusClientComponent = exports.buildDBusClientOptions = void 0;
+const dbus_sdk_1 = require("dbus-sdk");
+const core_1 = require("@lakutata/core");
+const di_1 = require("@lakutata/core/decorator/di");
+/**
+ * Build the declaration of a {@link DBusClientComponent} for the `components` of an application or a module, from its
+ * typed options.
+ * @param options The bus address and the connection options.
+ * @returns The declaration: the options with `class: DBusClientComponent`.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildDBusClientOptions, DBusClientComponent} from '@lakutata/dbus'
+ *
+ * Application
+ *     .run(() => ({
+ *         id: 'client.app',
+ *         name: 'Client',
+ *         components: {
+ *             dbus: buildDBusClientOptions({busAddress: 'unix:path=/var/run/dbus/system_bus_socket', timeout: 5000})
+ *         }
+ *     }))
+ *     .onLaunched(async (app: Application): Promise<void> => {
+ *         const dbus: DBusClientComponent = await app.getObject('dbus')
+ *         console.log(await dbus.listNames())
+ *     })
+ * ```
+ */
+const buildDBusClientOptions = (options) => ({
+    class: DBusClientComponent,
+    busAddress: options.busAddress,
+    timeout: options.timeout,
+    callTimeout: options.callTimeout,
+    decode: options.decode
+});
+exports.buildDBusClientOptions = buildDBusClientOptions;
+/**
+ * A D-Bus client: a connection to a bus, to call the services on it, read their objects, properties and introspection,
+ * and listen to their signals. Declare it in the `components` of an application with {@link buildDBusClientOptions}
+ * (or `{class: DBusClientComponent, busAddress: …}`) and get it with `getObject()` or `@Inject`; it is a singleton
+ * component. It connects when it is created, so a bus that cannot be reached fails its creation; it disconnects when it
+ * is destroyed (the application stopping). It is a thin layer over the `DBus` connection of `dbus-sdk`, whose classes
+ * (`DBusService`, `DBusObject`, `DBusRemoteInterface`…) its methods return.
+ *
+ * Its `on`, `once`, `off` and `removeListener` listen to the connection's events (`'nameOwnerChanged'`,
+ * `'connectionClose'`…), not to events of the component.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {DBusClientComponent, type DBusRemoteInterface} from '@lakutata/dbus'
+ *
+ * Application
+ *     .run(() => ({
+ *         id: 'client.app',
+ *         name: 'Client',
+ *         components: {
+ *             dbus: {class: DBusClientComponent, busAddress: 'unix:path=/var/run/dbus/system_bus_socket'}
+ *         }
+ *     }))
+ *     .onLaunched(async (app: Application): Promise<void> => {
+ *         const dbus: DBusClientComponent = await app.getObject('dbus')
+ *         //A method call: the output arguments, as an array
+ *         const [owner] = await dbus.invoke({
+ *             service: 'org.freedesktop.DBus',
+ *             objectPath: '/org/freedesktop/DBus',
+ *             interface: 'org.freedesktop.DBus',
+ *             method: 'GetNameOwner',
+ *             signature: 's',
+ *             args: ['org.freedesktop.DBus']
+ *         })
+ *         console.log(owner)
+ *         //An interface, from the introspection of its object: its methods, properties and signals
+ *         const device: DBusRemoteInterface = await dbus.interface('com.example.DeviceService', '/com/example/Devices/A1', 'com.example.Device')
+ *         console.log(await device.method.Status({sn: 'A1'}))
+ *         console.log(await device.property.State.get())
+ *         device.signal.on('Changed', (data: unknown): void => console.log(data))
+ *         dbus.on('nameOwnerChanged', (name: string, oldOwner: string, newOwner: string): void => console.log(name, oldOwner, newOwner))
+ *     })
+ * ```
+ */
+class DBusClientComponent extends core_1.Component {
+    /**
+     * The unique name the bus gave this connection (`':1.42'`).
+     */
+    get uniqueName() {
+        return this.dbus.uniqueName;
+    }
+    /**
+     * Connect to the bus, when the component is created.
+     * @throws {Error} When the bus cannot be reached, or the authentication fails.
+     */
+    async init() {
+        this.dbus = await dbus_sdk_1.DBus.connect({
+            busAddress: this.busAddress,
+            timeout: this.timeout,
+            callTimeout: this.callTimeout,
+            //The 64-bit integers are numbers unless the decoding says otherwise (as the client of lakutata 2.x)
+            decode: { int64: 'number', ...this.decode }
+        });
+    }
+    /**
+     * Disconnect from the bus, when the component is destroyed.
+     */
+    async destroy() {
+        await this.dbus.disconnect();
+    }
+    invoke(opts) {
+        return this.dbus.invoke(opts);
+    }
+    on(eventName, listener) {
+        this.dbus.on(eventName, listener);
+        return this;
+    }
+    once(eventName, listener) {
+        this.dbus.once(eventName, listener);
+        return this;
+    }
+    off(eventName, listener) {
+        this.dbus.off(eventName, listener);
+        return this;
+    }
+    removeListener(eventName, listener) {
+        this.dbus.removeListener(eventName, listener);
+        return this;
+    }
+    /**
+     * Ask the bus to route the messages matching a rule to this connection, without waiting for the bus's answer (the
+     * signal emitters of {@link interface} and {@link interfaceSignal} add their own rules).
+     * @param rule The match rule (`"type='signal',interface='com.example.Device'"`).
+     */
+    addMatch(rule) {
+        return this.dbus.addMatch(rule);
+    }
+    /**
+     * Remove a match rule added with {@link addMatch}, without waiting for the bus's answer.
+     * @param rule The match rule, as it was added.
+     */
+    removeMatch(rule) {
+        return this.dbus.removeMatch(rule);
+    }
+    /**
+     * Get the connection owning a name.
+     * @param name The bus name (`'com.example.DeviceService'`).
+     * @returns The unique name of its owner (`':1.42'`), or `undefined` when nobody owns it or the query fails.
+     */
+    async getNameOwner(name) {
+        return this.dbus.getNameOwner(name);
+    }
+    /**
+     * List the names the bus can start a service for (D-Bus activation), running or not.
+     * @returns The names.
+     */
+    async listActivatableNames() {
+        return this.dbus.listActivatableNames();
+    }
+    /**
+     * List the names owned on the bus now: the well-known names and the unique names of the connections.
+     * @returns The names.
+     */
+    async listNames() {
+        return this.dbus.listNames();
+    }
+    /**
+     * Tell whether a name is owned on the bus now.
+     * @param name The bus name.
+     * @returns `true` when a connection owns it.
+     */
+    async nameHasOwner(name) {
+        return this.dbus.nameHasOwner(name);
+    }
+    /**
+     * List the names of the bus, owned or activatable, with their owner, whether they are active or activatable, and the
+     * process id of their owner.
+     * @returns The names and their details.
+     */
+    async listBusNames() {
+        return this.dbus.listBusNames();
+    }
+    /**
+     * List the services of the bus: its well-known names (the unique names `:1.42` left out), with their details.
+     * @returns The services and their details.
+     */
+    async listServices() {
+        return this.dbus.listServices();
+    }
+    /**
+     * Get the services of the bus which are running, to browse their objects (the activatable services which are not
+     * running are left out, not started: get one with {@link service} to start it).
+     * @returns The services.
+     */
+    async services() {
+        return this.dbus.getServices();
+    }
+    /**
+     * Get a service, starting it when it is activatable and not running.
+     * @param service The service's well-known name (`'org.freedesktop.NetworkManager'`).
+     * @returns The service.
+     * @throws {Error} A `ServiceNotFoundError` of `dbus-sdk` when the name is neither owned nor activatable.
+     */
+    async service(service) {
+        return this.dbus.getService(service);
+    }
+    /**
+     * Get an object of a service, to read its introspection and its interfaces.
+     * @param service The service's well-known name.
+     * @param objectPath The object path (`'/org/freedesktop/NetworkManager'`).
+     * @returns The object.
+     * @throws {Error} A `ServiceNotFoundError` of `dbus-sdk` when the service is neither running nor activatable.
+     */
+    async object(service, objectPath) {
+        return this.dbus.getObject(service, objectPath);
+    }
+    /**
+     * Get an interface of an object, built from the object's introspection: its methods (`method.Name(...args)`, or
+     * `noReplyMethod`), its properties (`property.Name.get()`, `.set(value)`) and its signals (`signal.on('Name', …)`).
+     * @param service The service's well-known name.
+     * @param objectPath The object path.
+     * @param iface The interface name (`'org.freedesktop.NetworkManager'`).
+     * @returns The interface.
+     * @throws {Error} When the service is not found, or the object does not implement the interface
+     * (`InterfaceNotFoundError` of `dbus-sdk`).
+     */
+    async interface(service, objectPath, iface) {
+        return this.dbus.getInterface(service, objectPath, iface);
+    }
+    /**
+     * Get the signals of an interface of an object: an event emitter emitting each signal under its name, with its
+     * arguments.
+     * @param service The service's well-known name.
+     * @param objectPath The object path.
+     * @param iface The interface name.
+     * @returns The emitter of the interface's signals.
+     * @throws {Error} When the service is not found, or the object does not implement the interface
+     * (`InterfaceNotFoundError` of `dbus-sdk`).
+     */
+    async interfaceSignal(service, objectPath, iface) {
+        const dbusIface = await this.dbus.getInterface(service, objectPath, iface);
+        return dbusIface.signal;
+    }
+}
+exports.DBusClientComponent = DBusClientComponent;
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], DBusClientComponent.prototype, "busAddress", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Number().positive().integer().optional()),
+    __metadata("design:type", Number)
+], DBusClientComponent.prototype, "timeout", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Number().positive().integer().optional()),
+    __metadata("design:type", Number)
+], DBusClientComponent.prototype, "callTimeout", void 0);
+__decorate([
+    (0, di_1.Configurable)(core_1.DTO.Object({
+        types: core_1.DTO.String().valid('none', 'variants', 'all').optional(),
+        dictionaries: core_1.DTO.String().valid('object', 'map').optional(),
+        int64: core_1.DTO.String().valid('bigint', 'number').optional()
+    }).optional()),
+    __metadata("design:type", Object)
+], DBusClientComponent.prototype, "decode", void 0);

package/dist/cjs/components/DBusObjectManager.d.ts

@@ -0,0 +1,164 @@
+import { Component } from '@lakutata/core';
+import type { DBusPropertyDefinition, DBusSignalDefinition } from '../lib/Declarations.js';
+/**
+ * What a DBus adapter does for the object manager while it runs
+ */
+export type DBusObjectSink = {
+    /**
+     * Export an object, false when no interface of the adapter serves its path
+     */
+    addObject(path: string): boolean;
+    /**
+     * Stop exporting an object added by the object manager, false when it does not export it or exports it as a fixed
+     * object (the path of a template without variables), which it keeps
+     */
+    removeObject(path: string): boolean;
+    /**
+     * Whether it exports the object as a fixed object
+     */
+    isFixed(path: string): boolean;
+    emitSignal(path: string, signal: DBusSignalDefinition<any>, data: unknown): boolean;
+    propertyChanged(path: string, property: DBusPropertyDefinition<any>, value: unknown): void;
+};
+/**
+ * A property value written by a D-Bus client, the argument of the `propertyWritten` event of
+ * {@link DBusObjectManager}. The value is already validated and kept when the event is emitted.
+ */
+export type DBusPropertyWrite = {
+    /**
+     * The object path of the property (`'/com/example/Devices/A1'`).
+     */
+    readonly path: string;
+    /**
+     * The name of the interface the client wrote it through (`'com.example.Device'`).
+     */
+    readonly interface: string;
+    /**
+     * The property's definition, to compare with the one built by `defineDBusProperty`.
+     */
+    readonly property: DBusPropertyDefinition<any>;
+    /**
+     * The value written, validated by the property's schema.
+     */
+    readonly value: unknown;
+};
+export declare const ATTACH: unique symbol;
+export declare const STORE: unique symbol;
+/**
+ * The application's D-Bus objects: it adds and removes the objects of the path templates of `@DBusInterface`
+ * (`/com/example/Devices/{sn}`), keeps the values of their properties, and emits their signals. Inject it
+ * (`@Inject(DBusObjectManager)`) or get it (`getObject(DBusObjectManager)`) from any object: it is autoloaded, a
+ * singleton of the application, and needs no registration.
+ *
+ * Its state lives in the application, not on the bus: the objects added before a {@link dbusEntrypoint} starts are
+ * exported when it starts, and every running D-Bus adapter whose interfaces match a path exports the object. The
+ * clients are told of the objects added and removed by the `org.freedesktop.DBus.ObjectManager` interface of the root
+ * object (`InterfacesAdded`, `InterfacesRemoved`).
+ *
+ * It emits `propertyWritten` (a {@link DBusPropertyWrite}) when a client writes a writable property.
+ * @example
+ * ```typescript
+ * import {Component} from 'lakutata'
+ * import {Inject} from 'lakutata/decorator/di'
+ * import {DBusObjectManager, defineDBusProperty, defineDBusSignal, type DBusPropertyWrite} from '@lakutata/dbus'
+ *
+ * export const DeviceState = defineDBusProperty<string>('State', 's', {initial: 'idle'})
+ * export const DeviceLevel = defineDBusProperty<number>('Level', 'i', {writable: true, initial: 1})
+ * export const DeviceRemoved = defineDBusSignal<string>('Removed', 's')
+ *
+ * //Declared in the components of the application, with the controllers of the interfaces at /com/example/Devices/{sn}
+ * export class Devices extends Component {
+ *     @Inject(DBusObjectManager)
+ *     protected readonly manager: DBusObjectManager
+ *
+ *     protected async init(): Promise<void> {
+ *         this.manager.on('propertyWritten', (write: DBusPropertyWrite): void => {
+ *             if (write.property === DeviceLevel) console.log(`${write.path}: level ${write.value}`)
+ *         })
+ *     }
+ *
+ *     public plug(sn: string): void {
+ *         const path: string = `/com/example/Devices/${sn}`
+ *         this.manager.addObject(path)
+ *         this.manager.setPropertyValue(path, DeviceState, 'running')
+ *     }
+ *
+ *     public unplug(sn: string): void {
+ *         const path: string = `/com/example/Devices/${sn}`
+ *         this.manager.emitSignal(path, DeviceRemoved, sn)
+ *         this.manager.removeObject(path)
+ *     }
+ * }
+ * ```
+ */
+export declare class DBusObjectManager extends Component {
+    #private;
+    /**
+     * Send the changes to an adapter until the returned function is called; the objects already added are exported by it
+     * @param sink
+     */
+    [ATTACH](sink: DBusObjectSink): () => void;
+    /**
+     * Keep a value written by a client
+     * @param write
+     */
+    [STORE](write: DBusPropertyWrite): void;
+    /**
+     * Add an object: every running D-Bus adapter whose interfaces have a path template matching it (or the same path)
+     * exports it, with those interfaces, and the adapters started later export it when they start. The variables of the
+     * matching templates are given to the methods called on it. An object whose path matches no template is kept, but
+     * not exported.
+     * @param path The object path (`'/com/example/Devices/A1'`), not a template.
+     * @returns `false` when the object was already added, `true` otherwise.
+     * @throws {TypeError} When the path is invalid, or is a template (it contains braces).
+     */
+    addObject(path: string): boolean;
+    /**
+     * Remove an object added with {@link addObject}: the adapters stop exporting it, and its property values are
+     * forgotten (added again, it starts from the initial values). A fixed object (the path of a template without
+     * variables, exported by the adapters themselves) stays exported, with its property values, when it was also
+     * added: only its entry in {@link objects} is removed.
+     * @param path The object path given to {@link addObject}.
+     * @returns `false` when the object was not added, `true` otherwise.
+     */
+    removeObject(path: string): boolean;
+    /**
+     * Tell whether an object was added with {@link addObject} and not removed since.
+     * @param path The object path.
+     * @returns `true` when the object is added.
+     */
+    hasObject(path: string): boolean;
+    /**
+     * List the objects added with {@link addObject}, in the order they were added; the objects of the paths without
+     * variables, exported by the adapters themselves, are not listed.
+     * @returns The object paths.
+     */
+    objects(): string[];
+    /**
+     * Set the value of a property on an object, validated by the property's schema: the clients read it from then on,
+     * and the running adapters exporting the object announce it (`PropertiesChanged`). The value is kept even when no
+     * adapter exports the object yet.
+     * @param path The object path (`'/com/example/Devices/A1'`).
+     * @param property The property's definition, listed in the `properties` of the object's interface.
+     * @param value The new value.
+     * @throws {InvalidValueException} When the value does not match the property's schema; nothing is changed.
+     */
+    setPropertyValue<T>(path: string, property: DBusPropertyDefinition<T>, value: T): void;
+    /**
+     * Get the value of a property on an object: the last value set by the application or written by a client.
+     * @param path The object path.
+     * @param property The property's definition.
+     * @returns The value, or the property's `initial` value until one is set.
+     */
+    getPropertyValue<T>(path: string, property: DBusPropertyDefinition<T>): T | undefined;
+    /**
+     * Emit a signal from an object, through every running adapter exporting the object with an interface listing the
+     * signal. The data is validated by the signal's DTO first.
+     * @param path The object path (`'/com/example/Devices/A1'`).
+     * @param signal The signal's definition, listed in the `signals` of the object's interface.
+     * @param data The data of the signal.
+     * @returns `false` when no running adapter exports the object with this signal (nothing is sent), `true` otherwise.
+     * @throws {InvalidValueException} When the data does not match the signal's DTO.
+     */
+    emitSignal<T>(path: string, signal: DBusSignalDefinition<T>, data: T): boolean;
+}

package/dist/cjs/components/DBusObjectManager.js

@@ -0,0 +1,200 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DBusObjectManager = exports.STORE = exports.ATTACH = void 0;
+const core_1 = require("@lakutata/core");
+const di_1 = require("@lakutata/core/decorator/di");
+const Names_js_1 = require("../lib/Names.js");
+exports.ATTACH = Symbol('DBUS.OBJECT.MANAGER.ATTACH');
+exports.STORE = Symbol('DBUS.OBJECT.MANAGER.STORE');
+/**
+ * The application's D-Bus objects: it adds and removes the objects of the path templates of `@DBusInterface`
+ * (`/com/example/Devices/{sn}`), keeps the values of their properties, and emits their signals. Inject it
+ * (`@Inject(DBusObjectManager)`) or get it (`getObject(DBusObjectManager)`) from any object: it is autoloaded, a
+ * singleton of the application, and needs no registration.
+ *
+ * Its state lives in the application, not on the bus: the objects added before a {@link dbusEntrypoint} starts are
+ * exported when it starts, and every running D-Bus adapter whose interfaces match a path exports the object. The
+ * clients are told of the objects added and removed by the `org.freedesktop.DBus.ObjectManager` interface of the root
+ * object (`InterfacesAdded`, `InterfacesRemoved`).
+ *
+ * It emits `propertyWritten` (a {@link DBusPropertyWrite}) when a client writes a writable property.
+ * @example
+ * ```typescript
+ * import {Component} from 'lakutata'
+ * import {Inject} from 'lakutata/decorator/di'
+ * import {DBusObjectManager, defineDBusProperty, defineDBusSignal, type DBusPropertyWrite} from '@lakutata/dbus'
+ *
+ * export const DeviceState = defineDBusProperty<string>('State', 's', {initial: 'idle'})
+ * export const DeviceLevel = defineDBusProperty<number>('Level', 'i', {writable: true, initial: 1})
+ * export const DeviceRemoved = defineDBusSignal<string>('Removed', 's')
+ *
+ * //Declared in the components of the application, with the controllers of the interfaces at /com/example/Devices/{sn}
+ * export class Devices extends Component {
+ *     @Inject(DBusObjectManager)
+ *     protected readonly manager: DBusObjectManager
+ *
+ *     protected async init(): Promise<void> {
+ *         this.manager.on('propertyWritten', (write: DBusPropertyWrite): void => {
+ *             if (write.property === DeviceLevel) console.log(`${write.path}: level ${write.value}`)
+ *         })
+ *     }
+ *
+ *     public plug(sn: string): void {
+ *         const path: string = `/com/example/Devices/${sn}`
+ *         this.manager.addObject(path)
+ *         this.manager.setPropertyValue(path, DeviceState, 'running')
+ *     }
+ *
+ *     public unplug(sn: string): void {
+ *         const path: string = `/com/example/Devices/${sn}`
+ *         this.manager.emitSignal(path, DeviceRemoved, sn)
+ *         this.manager.removeObject(path)
+ *     }
+ * }
+ * ```
+ */
+let DBusObjectManager = class DBusObjectManager extends core_1.Component {
+    #objects = new Set();
+    #values = new Map();
+    #sinks = new Set();
+    /**
+     * Send the changes to an adapter until the returned function is called; the objects already added are exported by it
+     * @param sink
+     */
+    [exports.ATTACH](sink) {
+        this.#sinks.add(sink);
+        this.#objects.forEach((path) => sink.addObject(path));
+        return () => void this.#sinks.delete(sink);
+    }
+    /**
+     * Keep a value written by a client
+     * @param write
+     */
+    [exports.STORE](write) {
+        this.#valuesOf(write.path).set(write.property, write.value);
+        this.emit('propertyWritten', write);
+    }
+    /**
+     * The values of the properties of an object
+     * @param path
+     */
+    #valuesOf(path) {
+        let values = this.#values.get(path);
+        if (!values) {
+            values = new Map();
+            this.#values.set(path, values);
+        }
+        return values;
+    }
+    /**
+     * Add an object: every running D-Bus adapter whose interfaces have a path template matching it (or the same path)
+     * exports it, with those interfaces, and the adapters started later export it when they start. The variables of the
+     * matching templates are given to the methods called on it. An object whose path matches no template is kept, but
+     * not exported.
+     * @param path The object path (`'/com/example/Devices/A1'`), not a template.
+     * @returns `false` when the object was already added, `true` otherwise.
+     * @throws {TypeError} When the path is invalid, or is a template (it contains braces).
+     */
+    addObject(path) {
+        (0, Names_js_1.checkPathTemplate)(path);
+        if (/[{}]/.test(path))
+            throw new TypeError(`The object path "${path}" is a template, not the path of an object`);
+        if (this.#objects.has(path))
+            return false;
+        this.#objects.add(path);
+        this.#sinks.forEach((sink) => sink.addObject(path));
+        return true;
+    }
+    /**
+     * Remove an object added with {@link addObject}: the adapters stop exporting it, and its property values are
+     * forgotten (added again, it starts from the initial values). A fixed object (the path of a template without
+     * variables, exported by the adapters themselves) stays exported, with its property values, when it was also
+     * added: only its entry in {@link objects} is removed.
+     * @param path The object path given to {@link addObject}.
+     * @returns `false` when the object was not added, `true` otherwise.
+     */
+    removeObject(path) {
+        if (!this.#objects.delete(path))
+            return false;
+        let fixed = false;
+        this.#sinks.forEach((sink) => {
+            //An adapter keeps the objects it exports by itself
+            if (sink.isFixed(path))
+                fixed = true;
+            else
+                sink.removeObject(path);
+        });
+        if (!fixed)
+            this.#values.delete(path);
+        return true;
+    }
+    /**
+     * Tell whether an object was added with {@link addObject} and not removed since.
+     * @param path The object path.
+     * @returns `true` when the object is added.
+     */
+    hasObject(path) {
+        return this.#objects.has(path);
+    }
+    /**
+     * List the objects added with {@link addObject}, in the order they were added; the objects of the paths without
+     * variables, exported by the adapters themselves, are not listed.
+     * @returns The object paths.
+     */
+    objects() {
+        return [...this.#objects];
+    }
+    /**
+     * Set the value of a property on an object, validated by the property's schema: the clients read it from then on,
+     * and the running adapters exporting the object announce it (`PropertiesChanged`). The value is kept even when no
+     * adapter exports the object yet.
+     * @param path The object path (`'/com/example/Devices/A1'`).
+     * @param property The property's definition, listed in the `properties` of the object's interface.
+     * @param value The new value.
+     * @throws {InvalidValueException} When the value does not match the property's schema; nothing is changed.
+     */
+    setPropertyValue(path, property, value) {
+        const validated = property.validate(value);
+        this.#valuesOf(path).set(property, validated);
+        this.#sinks.forEach((sink) => sink.propertyChanged(path, property, validated));
+    }
+    /**
+     * Get the value of a property on an object: the last value set by the application or written by a client.
+     * @param path The object path.
+     * @param property The property's definition.
+     * @returns The value, or the property's `initial` value until one is set.
+     */
+    getPropertyValue(path, property) {
+        const values = this.#values.get(path);
+        return values?.has(property) ? values.get(property) : property.initial;
+    }
+    /**
+     * Emit a signal from an object, through every running adapter exporting the object with an interface listing the
+     * signal. The data is validated by the signal's DTO first.
+     * @param path The object path (`'/com/example/Devices/A1'`).
+     * @param signal The signal's definition, listed in the `signals` of the object's interface.
+     * @param data The data of the signal.
+     * @returns `false` when no running adapter exports the object with this signal (nothing is sent), `true` otherwise.
+     * @throws {InvalidValueException} When the data does not match the signal's DTO.
+     */
+    emitSignal(path, signal, data) {
+        const validated = signal.validate(data);
+        let emitted = false;
+        this.#sinks.forEach((sink) => {
+            if (sink.emitSignal(path, signal, validated))
+                emitted = true;
+        });
+        return emitted;
+    }
+};
+exports.DBusObjectManager = DBusObjectManager;
+exports.DBusObjectManager = DBusObjectManager = __decorate([
+    (0, di_1.Autoload)(),
+    (0, di_1.Singleton)()
+], DBusObjectManager);