@lakutata/dbus 2.3.1 → 3.0.0-beta.0

package/dist/esm/adapters/DBusEntrypoint.js

@@ -0,0 +1,274 @@
+import EventEmitter from 'node:events';
+import { FlexibleDTO } from '@lakutata/core/dtos';
+import { LocalInterface, LocalObject, LocalService, RequestNameFlags, RequestNameResultCode } from 'dbus-sdk';
+import { DBusChannel } from '../channel/DBusChannel.js';
+import { DBusContext } from '../context/DBusContext.js';
+import { ATTACH, DBusObjectManager, STORE } from '../components/DBusObjectManager.js';
+import { getDBusInterfaceDeclaration } from '../lib/Declarations.js';
+import { checkInterfaceName, compilePathTemplate, errorName } from '../lib/Names.js';
+import { toEncodable, schemaSignature } from '../lib/Signature.js';
+/**
+ * The connection options of a bus
+ * @param bus
+ */
+function connectOptions(bus) {
+    if (bus === 'session')
+        return { busAddress: process.env.DBUS_SESSION_BUS_ADDRESS };
+    if (bus === 'system')
+        return { busAddress: process.env.DBUS_SYSTEM_BUS_ADDRESS ?? 'unix:path=/var/run/dbus/system_bus_socket' };
+    if (/^[a-z]+:/.test(bus))
+        return { busAddress: bus };
+    return { socket: bus };
+}
+/**
+ * The error given to the caller of a method
+ * @param error
+ */
+function toMethodError(error) {
+    const { errMsg, message } = (error && typeof error === 'object' ? error : {});
+    const methodError = new Error(typeof errMsg === 'string' && errMsg ? errMsg : typeof message === 'string' ? message : String(error));
+    methodError.name = errorName(error);
+    return methodError;
+}
+/**
+ * Build the D-Bus adapter of the entrypoint (its `dbus` option): the application owns a service name on a bus and
+ * serves the controllers declared with `@DBusInterface` as the interfaces of its objects, their `@DBusMethod` actions
+ * as the methods. The objects of the paths without variables are exported when the adapter starts, until it stops
+ * ({@link DBusObjectManager.removeObject} does not remove them); the objects of the path templates are exported when
+ * they are added with {@link DBusObjectManager.addObject}, before or after the start.
+ *
+ * Starting connects to the bus and requests the name. The adapter stops gracefully with the entrypoint: it releases the
+ * name (no new call reaches it), the calls in progress end, then the connection closes. It needs a D-Bus daemon, as on
+ * Linux: the system bus, a session bus, or a private `dbus-daemon`.
+ * @param options The bus, the service name and how it is owned, the adapter's middlewares.
+ * @returns The adapter, to give to the `dbus` option of `buildEntrypoints()`.
+ * @throws {TypeError} At once, when the service name is invalid; when the adapter starts, when an action declared with
+ * `@DBusMethod` belongs to a controller without `@DBusInterface`.
+ * @throws {Error} When the adapter starts, if the bus cannot be reached, or if another connection owns the name
+ * (`The DBus name … is owned by another service`): the entrypoint fails to start.
+ * @example
+ * ```typescript
+ * import {Application} from 'lakutata'
+ * import {buildEntrypoints, Controller} from 'lakutata/com/entrypoint'
+ * import {dbusEntrypoint, DBusInterface, DBusMethod} from '@lakutata/dbus'
+ *
+ * @DBusInterface('com.example.Manager', {path: '/com/example/Manager'})
+ * class ManagerController extends Controller {
+ *     @DBusMethod('Ping', {returns: 's'})
+ *     public async ping(): Promise<string> {
+ *         return 'pong'
+ *     }
+ * }
+ *
+ * //busctl --system call com.example.DeviceService /com/example/Manager com.example.Manager Ping
+ * Application.run(() => ({
+ *     id: 'devices.app',
+ *     name: 'Devices',
+ *     components: {
+ *         entrypoint: buildEntrypoints({
+ *             controllers: [ManagerController],
+ *             dbus: dbusEntrypoint({bus: 'system', service: 'com.example.DeviceService'})
+ *         })
+ *     },
+ *     bootstrap: ['entrypoint']
+ * }))
+ * ```
+ */
+export function dbusEntrypoint(options) {
+    checkInterfaceName(options.service);
+    let service;
+    let detach;
+    const exported = new Map();
+    /**
+     * The interfaces of the controllers and of the actions, by path template
+     * @param runtime
+     */
+    const collect = (runtime) => {
+        const templates = new Map();
+        const interfacesAt = (path, name) => {
+            let template = templates.get(path);
+            if (!template) {
+                template = { template: compilePathTemplate(path), interfaces: new Map() };
+                templates.set(path, template);
+            }
+            let interfaces = template.interfaces.get(name);
+            if (!interfaces) {
+                interfaces = { methods: [] };
+                template.interfaces.set(name, interfaces);
+            }
+            return interfaces;
+        };
+        for (const controller of runtime.controllers) {
+            const declaration = getDBusInterfaceDeclaration(controller);
+            if (declaration)
+                interfacesAt(declaration.path, declaration.interface).declaration = declaration;
+        }
+        for (const action of runtime.actions) {
+            const { path, interface: interfaceName, member } = action.address;
+            if (path === undefined || interfaceName === undefined)
+                throw new TypeError(`The DBus method ${member} of ${action.controller} has no interface: declare its controller with @DBusInterface`);
+            interfacesAt(path, interfaceName).methods.push(action);
+        }
+        return templates;
+    };
+    /**
+     * The signature of the result of a method: its returns option, or the schema of @Return
+     * @param action
+     */
+    const resultSignature = (action) => {
+        if (action.address.returns !== undefined)
+            return action.address.returns;
+        return action.returnSchema ? schemaSignature(action.returnSchema) : undefined;
+    };
+    return {
+        channel: 'dbus',
+        definition: DBusChannel,
+        name: options.name,
+        middlewares: options.middlewares,
+        start: async (runtime) => {
+            const templates = collect(runtime);
+            const manager = await runtime.getObject(DBusObjectManager);
+            const localService = new LocalService(options.service);
+            service = localService;
+            /**
+             * Build the interface of an object
+             * @param path
+             * @param name
+             * @param served
+             * @param variables
+             * @param object
+             */
+            const buildInterface = (path, name, served, variables, object) => {
+                const localInterface = new LocalInterface(name);
+                for (const action of served.methods) {
+                    const returns = resultSignature(action);
+                    const hasInput = action.dto !== FlexibleDTO;
+                    localInterface.defineMethod({
+                        name: action.address.member,
+                        inputArgs: hasInput ? [{ name: 'input', type: 'a{sv}' }] : [],
+                        outputArgs: returns ? [{ name: 'output', type: returns }] : [],
+                        method: async (input) => {
+                            const context = new DBusContext({ path: path, interface: name, member: action.address.member, data: input && typeof input === 'object' ? input : {} });
+                            let result;
+                            try {
+                                result = await runtime.dispatchTo(action, context, { params: variables });
+                            }
+                            catch (error) {
+                                throw toMethodError(error);
+                            }
+                            if (!returns)
+                                return undefined;
+                            return toEncodable(returns === 'a{sv}' && (result === undefined || result === null) ? {} : result);
+                        }
+                    });
+                }
+                for (const property of served.declaration?.properties ?? []) {
+                    localInterface.defineProperty({
+                        name: property.name,
+                        type: property.type,
+                        getter: () => toEncodable(manager.getPropertyValue(path, property)),
+                        //A value written by a client is validated synchronously: its errors are given to the client
+                        setter: property.writable ? (value) => {
+                            let validated;
+                            try {
+                                validated = property.validate(value);
+                            }
+                            catch (error) {
+                                //The errors given to DBus are plain errors (the name of an exception is read only)
+                                throw toMethodError(error);
+                            }
+                            manager[STORE]({ path: path, interface: name, property: property, value: validated });
+                        } : undefined,
+                        emitPropertiesChanged: property.writable
+                    });
+                    object.properties.set(property, [...(object.properties.get(property) ?? []), name]);
+                }
+                for (const signal of served.declaration?.signals ?? []) {
+                    const emitter = new EventEmitter();
+                    localInterface.defineSignal({ name: signal.name, args: [{ name: 'data', type: signal.type }], eventEmitter: emitter });
+                    const signals = object.signals.get(signal.name) ?? [];
+                    signals.push({ signal: signal, emitter: emitter });
+                    object.signals.set(signal.name, signals);
+                }
+                return localInterface;
+            };
+            /**
+             * Export an object
+             * @param path
+             */
+            const addObject = (path) => {
+                if (exported.has(path))
+                    return true;
+                const object = { object: new LocalObject(path), signals: new Map(), properties: new Map() };
+                let served = false;
+                for (const { template, interfaces } of templates.values()) {
+                    const variables = template.match(path);
+                    if (!variables)
+                        continue;
+                    interfaces.forEach((interfaceServed, name) => object.object.addInterface(buildInterface(path, name, interfaceServed, variables, object)));
+                    served = true;
+                }
+                if (!served)
+                    return false;
+                exported.set(path, object);
+                localService.addObject(object.object);
+                return true;
+            };
+            //The objects of the paths without variables are exported at once, and kept until the adapter closes
+            const fixed = new Set();
+            for (const { template } of templates.values()) {
+                if (!template.static)
+                    continue;
+                fixed.add(template.template);
+                addObject(template.template);
+            }
+            const connect = connectOptions(options.bus ?? 'session');
+            let flags = RequestNameFlags.DBUS_NAME_FLAG_DO_NOT_QUEUE;
+            if (options.replaceExisting)
+                flags |= RequestNameFlags.DBUS_NAME_FLAG_REPLACE_EXISTING;
+            if (options.allowReplacement)
+                flags |= RequestNameFlags.DBUS_NAME_FLAG_ALLOW_REPLACEMENT;
+            const result = await localService.run({ ...connect, flags: flags });
+            if (result !== RequestNameResultCode.DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER && result !== RequestNameResultCode.DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER) {
+                await localService.stop().catch(() => undefined);
+                throw new Error(`The DBus name ${options.service} is owned by another service`);
+            }
+            const sink = {
+                addObject: addObject,
+                removeObject: (path) => {
+                    if (fixed.has(path) || !exported.delete(path))
+                        return false;
+                    return localService.removeObject(path);
+                },
+                isFixed: (path) => fixed.has(path),
+                emitSignal: (path, signal, data) => {
+                    const emitters = exported.get(path)?.signals.get(signal.name)?.filter((candidate) => candidate.signal === signal);
+                    if (!emitters?.length)
+                        return false;
+                    emitters.forEach(({ emitter }) => emitter.emit(signal.name, toEncodable(data)));
+                    return true;
+                },
+                propertyChanged: (path, property) => {
+                    const object = exported.get(path);
+                    const interfaces = object?.properties.get(property);
+                    if (!object || !interfaces)
+                        return;
+                    //The interfaces read the new value with their getters (the manager stored it), typed by the property
+                    interfaces.forEach((name) => object.object.getInterface(name)?.emitPropertiesChanged(property.name));
+                }
+            };
+            detach = manager[ATTACH](sink);
+        },
+        stop: async () => {
+            //The name is released: no new call reaches the service, the calls in progress end
+            detach?.();
+            detach = undefined;
+            await service?.dbus?.releaseName(options.service).catch(() => undefined);
+        },
+        close: async () => {
+            await service?.dbus?.disconnect().catch(() => undefined);
+            exported.clear();
+            service = undefined;
+        }
+    };
+}

