@lakutata/dbus 2.3.1 → 3.0.0-beta.0

package/dist/cjs/context/DBusContext.d.ts

@@ -0,0 +1,52 @@
+import { BaseContext } from '@lakutata/entrypoint';
+import { type DBusContextParams } from '../types/DBusContextParams.js';
+/**
+ * The `type` of every {@link DBusContext}: `'DBUS'`. A middleware or an access rule shared by several transports tells
+ * the D-Bus calls apart with it.
+ */
+export declare const DBUS_CONTEXT_TYPE: string;
+/**
+ * The context of a D-Bus method call: `this.context` of a controller action declared with `@DBusMethod` when a client
+ * calls it through {@link dbusEntrypoint}. The adapter creates one per call; its `data` is the call's input (the entries
+ * of its `a{sv}` dictionary). The variables of the object path template are not in the context: they are merged into
+ * the action's input, as the route parameters of HTTP.
+ * @example
+ * ```typescript
+ * import {Controller} from 'lakutata/com/entrypoint'
+ * import {DBusContext, DBusInterface, DBusMethod} from '@lakutata/dbus'
+ *
+ * @DBusInterface('com.example.Manager', {path: '/com/example/Manager'})
+ * class ManagerController extends Controller {
+ *     //Returns "com.example.Manager.Ping at /com/example/Manager"
+ *     @DBusMethod('Ping', {returns: 's'})
+ *     public async ping(): Promise<string> {
+ *         const context: DBusContext = this.context as DBusContext
+ *         return `${context.interface}.${context.member} at ${context.path}`
+ *     }
+ * }
+ * ```
+ */
+export declare class DBusContext<T extends Record<string, any> = {}> extends BaseContext<T> {
+    /**
+     * Always {@link DBUS_CONTEXT_TYPE} (`'DBUS'`).
+     */
+    readonly type: string;
+    /**
+     * The object path the client called (`'/com/example/Devices/A1'`).
+     */
+    readonly path: string;
+    /**
+     * The name of the interface the client called (`'com.example.Device'`).
+     */
+    readonly interface: string;
+    /**
+     * The name of the method the client called (`'Status'`).
+     */
+    readonly member: string;
+    /**
+     * Create the context of a method call, validating its properties.
+     * @param params The object path, the interface, the method and the input of the call.
+     * @throws {InvalidValueException} When a property is missing or invalid.
+     */
+    constructor(params: DBusContextParams);
+}

package/dist/cjs/context/DBusContext.js

@@ -0,0 +1,68 @@
+"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.DBusContext = exports.DBUS_CONTEXT_TYPE = void 0;
+const core_1 = require("@lakutata/core");
+const dto_1 = require("@lakutata/core/decorator/dto");
+const entrypoint_1 = require("@lakutata/entrypoint");
+/**
+ * The `type` of every {@link DBusContext}: `'DBUS'`. A middleware or an access rule shared by several transports tells
+ * the D-Bus calls apart with it.
+ */
+exports.DBUS_CONTEXT_TYPE = 'DBUS';
+/**
+ * The context of a D-Bus method call: `this.context` of a controller action declared with `@DBusMethod` when a client
+ * calls it through {@link dbusEntrypoint}. The adapter creates one per call; its `data` is the call's input (the entries
+ * of its `a{sv}` dictionary). The variables of the object path template are not in the context: they are merged into
+ * the action's input, as the route parameters of HTTP.
+ * @example
+ * ```typescript
+ * import {Controller} from 'lakutata/com/entrypoint'
+ * import {DBusContext, DBusInterface, DBusMethod} from '@lakutata/dbus'
+ *
+ * @DBusInterface('com.example.Manager', {path: '/com/example/Manager'})
+ * class ManagerController extends Controller {
+ *     //Returns "com.example.Manager.Ping at /com/example/Manager"
+ *     @DBusMethod('Ping', {returns: 's'})
+ *     public async ping(): Promise<string> {
+ *         const context: DBusContext = this.context as DBusContext
+ *         return `${context.interface}.${context.member} at ${context.path}`
+ *     }
+ * }
+ * ```
+ */
+class DBusContext extends entrypoint_1.BaseContext {
+    /**
+     * Create the context of a method call, validating its properties.
+     * @param params The object path, the interface, the method and the input of the call.
+     * @throws {InvalidValueException} When a property is missing or invalid.
+     */
+    constructor(params) {
+        super(params);
+    }
+}
+exports.DBusContext = DBusContext;
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().valid(exports.DBUS_CONTEXT_TYPE).default(exports.DBUS_CONTEXT_TYPE)),
+    __metadata("design:type", String)
+], DBusContext.prototype, "type", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], DBusContext.prototype, "path", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], DBusContext.prototype, "interface", void 0);
+__decorate([
+    (0, dto_1.Expect)(core_1.DTO.String().required()),
+    __metadata("design:type", String)
+], DBusContext.prototype, "member", void 0);

