matterbridge 3.4.7-dev-20260104-6b10cee → 3.4.7-dev-20260112-a00b2bf

package/dist/matterNode.d.ts

@@ -0,0 +1,84 @@
+import EventEmitter from 'node:events';
+import '@matter/nodejs';
+import { Diagnostic, StorageContext, StorageManager, StorageService } from '@matter/general';
+import { DeviceCertification, ExposedFabricInformation, MdnsService } from '@matter/protocol';
+import { VendorId, DeviceTypeId } from '@matter/types';
+import { ServerNode, Endpoint, SessionsBehavior } from '@matter/node';
+import { AggregatorEndpoint } from '@matter/node/endpoints/aggregator';
+import type { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
+import { SharedMatterbridge, ApiMatter, Plugin, SanitizedExposedFabricInformation, SanitizedSession, PluginName } from './matterbridgeTypes.js';
+import { WorkerMessage } from './broadcastServerTypes.js';
+import { PluginManager } from './pluginManager.js';
+interface MatterEvents {
+    ready: [nodeId: string];
+    online: [nodeId: string];
+    offline: [nodeId: string];
+    closed: [];
+}
+export declare class MatterNode extends EventEmitter<MatterEvents> {
+    private readonly matterbridge;
+    private readonly pluginName?;
+    private readonly device?;
+    private readonly log;
+    private readonly matterLog;
+    private readonly environment;
+    storeId: string | undefined;
+    matterMdnsService: MdnsService | undefined;
+    matterStorageService: StorageService | undefined;
+    matterStorageManager: StorageManager | undefined;
+    matterStorageContext: StorageContext | undefined;
+    mdnsInterface: string | undefined;
+    ipv4Address: string | undefined;
+    ipv6Address: string | undefined;
+    port: number | undefined;
+    passcode: number | undefined;
+    discriminator: number | undefined;
+    certification: DeviceCertification.Configuration | undefined;
+    serverNode: ServerNode<ServerNode.RootEndpoint> | undefined;
+    aggregatorNode: Endpoint<AggregatorEndpoint> | undefined;
+    aggregatorVendorId: VendorId;
+    aggregatorVendorName: string;
+    aggregatorProductId: number;
+    aggregatorProductName: string;
+    aggregatorDeviceType: DeviceTypeId;
+    aggregatorSerialNumber: string | undefined;
+    aggregatorUniqueId: string | undefined;
+    advertisingNodes: Map<string, number>;
+    readonly pluginManager: PluginManager;
+    readonly dependantMatterNodes: Map<string, MatterNode>;
+    private readonly server;
+    private readonly debug;
+    private readonly verbose;
+    constructor(matterbridge: SharedMatterbridge, pluginName?: PluginName | undefined, device?: MatterbridgeEndpoint | undefined);
+    msgHandler(msg: WorkerMessage): Promise<void>;
+    destroy(closeMdns?: boolean): Promise<void>;
+    create(): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    createDestinationMatterLogger(): (text: string, message: Diagnostic.Message) => void;
+    startMatterStorage(): Promise<void>;
+    backupMatterStorage(storageName: string, backupName: string): Promise<void>;
+    stopMatterStorage(): Promise<void>;
+    createServerNodeContext(storeId: string, deviceName: string, deviceType: DeviceTypeId, vendorId: VendorId, vendorName: string, productId: number, productName: string, serialNumber?: string, uniqueId?: string): Promise<StorageContext>;
+    createServerNode(port?: number, passcode?: number, discriminator?: number): Promise<ServerNode<ServerNode.RootEndpoint>>;
+    getServerNodeData(serverNode: ServerNode<ServerNode.RootEndpoint>): ApiMatter;
+    startServerNode(timeout?: number): Promise<void>;
+    stopServerNode(timeout?: number): Promise<void>;
+    createAggregatorNode(): Promise<Endpoint<AggregatorEndpoint>>;
+    createMatterbridgeServerNode(): Promise<ServerNode<ServerNode.RootEndpoint>>;
+    createAccessoryPlugin(plugin: Plugin | PluginName, device: MatterbridgeEndpoint): Promise<ServerNode<ServerNode.RootEndpoint> | undefined>;
+    createDynamicPlugin(plugin: Plugin | PluginName): Promise<ServerNode<ServerNode.RootEndpoint> | undefined>;
+    createDeviceServerNode(plugin: Plugin | PluginName, device: MatterbridgeEndpoint): Promise<ServerNode<ServerNode.RootEndpoint> | undefined>;
+    addBridgedEndpoint(pluginName: string, device: MatterbridgeEndpoint): Promise<MatterbridgeEndpoint | undefined>;
+    removeBridgedEndpoint(pluginName: string, device: MatterbridgeEndpoint): Promise<MatterbridgeEndpoint | undefined>;
+    removeAllBridgedEndpoints(pluginName: string, delay?: number): Promise<void>;
+    addVirtualEndpoint(pluginName: string, name: string, type: 'light' | 'outlet' | 'switch' | 'mounted_switch', callback: () => Promise<void>): Promise<boolean>;
+    subscribeAttributeChanged(plugin: Plugin, device: MatterbridgeEndpoint): Promise<void>;
+    sanitizeFabricInformations(fabricInfo: ExposedFabricInformation[]): SanitizedExposedFabricInformation[];
+    sanitizeSessionInformation(sessions: SessionsBehavior.Session[]): SanitizedSession[];
+    setServerReachability(reachable: boolean): Promise<void>;
+    setAggregatorReachability(aggregatorNode: Endpoint<AggregatorEndpoint>, reachable: boolean): Promise<void>;
+    getVendorIdName: (vendorId: number | undefined) => string;
+    yieldToNode(timeout?: number): Promise<void>;
+}
+export {};

package/dist/matterbridge.d.ts

@@ -0,0 +1,152 @@
+import EventEmitter from 'node:events';
+import { AnsiLogger, LogLevel } from 'node-ansi-logger';
+import { NodeStorageManager, NodeStorage } from 'node-persist-manager';
+import '@matter/nodejs';
+import { StorageContext, StorageManager, StorageService } from '@matter/general';
+import { DeviceCertification } from '@matter/protocol';
+import { Endpoint, ServerNode } from '@matter/node';
+import { DeviceTypeId, VendorId } from '@matter/types/datatype';
+import { AggregatorEndpoint } from '@matter/node/endpoints';
+import { ApiMatter, MaybePromise, SystemInformation } from './matterbridgeTypes.js';
+import { PluginManager } from './pluginManager.js';
+import { DeviceManager } from './deviceManager.js';
+import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
+import { Frontend } from './frontend.js';
+interface MatterbridgeEvents {
+    shutdown: [];
+    restart: [];
+    update: [];
+    initialize_started: [];
+    initialize_completed: [];
+    online: [nodeid: string];
+    offline: [nodeid: string];
+    bridge_started: [];
+    childbridge_started: [];
+    cleanup_started: [];
+    cleanup_completed: [];
+    startmemorycheck: [];
+    stopmemorycheck: [];
+    startinspector: [];
+    stopinspector: [];
+    takeheapsnapshot: [];
+    triggergarbagecollection: [];
+}
+export declare class Matterbridge extends EventEmitter<MatterbridgeEvents> {
+    systemInformation: SystemInformation;
+    homeDirectory: string;
+    rootDirectory: string;
+    matterbridgeDirectory: string;
+    matterbridgePluginDirectory: string;
+    matterbridgeCertDirectory: string;
+    globalModulesDirectory: string;
+    matterbridgeVersion: string;
+    matterbridgeLatestVersion: string;
+    matterbridgeDevVersion: string;
+    frontendVersion: string;
+    bridgeMode: 'bridge' | 'childbridge' | 'controller' | '';
+    restartMode: 'service' | 'docker' | '';
+    virtualMode: 'disabled' | 'outlet' | 'light' | 'switch' | 'mounted_switch';
+    readonly profile: string | undefined;
+    readonly log: AnsiLogger;
+    logLevel: LogLevel;
+    fileLogger: boolean;
+    readonly matterLog: AnsiLogger;
+    matterLogLevel: LogLevel;
+    matterFileLogger: boolean;
+    readonly readOnly: boolean;
+    readonly shellyBoard: boolean;
+    shellySysUpdate: boolean;
+    shellyMainUpdate: boolean;
+    restartRequired: boolean;
+    fixedRestartRequired: boolean;
+    updateRequired: boolean;
+    readonly plugins: PluginManager;
+    readonly devices: DeviceManager;
+    readonly frontend: Frontend;
+    nodeStorage: NodeStorageManager | undefined;
+    nodeContext: NodeStorage | undefined;
+    protected static instance: Matterbridge | undefined;
+    shutdown: boolean;
+    private readonly failCountLimit;
+    hasCleanupStarted: boolean;
+    private initialized;
+    private startMatterInterval;
+    private readonly startMatterIntervalMs;
+    private checkUpdateInterval;
+    private checkUpdateTimeout;
+    private configureTimeout;
+    private reachabilityTimeout;
+    private sigintHandler;
+    private sigtermHandler;
+    private exceptionHandler;
+    private rejectionHandler;
+    private readonly environment;
+    matterStorageService: StorageService | undefined;
+    matterStorageManager: StorageManager | undefined;
+    matterbridgeContext: StorageContext | undefined;
+    controllerContext: StorageContext | undefined;
+    mdnsInterface: string | undefined;
+    ipv4Address: string | undefined;
+    ipv6Address: string | undefined;
+    port: number | undefined;
+    passcode: number | undefined;
+    discriminator: number | undefined;
+    certification: DeviceCertification.Configuration | undefined;
+    serverNode: ServerNode<ServerNode.RootEndpoint> | undefined;
+    aggregatorNode: Endpoint<AggregatorEndpoint> | undefined;
+    aggregatorVendorId: VendorId;
+    aggregatorVendorName: string;
+    aggregatorProductId: number;
+    aggregatorProductName: string;
+    aggregatorDeviceType: DeviceTypeId;
+    aggregatorSerialNumber: string | undefined;
+    aggregatorUniqueId: string | undefined;
+    advertisingNodes: Map<string, number>;
+    private readonly server;
+    private readonly verbose;
+    private constructor();
+    destroy(): void;
+    private msgHandler;
+    static loadInstance(initialize?: boolean): Promise<Matterbridge>;
+    private initialize;
+    private parseCommandLine;
+    private startPlugins;
+    private registerProcessHandlers;
+    private deregisterProcessHandlers;
+    private logNodeAndSystemInfo;
+    setLogLevel(logLevel: LogLevel): Promise<LogLevel>;
+    getLogLevel(): MaybePromise<LogLevel>;
+    private createDestinationMatterLogger;
+    restartProcess(): Promise<void>;
+    shutdownProcess(): Promise<void>;
+    updateProcess(): Promise<void>;
+    unregisterAndShutdownProcess(timeout?: number): Promise<void>;
+    shutdownProcessAndReset(): Promise<void>;
+    shutdownProcessAndFactoryReset(): Promise<void>;
+    private cleanup;
+    private startBridge;
+    private startChildbridge;
+    private startController;
+    private startMatterStorage;
+    private backupMatterStorage;
+    private stopMatterStorage;
+    private createServerNodeContext;
+    private createServerNode;
+    getServerNodeData(serverNode: ServerNode<ServerNode.RootEndpoint>): ApiMatter;
+    private startServerNode;
+    private stopServerNode;
+    private createAggregatorNode;
+    private createAccessoryPlugin;
+    private createDynamicPlugin;
+    private createDeviceServerNode;
+    addBridgedEndpoint(pluginName: string, device: MatterbridgeEndpoint): Promise<void>;
+    removeBridgedEndpoint(pluginName: string, device: MatterbridgeEndpoint): Promise<void>;
+    removeAllBridgedEndpoints(pluginName: string, delay?: number): Promise<void>;
+    addVirtualEndpoint(pluginName: string, name: string, type: 'light' | 'outlet' | 'switch' | 'mounted_switch', callback: () => Promise<void>): Promise<boolean>;
+    private subscribeAttributeChanged;
+    private sanitizeFabricInformations;
+    private sanitizeSessionInformation;
+    private setAggregatorReachability;
+    private getVendorIdName;
+}
+export {};

package/dist/matterbridgeAccessoryPlatform.d.ts

@@ -0,0 +1,5 @@
+import { AnsiLogger } from 'node-ansi-logger';
+import { MatterbridgePlatform, PlatformConfig, PlatformMatterbridge } from './matterbridgePlatform.js';
+export declare class MatterbridgeAccessoryPlatform extends MatterbridgePlatform {
+    constructor(matterbridge: PlatformMatterbridge, log: AnsiLogger, config: PlatformConfig);
+}