package/dist/esm/channel/DBusChannel.js

@@ -0,0 +1,67 @@
+import { ControllerActionNotFoundException } from '@lakutata/entrypoint';
+import { defineChannel, getChannel, hasChannel } from '@lakutata/entrypoint/channel';
+import { DBUS_CONTEXT_TYPE } from '../context/DBusContext.js';
+import { checkInterfaceName, checkMemberName, checkPathTemplate, compilePathTemplate } from '../lib/Names.js';
+/**
+ * The key of the address of a method
+ * @param interfaceName
+ * @param member
+ * @param path
+ */
+function addressKey(interfaceName, member, path) {
+    return `${interfaceName}.${member}@${path}`;
+}
+/**
+ * The definition of the D-Bus channel of the entrypoint, named `dbus`: its actions are the methods of D-Bus interfaces,
+ * addressed by `{member, interface, path}` (the method name from `@DBusMethod`, the interface and the path template from
+ * `@DBusInterface`). A call matches an action by its interface, its method and its object path; a call matching none
+ * fails with `ControllerActionNotFoundException`. `@DBusMethod` and {@link dbusEntrypoint} use it: an application only
+ * needs it to write an adapter of its own.
+ */
+export const DBusChannel = hasChannel('dbus') ? getChannel('dbus') : defineChannel({
+    name: 'dbus',
+    kind: 'request',
+    contextType: DBUS_CONTEXT_TYPE,
+    validate: (pattern) => {
+        checkMemberName(pattern.member, 'method');
+        if (pattern.interface !== undefined)
+            checkInterfaceName(pattern.interface);
+        if (pattern.path !== undefined)
+            checkPathTemplate(pattern.path);
+        return pattern;
+    },
+    identify: (pattern) => addressKey(pattern.interface ?? '?', pattern.member, pattern.path ?? '?'),
+    describe: (pattern) => {
+        const { returns, ...address } = pattern;
+        return returns === undefined ? address : { ...address, returns: returns };
+    },
+    prefix: (prefix, pattern) => {
+        const dbus = prefix.dbus;
+        if (!dbus || (pattern.path !== undefined && pattern.interface !== undefined))
+            return undefined;
+        return { ...pattern, path: pattern.path ?? dbus.path, interface: pattern.interface ?? dbus.interface };
+    },
+    createMatcher: (entries) => {
+        const templates = entries
+            .filter((entry) => entry.details.pattern.path !== undefined)
+            .map((entry) => ({ entry: entry, template: compilePathTemplate(entry.details.pattern.path) }));
+        return {
+            match: (context) => {
+                const { path, interface: interfaceName, member } = context;
+                for (const { entry, template } of templates) {
+                    if (entry.details.pattern.interface !== interfaceName || entry.details.pattern.member !== member)
+                        continue;
+                    const params = template.match(path);
+                    if (params)
+                        return { entry: entry, params: params };
+                }
+                return undefined;
+            }
+        };
+    },
+    notFound: (context) => new ControllerActionNotFoundException('The DBus method {member} of the interface {interface} of {path} is not found', {
+        member: context.member,
+        interface: context.interface,
+        path: context.path
+    })
+});