package/dist/cjs/decorators/DBusInterface.d.ts

@@ -0,0 +1,74 @@
+import type { Controller } from '@lakutata/entrypoint';
+import { type DBusPropertyDefinition, type DBusSignalDefinition } from '../lib/Declarations.js';
+/**
+ * The options of {@link DBusInterface}: where the interface is served, and its signals and properties.
+ */
+export type DBusInterfaceOptions = {
+    /**
+     * The object path of the interface. A path without variables (`'/com/example/Manager'`) is one object, exported
+     * while the adapter runs ({@link DBusObjectManager.removeObject} does not remove it). A template (`'/com/example/Devices/{sn}'`) serves the objects added with
+     * {@link DBusObjectManager.addObject} whose path matches it; its variables are merged into the input of the methods,
+     * as route parameters (they take precedence over the client's input). Its elements are letters, digits and `_`, or
+     * variables in braces; a variable matches one element.
+     */
+    path: string;
+    /**
+     * The signals of the interface, declared with {@link defineDBusSignal} and emitted with
+     * {@link DBusObjectManager.emitSignal}.
+     * @default []
+     */
+    signals?: DBusSignalDefinition<any>[];
+    /**
+     * The properties of the interface, declared with {@link defineDBusProperty} and set with
+     * {@link DBusObjectManager.setPropertyValue}.
+     * @default []
+     */
+    properties?: DBusPropertyDefinition<any>[];
+};
+/**
+ * Serve a controller as a D-Bus interface: its `@DBusMethod` actions are the interface's methods, and the signals and
+ * properties of the options are its other members, on the objects at `options.path`. The controllers declaring the same
+ * path are served by the same objects, each one interface; a subclass inherits the declaration of its parent class.
+ * The objects also implement `org.freedesktop.DBus.Properties`, `Introspectable` and `Peer`, and the root object `/`
+ * implements `ObjectManager`. Nothing is served until a {@link dbusEntrypoint} runs.
+ * @param name The name of the interface (`'com.example.Device'`): two or more elements separated by dots, made of
+ * letters, digits and `_`, not starting with a digit; 255 characters at most.
+ * @param options The object path (or template) of the interface, its signals and its properties.
+ * @returns The class decorator.
+ * @throws {TypeError} When the class is declared, if the name of the interface or the path is invalid.
+ * @example
+ * ```typescript
+ * import {DTO} from 'lakutata'
+ * import {Controller} from 'lakutata/com/entrypoint'
+ * import {Expect, Return} from 'lakutata/decorator/dto'
+ * import {DBusInterface, DBusMethod, defineDBusProperty, defineDBusSignal} from '@lakutata/dbus'
+ *
+ * class DeviceSnDTO extends DTO {
+ *     @Expect(DTO.String().required())
+ *     public sn: string
+ * }
+ *
+ * class StatusDTO extends DTO {
+ *     @Expect(DTO.String().required())
+ *     public sn: string
+ *
+ *     @Expect(DTO.Boolean().required())
+ *     public online: boolean
+ * }
+ *
+ * export const DeviceChanged = defineDBusSignal('Changed', StatusDTO)
+ * export const DeviceState = defineDBusProperty<string>('State', 's', {initial: 'idle'})
+ *
+ * //Served by the objects /com/example/Devices/A1, /com/example/Devices/B2… added with DBusObjectManager
+ * @DBusInterface('com.example.Device', {path: '/com/example/Devices/{sn}', signals: [DeviceChanged], properties: [DeviceState]})
+ * export class DeviceController extends Controller {
+ *     //The sn of the input is the one of the object path
+ *     @DBusMethod('Status', DeviceSnDTO)
+ *     @Return(StatusDTO)
+ *     public async status(input: DeviceSnDTO): Promise<StatusDTO> {
+ *         return {sn: input.sn, online: true} as StatusDTO
+ *     }
+ * }
+ * ```
+ */
+export declare function DBusInterface<ClassConstructor extends typeof Controller>(name: string, options: DBusInterfaceOptions): (target: ClassConstructor) => void;

package/dist/cjs/decorators/DBusInterface.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DBusInterface = DBusInterface;
+const channel_1 = require("@lakutata/entrypoint/channel");
+const Declarations_js_1 = require("../lib/Declarations.js");
+/**
+ * Serve a controller as a D-Bus interface: its `@DBusMethod` actions are the interface's methods, and the signals and
+ * properties of the options are its other members, on the objects at `options.path`. The controllers declaring the same
+ * path are served by the same objects, each one interface; a subclass inherits the declaration of its parent class.
+ * The objects also implement `org.freedesktop.DBus.Properties`, `Introspectable` and `Peer`, and the root object `/`
+ * implements `ObjectManager`. Nothing is served until a {@link dbusEntrypoint} runs.
+ * @param name The name of the interface (`'com.example.Device'`): two or more elements separated by dots, made of
+ * letters, digits and `_`, not starting with a digit; 255 characters at most.
+ * @param options The object path (or template) of the interface, its signals and its properties.
+ * @returns The class decorator.
+ * @throws {TypeError} When the class is declared, if the name of the interface or the path is invalid.
+ * @example
+ * ```typescript
+ * import {DTO} from 'lakutata'
+ * import {Controller} from 'lakutata/com/entrypoint'
+ * import {Expect, Return} from 'lakutata/decorator/dto'
+ * import {DBusInterface, DBusMethod, defineDBusProperty, defineDBusSignal} from '@lakutata/dbus'
+ *
+ * class DeviceSnDTO extends DTO {
+ *     @Expect(DTO.String().required())
+ *     public sn: string
+ * }
+ *
+ * class StatusDTO extends DTO {
+ *     @Expect(DTO.String().required())
+ *     public sn: string
+ *
+ *     @Expect(DTO.Boolean().required())
+ *     public online: boolean
+ * }
+ *
+ * export const DeviceChanged = defineDBusSignal('Changed', StatusDTO)
+ * export const DeviceState = defineDBusProperty<string>('State', 's', {initial: 'idle'})
+ *
+ * //Served by the objects /com/example/Devices/A1, /com/example/Devices/B2… added with DBusObjectManager
+ * @DBusInterface('com.example.Device', {path: '/com/example/Devices/{sn}', signals: [DeviceChanged], properties: [DeviceState]})
+ * export class DeviceController extends Controller {
+ *     //The sn of the input is the one of the object path
+ *     @DBusMethod('Status', DeviceSnDTO)
+ *     @Return(StatusDTO)
+ *     public async status(input: DeviceSnDTO): Promise<StatusDTO> {
+ *         return {sn: input.sn, online: true} as StatusDTO
+ *     }
+ * }
+ * ```
+ */
+function DBusInterface(name, options) {
+    return (target) => {
+        (0, Declarations_js_1.setDBusInterfaceDeclaration)(target, {
+            interface: name,
+            path: options.path,
+            signals: options.signals ?? [],
+            properties: options.properties ?? []
+        });
+        //The methods of the controller are addressed at its interface and its path
+        (0, channel_1.setPrefix)(target, { dbus: { path: options.path, interface: name } });
+    };
+}

package/dist/cjs/decorators/DBusMethod.d.ts