package/dist/esm/components/DBusClientComponent.js

@@ -0,0 +1,267 @@
+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);
+};
+import { DBus } from 'dbus-sdk';
+import { Component, DTO } from '@lakutata/core';
+import { Configurable } from '@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())
+ *     })
+ * ```
+ */
+export const buildDBusClientOptions = (options) => ({
+    class: DBusClientComponent,
+    busAddress: options.busAddress,
+    timeout: options.timeout,
+    callTimeout: options.callTimeout,
+    decode: options.decode
+});
+/**
+ * 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))
+ *     })
+ * ```
+ */
+export class DBusClientComponent extends 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.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;
+    }
+}
+__decorate([
+    Configurable(DTO.String().required()),
+    __metadata("design:type", String)
+], DBusClientComponent.prototype, "busAddress", void 0);
+__decorate([
+    Configurable(DTO.Number().positive().integer().optional()),
+    __metadata("design:type", Number)
+], DBusClientComponent.prototype, "timeout", void 0);
+__decorate([
+    Configurable(DTO.Number().positive().integer().optional()),
+    __metadata("design:type", Number)
+], DBusClientComponent.prototype, "callTimeout", void 0);
+__decorate([
+    Configurable(DTO.Object({
+        types: DTO.String().valid('none', 'variants', 'all').optional(),
+        dictionaries: DTO.String().valid('object', 'map').optional(),
+        int64: DTO.String().valid('bigint', 'number').optional()
+    }).optional()),
+    __metadata("design:type", Object)
+], DBusClientComponent.prototype, "decode", void 0);