@@ -0,0 +1,115 @@
+import type { DTO, MethodDecorator } from '@lakutata/core';
+import type { Controller } from '@lakutata/entrypoint';
+import { ActionOptions } from '@lakutata/entrypoint/channel';
+import type { DBusContext } from '../context/DBusContext.js';
+/**
+ * The options of {@link DBusMethod}: the options of a controller action (`name`, `description`, `acl`, `rule`,
+ * `groups`, `middlewares`), with the D-Bus type of the method's result.
+ */
+export type DBusMethodOptions = ActionOptions<DBusContext> & {
+    /**
+     * The type of the method's result: a DTO (a dictionary of variants, `a{sv}`) or a D-Bus signature (`'s'`, `'b'`,
+     * `'x'`, `'v'`…). Without it, the type comes from the method's `@Return` schema: an object is `a{sv}`, a string
+     * `s`, a boolean `b`, an integer or a bigint `x`, another number `d`, an array `av`, any other value a variant `v`.
+     * @default the type of the `@Return` schema; without `@Return`, the method has no result
+     */
+    returns?: typeof DTO | string;
+};
+/**
+ * Serve a controller action as a method of the D-Bus interface its controller declares with `@DBusInterface`. A method
+ * with a DTO takes one argument, a dictionary of variants (`a{sv}`) holding the DTO's properties; a method without one
+ * takes no argument. The input goes through the entrypoint's middlewares, the DTO validation and the access control,
+ * as in the other channels, and the variables of the object path template are merged into it.
+ *
+ * The result is encoded with the type of `returns` or of `@Return` (the dates as ISO strings, the `null` and
+ * `undefined` values left out, since a variant has no null); a method with neither returns nothing. An error thrown by
+ * the action is answered as a D-Bus error named after its `errno` (or its name), prefixed by the service name
+ * (`com.example.DeviceService.E_OFFLINE`), with its message; an `errno` already containing dots is used as it is.
+ * The same method may also carry the decorators of the other channels (`@ServiceAction`, `@GET`…).
+ * @param name The name of the method (`'Reboot'`): letters, digits and `_`, not starting with a digit; 255 characters at
+ * most. Unique in its interface.
+ * @returns The method decorator.
+ * @throws {TypeError} When the method is declared, if its name is invalid; when the adapter starts, if its controller
+ * has no `@DBusInterface`.
+ * @example
+ * ```typescript
+ * import {DTO} from 'lakutata'
+ * import {Controller} from 'lakutata/com/entrypoint'
+ * import {Expect, Return} from 'lakutata/decorator/dto'
+ * import {DBusInterface, DBusMethod} from '@lakutata/dbus'
+ *
+ * class ConfigureDTO extends DTO {
+ *     @Expect(DTO.String().required())
+ *     public sn: string
+ *
+ *     @Expect(DTO.Number().integer().min(0).optional())
+ *     public retries?: number
+ * }
+ *
+ * @DBusInterface('com.example.Manager', {path: '/com/example/Manager'})
+ * export class ManagerController extends Controller {
+ *     //No argument, returns a string (s)
+ *     @DBusMethod('Ping', {returns: 's'})
+ *     public async ping(): Promise<string> {
+ *         return 'pong'
+ *     }
+ *
+ *     //One argument a{sv}, returns a dictionary a{sv} (the type of @Return)
+ *     @DBusMethod('Configure', ConfigureDTO, {description: 'Configure a device'})
+ *     @Return(ConfigureDTO)
+ *     public async configure(input: ConfigureDTO): Promise<ConfigureDTO> {
+ *         return input
+ *     }
+ *
+ *     //No result
+ *     @DBusMethod('Reset')
+ *     public async reset(): Promise<void> {
+ *     }
+ * }
+ * ```
+ */
+export declare function DBusMethod<ClassPrototype extends Controller, Method>(name: string): MethodDecorator<ClassPrototype, Method, any>;
+/**
+ * Serve a controller action as a method of the D-Bus interface its controller declares with `@DBusInterface`: its input
+ * is the DTO, given by the client as one dictionary of variants (`a{sv}`); its result has the type of `@Return`.
+ * The input goes through the entrypoint's middlewares, the DTO validation and the access control, and the variables
+ * of the object path template are merged into it. An error thrown by the action is answered as a D-Bus error named
+ * after its `errno`, prefixed by the service name (`com.example.DeviceService.E_OFFLINE`).
+ * @param name The name of the method (`'Reboot'`): letters, digits and `_`, not starting with a digit; 255 characters at
+ * most. Unique in its interface.
+ * @param dtoConstructor The DTO of the method's input, given by the client as an `a{sv}` dictionary.
+ * @returns The method decorator.
+ * @throws {TypeError} When the method is declared, if its name is invalid; when the adapter starts, if its controller
+ * has no `@DBusInterface`.
+ */
+export declare function DBusMethod<ClassPrototype extends Controller, Method, DTOConstructor extends typeof DTO = typeof DTO>(name: string, dtoConstructor: DTOConstructor): MethodDecorator<ClassPrototype, Method, any>;
+/**
+ * Serve a controller action as a method of the D-Bus interface its controller declares with `@DBusInterface`, with
+ * action options: it takes no argument; its result has the type of `returns` or of `@Return`.
+ * The input goes through the entrypoint's middlewares, the DTO validation and the access control, and the variables
+ * of the object path template are merged into it. An error thrown by the action is answered as a D-Bus error named
+ * after its `errno`, prefixed by the service name (`com.example.DeviceService.E_OFFLINE`).
+ * @param name The name of the method (`'Reboot'`): letters, digits and `_`, not starting with a digit; 255 characters at
+ * most. Unique in its interface.
+ * @param options The options of the action, and the type of its result (`returns`).
+ * @returns The method decorator.
+ * @throws {TypeError} When the method is declared, if its name is invalid; when the adapter starts, if its controller
+ * has no `@DBusInterface`.
+ */
+export declare function DBusMethod<ClassPrototype extends Controller, Method>(name: string, options: DBusMethodOptions): MethodDecorator<ClassPrototype, Method, any>;
+/**
+ * Serve a controller action as a method of the D-Bus interface its controller declares with `@DBusInterface`, with
+ * action options: its input is the DTO, given by the client as one dictionary of variants (`a{sv}`); its result has the
+ * type of `returns` or of `@Return`.
+ * The input goes through the entrypoint's middlewares, the DTO validation and the access control, and the variables
+ * of the object path template are merged into it. An error thrown by the action is answered as a D-Bus error named
+ * after its `errno`, prefixed by the service name (`com.example.DeviceService.E_OFFLINE`).
+ * @param name The name of the method (`'Reboot'`): letters, digits and `_`, not starting with a digit; 255 characters at
+ * most. Unique in its interface.
+ * @param dtoConstructor The DTO of the method's input, given by the client as an `a{sv}` dictionary.
+ * @param options The options of the action, and the type of its result (`returns`).
+ * @returns The method decorator.
+ * @throws {TypeError} When the method is declared, if its name is invalid; when the adapter starts, if its controller
+ * has no `@DBusInterface`.
+ */
+export declare function DBusMethod<ClassPrototype extends Controller, Method, DTOConstructor extends typeof DTO = typeof DTO>(name: string, dtoConstructor: DTOConstructor, options: DBusMethodOptions): MethodDecorator<ClassPrototype, Method, any>;

package/dist/cjs/decorators/DBusMethod.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DBusMethod = DBusMethod;
+const channel_1 = require("@lakutata/entrypoint/channel");
+const DBusChannel_js_1 = require("../channel/DBusChannel.js");
+const Signature_js_1 = require("../lib/Signature.js");
+function DBusMethod(name, dtoConstructorOrOptions, options) {
+    return (target, propertyKey, descriptor) => {
+        const isDTO = typeof dtoConstructorOrOptions === 'function';
+        const { returns, ...actionOptions } = (isDTO ? options : dtoConstructorOrOptions) ?? {};
+        const [dtoConstructor, validatedOptions] = isDTO
+            ? (0, channel_1.getActionDTOAndOptions)(dtoConstructorOrOptions, actionOptions)
+            : (0, channel_1.getActionDTOAndOptions)(actionOptions);
+        const pattern = { member: name };
+        if (returns !== undefined)
+            pattern.returns = typeof returns === 'string' ? returns : (0, Signature_js_1.schemaSignature)(returns);
+        (0, channel_1.registerControllerAction)(DBusChannel_js_1.DBusChannel, target, propertyKey, pattern, dtoConstructor, validatedOptions);
+        return descriptor;
+    };
+}

package/dist/cjs/exports/DBus.d.ts

@@ -0,0 +1,11 @@
+export { DBusChannel } from '../channel/DBusChannel.js';
+export { DBusContext, DBUS_CONTEXT_TYPE } from '../context/DBusContext.js';
+export { type DBusContextParams } from '../types/DBusContextParams.js';
+export { DBusInterface, type DBusInterfaceOptions } from '../decorators/DBusInterface.js';
+export { DBusMethod, type DBusMethodOptions } from '../decorators/DBusMethod.js';
+export { defineDBusSignal, defineDBusProperty, type DBusSignalDefinition, type DBusPropertyDefinition, type DBusPropertyOptions, type DBusInterfaceDeclaration } from '../lib/Declarations.js';
+export { dbusEntrypoint, type DBusEntrypointOptions } from '../adapters/DBusEntrypoint.js';
+export { DBusObjectManager, type DBusPropertyWrite } from '../components/DBusObjectManager.js';
+export { DBusClientComponent, buildDBusClientOptions } from '../components/DBusClientComponent.js';
+export type { DBusClientOptions } from '../lib/DBusClientOptions.js';
+export { DBus, DBusInterface as DBusRemoteInterface, DBusObject, DBusService, LocalInterface, LocalObject, LocalService, createDBusError, DBusSignedValue, DBusSignalEmitter, Signature, RequestNameFlags, RequestNameResultCode, type BusNameBasicInfo, type ConnectOpts, type DecodeOpts, type InvokeOpts } from 'dbus-sdk';

package/dist/cjs/exports/DBus.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestNameResultCode = exports.RequestNameFlags = exports.Signature = exports.DBusSignalEmitter = exports.DBusSignedValue = exports.createDBusError = exports.LocalService = exports.LocalObject = exports.LocalInterface = exports.DBusService = exports.DBusObject = exports.DBusRemoteInterface = exports.DBus = exports.buildDBusClientOptions = exports.DBusClientComponent = exports.DBusObjectManager = exports.dbusEntrypoint = exports.defineDBusProperty = exports.defineDBusSignal = exports.DBusMethod = exports.DBusInterface = exports.DBUS_CONTEXT_TYPE = exports.DBusContext = exports.DBusChannel = void 0;
+//The DBus channel: the controllers served as the interfaces of the DBus objects
+var DBusChannel_js_1 = require("../channel/DBusChannel.js");
+Object.defineProperty(exports, "DBusChannel", { enumerable: true, get: function () { return DBusChannel_js_1.DBusChannel; } });
+var DBusContext_js_1 = require("../context/DBusContext.js");
+Object.defineProperty(exports, "DBusContext", { enumerable: true, get: function () { return DBusContext_js_1.DBusContext; } });
+Object.defineProperty(exports, "DBUS_CONTEXT_TYPE", { enumerable: true, get: function () { return DBusContext_js_1.DBUS_CONTEXT_TYPE; } });
+var DBusInterface_js_1 = require("../decorators/DBusInterface.js");
+Object.defineProperty(exports, "DBusInterface", { enumerable: true, get: function () { return DBusInterface_js_1.DBusInterface; } });
+var DBusMethod_js_1 = require("../decorators/DBusMethod.js");
+Object.defineProperty(exports, "DBusMethod", { enumerable: true, get: function () { return DBusMethod_js_1.DBusMethod; } });
+var Declarations_js_1 = require("../lib/Declarations.js");
+Object.defineProperty(exports, "defineDBusSignal", { enumerable: true, get: function () { return Declarations_js_1.defineDBusSignal; } });
+Object.defineProperty(exports, "defineDBusProperty", { enumerable: true, get: function () { return Declarations_js_1.defineDBusProperty; } });
+var DBusEntrypoint_js_1 = require("../adapters/DBusEntrypoint.js");
+Object.defineProperty(exports, "dbusEntrypoint", { enumerable: true, get: function () { return DBusEntrypoint_js_1.dbusEntrypoint; } });
+var DBusObjectManager_js_1 = require("../components/DBusObjectManager.js");
+Object.defineProperty(exports, "DBusObjectManager", { enumerable: true, get: function () { return DBusObjectManager_js_1.DBusObjectManager; } });
+//The DBus client
+var DBusClientComponent_js_1 = require("../components/DBusClientComponent.js");
+Object.defineProperty(exports, "DBusClientComponent", { enumerable: true, get: function () { return DBusClientComponent_js_1.DBusClientComponent; } });
+Object.defineProperty(exports, "buildDBusClientOptions", { enumerable: true, get: function () { return DBusClientComponent_js_1.buildDBusClientOptions; } });
+//The DBus SDK
+var dbus_sdk_1 = require("dbus-sdk");
+Object.defineProperty(exports, "DBus", { enumerable: true, get: function () { return dbus_sdk_1.DBus; } });
+Object.defineProperty(exports, "DBusRemoteInterface", { enumerable: true, get: function () { return dbus_sdk_1.DBusInterface; } });
+Object.defineProperty(exports, "DBusObject", { enumerable: true, get: function () { return dbus_sdk_1.DBusObject; } });
+Object.defineProperty(exports, "DBusService", { enumerable: true, get: function () { return dbus_sdk_1.DBusService; } });
+Object.defineProperty(exports, "LocalInterface", { enumerable: true, get: function () { return dbus_sdk_1.LocalInterface; } });
+Object.defineProperty(exports, "LocalObject", { enumerable: true, get: function () { return dbus_sdk_1.LocalObject; } });
+Object.defineProperty(exports, "LocalService", { enumerable: true, get: function () { return dbus_sdk_1.LocalService; } });
+Object.defineProperty(exports, "createDBusError", { enumerable: true, get: function () { return dbus_sdk_1.createDBusError; } });
+Object.defineProperty(exports, "DBusSignedValue", { enumerable: true, get: function () { return dbus_sdk_1.DBusSignedValue; } });
+Object.defineProperty(exports, "DBusSignalEmitter", { enumerable: true, get: function () { return dbus_sdk_1.DBusSignalEmitter; } });
+Object.defineProperty(exports, "Signature", { enumerable: true, get: function () { return dbus_sdk_1.Signature; } });
+Object.defineProperty(exports, "RequestNameFlags", { enumerable: true, get: function () { return dbus_sdk_1.RequestNameFlags; } });
+Object.defineProperty(exports, "RequestNameResultCode", { enumerable: true, get: function () { return dbus_sdk_1.RequestNameResultCode; } });
+
+//The default of the entry: the entry itself (scripts/package-build/cjs-package.mjs)
+if (!Object.prototype.hasOwnProperty.call(exports, 'default')) Object.defineProperty(exports, 'default', {value: exports})

package/dist/cjs/lib/DBusClientOptions.d.ts

@@ -0,0 +1,30 @@
+import type { DecodeOpts } from 'dbus-sdk';
+/**
+ * The options of {@link buildDBusClientOptions}: the bus a {@link DBusClientComponent} connects to, and how it decodes
+ * the replies.
+ */
+export interface DBusClientOptions {
+    /**
+     * The address of the bus: `'unix:path=/var/run/dbus/system_bus_socket'` (the system bus),
+     * `'unix:path=/run/user/1000/bus'`, `'tcp:host=127.0.0.1,port=5555'`; the value of `DBUS_SESSION_BUS_ADDRESS` for
+     * the session bus.
+     */
+    busAddress: string;
+    /**
+     * How long the connection to the bus may take, in milliseconds (a positive integer).
+     * @default 20000
+     */
+    timeout?: number;
+    /**
+     * How long a call may wait for its reply, in milliseconds (a positive integer); a call's own `timeout` overrides it.
+     * @default dbus-sdk's default
+     */
+    callTimeout?: number;
+    /**
+     * How the replies and the signals are decoded (`DecodeOpts` of `dbus-sdk`): `types` (`'none'`, `'variants'`,
+     * `'all'`: where the values keep their D-Bus types as typed values), `dictionaries` (`'object'` or `'map'`),
+     * `int64` (`'number'` or `'bigint'`).
+     * @default {int64: 'number'} (the 64-bit integers as numbers when they are safe integers, else bigints)
+     */
+    decode?: DecodeOpts;
+}