matterbridge 3.4.7-dev-20260103-3152357 → 3.4.7-dev-20260112-a00b2bf

package/dist/matterbridgeEndpointTypes.d.ts

@@ -0,0 +1,96 @@
+import { Semtag } from '@matter/types/globals';
+import { ClusterId, EndpointNumber } from '@matter/types/datatype';
+import { HandlerFunction } from '@matter/general';
+import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
+import { DeviceTypeDefinition } from './matterbridgeDeviceTypes.js';
+export type PrimitiveTypes = boolean | number | bigint | string | object | undefined | null;
+export type CommandHandlerData = {
+    request: Record<string, any>;
+    cluster: string;
+    attributes: Record<string, PrimitiveTypes>;
+    endpoint: MatterbridgeEndpoint;
+};
+export type CommandHandlerFunction = (data: CommandHandlerData) => void | Promise<void>;
+export interface MatterbridgeEndpointCommands {
+    identify: HandlerFunction;
+    triggerEffect: HandlerFunction;
+    on: HandlerFunction;
+    off: HandlerFunction;
+    toggle: HandlerFunction;
+    offWithEffect: HandlerFunction;
+    moveToLevel: HandlerFunction;
+    moveToLevelWithOnOff: HandlerFunction;
+    moveToColor: HandlerFunction;
+    moveColor: HandlerFunction;
+    stepColor: HandlerFunction;
+    moveToHue: HandlerFunction;
+    moveHue: HandlerFunction;
+    stepHue: HandlerFunction;
+    enhancedMoveToHue: HandlerFunction;
+    enhancedMoveHue: HandlerFunction;
+    enhancedStepHue: HandlerFunction;
+    moveToSaturation: HandlerFunction;
+    moveSaturation: HandlerFunction;
+    stepSaturation: HandlerFunction;
+    moveToHueAndSaturation: HandlerFunction;
+    enhancedMoveToHueAndSaturation: HandlerFunction;
+    moveToColorTemperature: HandlerFunction;
+    upOrOpen: HandlerFunction;
+    downOrClose: HandlerFunction;
+    stopMotion: HandlerFunction;
+    goToLiftPercentage: HandlerFunction;
+    goToTiltPercentage: HandlerFunction;
+    lockDoor: HandlerFunction;
+    unlockDoor: HandlerFunction;
+    setpointRaiseLower: HandlerFunction;
+    setActivePresetRequest: HandlerFunction;
+    step: HandlerFunction;
+    changeToMode: HandlerFunction;
+    open: HandlerFunction;
+    close: HandlerFunction;
+    suppressAlarm: HandlerFunction;
+    enableDisableAlarm: HandlerFunction;
+    selfTestRequest: HandlerFunction;
+    resetCounts: HandlerFunction;
+    setUtcTime: HandlerFunction;
+    setTimeZone: HandlerFunction;
+    setDstOffset: HandlerFunction;
+    pauseRequest: HandlerFunction;
+    resumeRequest: HandlerFunction;
+    pause: HandlerFunction;
+    stop: HandlerFunction;
+    start: HandlerFunction;
+    resume: HandlerFunction;
+    goHome: HandlerFunction;
+    selectAreas: HandlerFunction;
+    boost: HandlerFunction;
+    cancelBoost: HandlerFunction;
+    enableCharging: HandlerFunction;
+    disable: HandlerFunction;
+    powerAdjustRequest: HandlerFunction;
+    cancelPowerAdjustRequest: HandlerFunction;
+    setTemperature: HandlerFunction;
+    setCookingParameters: HandlerFunction;
+    addMoreTime: HandlerFunction;
+    resetCondition: HandlerFunction;
+}
+export interface SerializedMatterbridgeEndpoint {
+    pluginName: string;
+    deviceName: string;
+    serialNumber: string;
+    uniqueId: string;
+    productId?: number;
+    productName?: string;
+    vendorId?: number;
+    vendorName?: string;
+    deviceTypes: DeviceTypeDefinition[];
+    number: EndpointNumber | undefined;
+    id: string | undefined;
+    clusterServersId: ClusterId[];
+}
+export interface MatterbridgeEndpointOptions {
+    tagList?: Semtag[];
+    mode?: 'server' | 'matter';
+    id?: string;
+    number?: EndpointNumber;
+}

package/dist/matterbridgePlatform.d.ts

@@ -0,0 +1,114 @@
+import { AnsiLogger, LogLevel } from 'node-ansi-logger';
+import { NodeStorage } from 'node-persist-manager';
+import { EndpointNumber, VendorId } from '@matter/types/datatype';
+import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
+import { ApiSelectDevice, ApiSelectEntity } from './frontendTypes.js';
+import { SystemInformation } from './matterbridgeTypes.js';
+export type PlatformConfigValue = string | number | boolean | bigint | object | undefined | null;
+export type PlatformConfig = {
+    name: string;
+    type: string;
+    version: string;
+    debug: boolean;
+    unregisterOnShutdown: boolean;
+} & Record<string, PlatformConfigValue>;
+export type PlatformSchemaValue = string | number | boolean | bigint | object | undefined | null;
+export type PlatformSchema = Record<string, PlatformSchemaValue>;
+export type PlatformMatterbridge = {
+    readonly systemInformation: Readonly<Pick<SystemInformation, 'interfaceName' | 'macAddress' | 'ipv4Address' | 'ipv6Address' | 'nodeVersion' | 'hostname' | 'user' | 'osType' | 'osRelease' | 'osPlatform' | 'osArch' | 'totalMemory' | 'freeMemory' | 'systemUptime' | 'processUptime' | 'cpuUsage' | 'processCpuUsage' | 'rss' | 'heapTotal' | 'heapUsed'>>;
+    readonly rootDirectory: string;
+    readonly homeDirectory: string;
+    readonly matterbridgeDirectory: string;
+    readonly matterbridgePluginDirectory: string;
+    readonly matterbridgeCertDirectory: string;
+    readonly globalModulesDirectory: string;
+    readonly matterbridgeVersion: string;
+    readonly matterbridgeLatestVersion: string;
+    readonly matterbridgeDevVersion: string;
+    readonly frontendVersion: string;
+    readonly bridgeMode: 'bridge' | 'childbridge' | 'controller' | '';
+    readonly restartMode: 'service' | 'docker' | '';
+    readonly virtualMode: 'disabled' | 'outlet' | 'light' | 'switch' | 'mounted_switch';
+    readonly aggregatorVendorId: VendorId;
+    readonly aggregatorVendorName: string;
+    readonly aggregatorProductId: number;
+    readonly aggregatorProductName: string;
+};
+export declare class MatterbridgePlatform {
+    #private;
+    readonly matterbridge: PlatformMatterbridge;
+    readonly log: AnsiLogger;
+    config: PlatformConfig;
+    name: string;
+    type: 'DynamicPlatform' | 'AccessoryPlatform' | 'AnyPlatform';
+    version: string;
+    context?: NodeStorage;
+    isReady: boolean;
+    isLoaded: boolean;
+    isStarted: boolean;
+    isConfigured: boolean;
+    isShuttingDown: boolean;
+    readonly ready: Promise<void>;
+    private setMatterNode;
+    protected constructor(matterbridge: PlatformMatterbridge, log: AnsiLogger, config: PlatformConfig);
+    private destroy;
+    onStart(reason?: string): Promise<void>;
+    onConfigure(): Promise<void>;
+    onShutdown(reason?: string): Promise<void>;
+    onChangeLoggerLevel(logLevel: LogLevel): Promise<void>;
+    onAction(action: string, value?: string, id?: string, formData?: PlatformConfig): Promise<void>;
+    onConfigChanged(config: PlatformConfig): Promise<void>;
+    saveConfig(config: PlatformConfig): void;
+    getSchema(): Promise<PlatformSchema | undefined>;
+    setSchema(schema: PlatformSchema): void;
+    wssSendRestartRequired(snackbar?: boolean, fixed?: boolean): void;
+    wssSendSnackbarMessage(message: string, timeout?: number, severity?: 'error' | 'success' | 'info' | 'warning'): void;
+    size(): number;
+    getDevices(): MatterbridgeEndpoint[];
+    getDeviceByName(deviceName: string): MatterbridgeEndpoint | undefined;
+    getDeviceByUniqueId(uniqueId: string): MatterbridgeEndpoint | undefined;
+    getDeviceBySerialNumber(serialNumber: string): MatterbridgeEndpoint | undefined;
+    getDeviceById(id: string): MatterbridgeEndpoint | undefined;
+    getDeviceByOriginalId(originalId: string): MatterbridgeEndpoint | undefined;
+    getDeviceByNumber(number: EndpointNumber | number): MatterbridgeEndpoint | undefined;
+    hasDeviceName(deviceName: string): boolean;
+    hasDeviceUniqueId(deviceUniqueId: string): boolean;
+    registerVirtualDevice(name: string, type: 'light' | 'outlet' | 'switch' | 'mounted_switch', callback: () => Promise<void>): Promise<boolean>;
+    registerDevice(device: MatterbridgeEndpoint): Promise<void>;
+    unregisterDevice(device: MatterbridgeEndpoint): Promise<void>;
+    unregisterAllDevices(delay?: number): Promise<void>;
+    private saveSelects;
+    clearSelect(): Promise<void>;
+    clearDeviceSelect(serial: string): Promise<void>;
+    clearEntitySelect(name: string): Promise<void>;
+    setSelectDevice(serial: string, name: string, configUrl?: string, icon?: string, entities?: {
+        name: string;
+        description: string;
+        icon?: string;
+    }[]): void;
+    getSelectDevice(serial: string): {
+        serial: string;
+        name: string;
+        configUrl?: string;
+        icon?: string;
+        entities?: {
+            name: string;
+            description: string;
+            icon?: string;
+        }[];
+    } | undefined;
+    setSelectDeviceEntity(serial: string, entityName: string, entityDescription: string, entityIcon?: string): void;
+    getSelectDevices(): ApiSelectDevice[];
+    setSelectEntity(name: string, description: string, icon?: string): void;
+    getSelectEntity(name: string): {
+        name: string;
+        description: string;
+        icon?: string | undefined;
+    } | undefined;
+    getSelectEntities(): ApiSelectEntity[];
+    verifyMatterbridgeVersion(requiredVersion: string, destroy?: boolean): boolean;
+    validateDevice(device: string | string[], log?: boolean): boolean;
+    validateEntity(device: string, entity: string, log?: boolean): boolean;
+    private clearEndpointNumbers;
+    private checkEndpointNumbers;
+}

package/dist/matterbridgeTypes.d.ts

@@ -0,0 +1,206 @@
+import type { NodeStorage } from 'node-persist-manager';
+import type { LogLevel } from 'node-ansi-logger';
+import type { ServerNode, Endpoint as EndpointNode } from '@matter/node';
+import type { StorageContext } from '@matter/general';
+import type { FabricIndex, VendorId, EndpointNumber, Semtag } from '@matter/types';
+import type { AggregatorEndpoint } from '@matter/node/endpoints/aggregator';
+import type { AdministratorCommissioning } from '@matter/types/clusters/administrator-commissioning';
+import type { Matterbridge } from './matterbridge.js';
+import type { MatterbridgePlatform, PlatformConfig, PlatformSchema } from './matterbridgePlatform.js';
+import type { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
+export declare const plg = "\u001B[38;5;33m";
+export declare const dev = "\u001B[38;5;79m";
+export declare const typ = "\u001B[38;5;207m";
+export declare const MATTERBRIDGE_LOGGER_FILE = "matterbridge.log";
+export declare const MATTER_LOGGER_FILE = "matter.log";
+export declare const NODE_STORAGE_DIR = "storage";
+export declare const MATTER_STORAGE_NAME = "matterstorage";
+export declare const MATTERBRIDGE_DIAGNOSTIC_FILE = "diagnostic.log";
+export declare const MATTERBRIDGE_HISTORY_FILE = "history.html";
+export type MaybePromise<T> = T | Promise<T>;
+export type SharedMatterbridge = Readonly<Pick<Matterbridge, 'systemInformation' | 'rootDirectory' | 'homeDirectory' | 'matterbridgeDirectory' | 'matterbridgePluginDirectory' | 'matterbridgeCertDirectory' | 'globalModulesDirectory' | 'matterbridgeVersion' | 'matterbridgeLatestVersion' | 'matterbridgeDevVersion' | 'frontendVersion' | 'bridgeMode' | 'restartMode' | 'virtualMode' | 'profile' | 'logLevel' | 'fileLogger' | 'matterLogLevel' | 'matterFileLogger' | 'mdnsInterface' | 'ipv4Address' | 'ipv6Address' | 'port' | 'discriminator' | 'passcode' | 'shellySysUpdate' | 'shellyMainUpdate'>>;
+export type PluginName = string;
+export interface Plugin extends ApiPlugin {
+    nodeContext?: NodeStorage;
+    storageContext?: StorageContext;
+    serverNode?: ServerNode<ServerNode.RootEndpoint>;
+    aggregatorNode?: EndpointNode<AggregatorEndpoint>;
+    device?: MatterbridgeEndpoint;
+    platform?: MatterbridgePlatform;
+    reachabilityTimeout?: NodeJS.Timeout;
+}
+export interface ApiPlugin extends StoragePlugin {
+    latestVersion?: string;
+    devVersion?: string;
+    homepage?: string;
+    help?: string;
+    changelog?: string;
+    funding?: string;
+    locked?: boolean;
+    error?: boolean;
+    loaded?: boolean;
+    started?: boolean;
+    configured?: boolean;
+    restartRequired?: boolean;
+    registeredDevices?: number;
+    configJson?: PlatformConfig;
+    schemaJson?: PlatformSchema;
+    hasWhiteList?: boolean;
+    hasBlackList?: boolean;
+    matter?: ApiMatter;
+}
+export interface StoragePlugin {
+    name: string;
+    path: string;
+    type: 'DynamicPlatform' | 'AccessoryPlatform' | 'AnyPlatform';
+    version: string;
+    description: string;
+    author: string;
+    enabled: boolean;
+}
+export interface SystemInformation {
+    interfaceName: string;
+    macAddress: string;
+    ipv4Address: string;
+    ipv6Address: string;
+    nodeVersion: string;
+    hostname: string;
+    user: string;
+    osType: string;
+    osRelease: string;
+    osPlatform: string;
+    osArch: string;
+    totalMemory: string;
+    freeMemory: string;
+    systemUptime: string;
+    processUptime: string;
+    cpuUsage: string;
+    processCpuUsage: string;
+    rss: string;
+    heapTotal: string;
+    heapUsed: string;
+}
+export interface MatterbridgeInformation {
+    rootDirectory: string;
+    homeDirectory: string;
+    matterbridgeDirectory: string;
+    matterbridgePluginDirectory: string;
+    matterbridgeCertDirectory: string;
+    globalModulesDirectory: string;
+    matterbridgeVersion: string;
+    matterbridgeLatestVersion: string;
+    matterbridgeDevVersion: string;
+    frontendVersion: string;
+    bridgeMode: string;
+    restartMode: string;
+    virtualMode: 'disabled' | 'outlet' | 'light' | 'switch' | 'mounted_switch';
+    profile: string | undefined;
+    readOnly: boolean;
+    shellyBoard: boolean;
+    shellySysUpdate: boolean;
+    shellyMainUpdate: boolean;
+    loggerLevel: LogLevel;
+    fileLogger: boolean;
+    matterLoggerLevel: number;
+    matterFileLogger: boolean;
+    matterMdnsInterface: string | undefined;
+    matterIpv4Address: string | undefined;
+    matterIpv6Address: string | undefined;
+    matterPort: number;
+    matterDiscriminator: number | undefined;
+    matterPasscode: number | undefined;
+    restartRequired: boolean;
+    fixedRestartRequired: boolean;
+    updateRequired: boolean;
+}
+export interface SanitizedExposedFabricInformation {
+    fabricIndex: FabricIndex;
+    fabricId: string;
+    nodeId: string;
+    rootNodeId: string;
+    rootVendorId: VendorId;
+    rootVendorName: string;
+    label: string;
+}
+export interface SanitizedSession {
+    name: string;
+    nodeId: string;
+    peerNodeId: string;
+    fabric?: SanitizedExposedFabricInformation;
+    isPeerActive: boolean;
+    lastInteractionTimestamp: string;
+    lastActiveTimestamp: string;
+    numberOfActiveSubscriptions: number;
+}
+export interface ApiDevice {
+    pluginName: string;
+    type: string;
+    endpoint: EndpointNumber | undefined;
+    name: string;
+    serial: string;
+    productUrl: string;
+    configUrl?: string;
+    uniqueId: string;
+    reachable: boolean;
+    powerSource?: 'ac' | 'dc' | 'ok' | 'warning' | 'critical';
+    batteryLevel?: number;
+    cluster: string;
+    matter?: ApiMatter;
+}
+export interface BaseDevice {
+    mode: 'server' | 'matter' | undefined;
+    plugin: string | undefined;
+    configUrl: string | undefined;
+    deviceName: string | undefined;
+    serialNumber: string | undefined;
+    uniqueId: string | undefined;
+    vendorId: number | undefined;
+    vendorName: string | undefined;
+    productId: number | undefined;
+    productName: string | undefined;
+    softwareVersion: number | undefined;
+    softwareVersionString: string | undefined;
+    hardwareVersion: number | undefined;
+    hardwareVersionString: string | undefined;
+    productUrl: string;
+    tagList: Semtag[] | undefined;
+    originalId: string | undefined;
+    name: string | undefined;
+    deviceType: number | undefined;
+    number: EndpointNumber | undefined;
+    id: string | undefined;
+}
+export interface ApiMatter {
+    id: string;
+    online: boolean;
+    commissioned: boolean;
+    advertising: boolean;
+    advertiseTime: number;
+    windowStatus: AdministratorCommissioning.CommissioningWindowStatus;
+    fabricInformations: SanitizedExposedFabricInformation[];
+    sessionInformations: SanitizedSession[];
+    qrPairingCode: string;
+    manualPairingCode: string;
+    serialNumber: string | undefined;
+}
+export interface ApiClusters {
+    plugin: string;
+    deviceName: string;
+    serialNumber: string;
+    number: EndpointNumber;
+    id: string;
+    deviceTypes: number[];
+    clusters: Cluster[];
+}
+export interface Cluster {
+    endpoint: string;
+    number: EndpointNumber;
+    id: string;
+    deviceTypes: number[];
+    clusterName: string;
+    clusterId: string;
+    attributeName: string;
+    attributeId: string;
+    attributeValue: string;
+    attributeLocalValue: unknown;
+}

package/dist/pluginManager.d.ts

@@ -0,0 +1,67 @@
+import EventEmitter from 'node:events';
+import { LogLevel } from 'node-ansi-logger';
+import type { Matterbridge } from './matterbridge.js';
+import type { MatterbridgePlatform, PlatformConfig, PlatformSchema } from './matterbridgePlatform.js';
+import { ApiPlugin, Plugin, PluginName, StoragePlugin } from './matterbridgeTypes.js';
+interface PluginManagerEvents {
+    added: [name: string];
+    removed: [name: string];
+    loaded: [name: string];
+    enabled: [name: string];
+    disabled: [name: string];
+    installed: [name: string, version: string | undefined];
+    uninstalled: [name: string];
+    started: [name: string];
+    configured: [name: string];
+    shutdown: [name: string];
+}
+export declare class PluginManager extends EventEmitter<PluginManagerEvents> {
+    private readonly matterbridge;
+    private readonly _plugins;
+    private readonly log;
+    private readonly server;
+    private readonly debug;
+    private readonly verbose;
+    constructor(matterbridge: Matterbridge);
+    destroy(): void;
+    private msgHandler;
+    get length(): number;
+    get size(): number;
+    has(name: string): boolean;
+    get(name: string): Plugin | undefined;
+    set(plugin: Plugin): Plugin;
+    clear(): void;
+    private toStoragePlugin;
+    private toApiPlugin;
+    array(): Plugin[];
+    storagePluginArray(): StoragePlugin[];
+    apiPluginArray(): ApiPlugin[];
+    [Symbol.iterator](): MapIterator<Plugin>;
+    forEach(callback: (plugin: Plugin) => Promise<void>): Promise<void>;
+    set logLevel(logLevel: LogLevel);
+    loadFromStorage(): Promise<StoragePlugin[]>;
+    saveToStorage(): Promise<number>;
+    resolve(nameOrPath: string): Promise<string | null>;
+    install(packageName: string): Promise<boolean>;
+    uninstall(packageName: string): Promise<boolean>;
+    getAuthor(packageJson: Record<string, string | number | Record<string, string | number | object>>): string;
+    getHomepage(packageJson: Record<string, string | number | Record<string, string | number | object>>): string | undefined;
+    getHelp(packageJson: Record<string, string | number | Record<string, string | number | object>>): string | undefined;
+    getChangelog(packageJson: Record<string, string | number | Record<string, string | number | object>>): string | undefined;
+    getFunding(packageJson: Record<string, any>): string | undefined;
+    parse(plugin: Plugin | PluginName): Promise<Record<string, string | number | object> | null>;
+    enable(nameOrPath: string): Promise<Plugin | null>;
+    disable(nameOrPath: string): Promise<Plugin | null>;
+    remove(nameOrPath: string): Promise<Plugin | null>;
+    add(nameOrPath: string): Promise<Plugin | null>;
+    load(plugin: Plugin | PluginName, start?: boolean, message?: string, configure?: boolean): Promise<MatterbridgePlatform | undefined>;
+    start(plugin: Plugin | PluginName, message?: string, configure?: boolean): Promise<Plugin | undefined>;
+    configure(plugin: Plugin | PluginName): Promise<Plugin | undefined>;
+    shutdown(plugin: Plugin | PluginName, reason?: string, removeAllDevices?: boolean, force?: boolean): Promise<Plugin | undefined>;
+    loadConfig(plugin: Plugin): Promise<PlatformConfig>;
+    saveConfigFromPlugin(plugin: Plugin, restartRequired?: boolean): Promise<void>;
+    saveConfigFromJson(plugin: Plugin, config: PlatformConfig, restartRequired?: boolean): Promise<void>;
+    loadSchema(plugin: Plugin): Promise<PlatformSchema>;
+    getDefaultSchema(plugin: Plugin): PlatformSchema;
+}
+export {};

package/dist/shelly.d.ts

@@ -0,0 +1,24 @@
+import { AnsiLogger } from 'node-ansi-logger';
+import { Matterbridge } from './matterbridge.js';
+import { BroadcastServer } from './broadcastServer.js';
+import { SharedMatterbridge } from './matterbridgeTypes.js';
+export declare function setVerifyIntervalSecs(seconds: number): void;
+export declare function setVerifyTimeoutSecs(seconds: number): void;
+export declare function getShellySysUpdate(matterbridge: SharedMatterbridge, log: AnsiLogger, server: BroadcastServer): Promise<void>;
+export declare function triggerShellySysUpdate(matterbridge: Matterbridge): Promise<void>;
+export declare function getShellyMainUpdate(matterbridge: SharedMatterbridge, log: AnsiLogger, server: BroadcastServer): Promise<void>;
+export declare function triggerShellyMainUpdate(matterbridge: Matterbridge): Promise<void>;
+export declare function verifyShellyUpdate(matterbridge: Matterbridge, api: string, name: string): Promise<void>;
+export declare function triggerShellyChangeIp(matterbridge: Matterbridge, config: {
+    type: 'static' | 'dhcp';
+    ip: string;
+    subnet: string;
+    gateway: string;
+    dns: string;
+}): Promise<void>;
+export declare function triggerShellyReboot(matterbridge: Matterbridge): Promise<void>;
+export declare function triggerShellySoftReset(matterbridge: Matterbridge): Promise<void>;
+export declare function triggerShellyHardReset(matterbridge: Matterbridge): Promise<void>;
+export declare function createShellySystemLog(matterbridge: Matterbridge): Promise<boolean>;
+export declare function getShelly(api: string, timeout?: number): Promise<any>;
+export declare function postShelly(api: string, data: any, timeout?: number): Promise<any>;

package/dist/storage/export.d.ts

@@ -0,0 +1 @@
+export * from 'node-persist-manager';

package/dist/update.d.ts

@@ -0,0 +1,9 @@
+import { AnsiLogger } from 'node-ansi-logger';
+import { ApiPlugin, SharedMatterbridge } from './matterbridgeTypes.js';
+import { BroadcastServer } from './broadcastServer.js';
+export declare function checkUpdates(matterbridge: SharedMatterbridge): Promise<void>;
+export declare function checkUpdatesAndLog(matterbridge: SharedMatterbridge, log: AnsiLogger, server: BroadcastServer): Promise<void>;
+export declare function getMatterbridgeLatestVersion(matterbridge: SharedMatterbridge, log: AnsiLogger, server: BroadcastServer): Promise<string | undefined>;
+export declare function getMatterbridgeDevVersion(matterbridge: SharedMatterbridge, log: AnsiLogger, server: BroadcastServer): Promise<string | undefined>;
+export declare function getPluginLatestVersion(log: AnsiLogger, server: BroadcastServer, plugin: ApiPlugin): Promise<string | undefined>;
+export declare function getPluginDevVersion(log: AnsiLogger, server: BroadcastServer, plugin: ApiPlugin): Promise<string | undefined>;

package/dist/utils/colorUtils.d.ts

@@ -0,0 +1,24 @@
+export interface RGB {
+    r: number;
+    g: number;
+    b: number;
+}
+export interface XY {
+    x: number;
+    y: number;
+}
+export interface HSL {
+    h: number;
+    s: number;
+    l: number;
+}
+export declare function hslColorToRgbColor(hue: number, saturation: number, luminance: number): RGB;
+export declare function rgbColorToXYColor(rgb: RGB): XY;
+export declare function xyColorToRgbColor(x: number, y: number, brightness?: number): RGB;
+export declare function rgbColorToHslColor(rgb: RGB): HSL;
+export declare function xyToHsl(x: number, y: number): HSL;
+export declare function miredToKelvin(mired: number): number;
+export declare const miredsToKelvin: typeof miredToKelvin;
+export declare function kelvinToMired(kelvin: number): number;
+export declare const kelvinToMireds: typeof kelvinToMired;
+export declare function kelvinToRGB(kelvin: number): RGB;

package/dist/utils/commandLine.d.ts

@@ -0,0 +1,6 @@
+export declare function hasParameter(name: string): boolean;
+export declare function hasAnyParameter(...params: string[]): boolean;
+export declare function getParameter(name: string): string | undefined;
+export declare function getIntParameter(name: string): number | undefined;
+export declare function getIntArrayParameter(name: string): number[] | undefined;
+export declare function getStringArrayParameter(name: string): string[] | undefined;

package/dist/utils/copyDirectory.d.ts

@@ -0,0 +1,2 @@
+import { AnsiLogger } from 'node-ansi-logger';
+export declare function copyDirectory(srcDir: string, destDir: string, log?: AnsiLogger): Promise<boolean>;

package/dist/utils/createDirectory.d.ts

@@ -0,0 +1,2 @@
+import { Logger } from 'node-ansi-logger';
+export declare function createDirectory(path: string, name: string, log: Logger): Promise<void>;

package/dist/utils/createZip.d.ts

@@ -0,0 +1 @@
+export declare function createZip(outputPath: string, ...sourcePaths: string[]): Promise<number>;

package/dist/utils/deepCopy.d.ts

@@ -0,0 +1 @@
+export declare function deepCopy<T>(value: T): T;

package/dist/utils/deepEqual.d.ts

@@ -0,0 +1 @@
+export declare function deepEqual(a: any, b: any, excludeProperties?: string[]): boolean;

package/dist/utils/error.d.ts

@@ -0,0 +1,3 @@
+import { type AnsiLogger } from 'node-ansi-logger';
+export declare function logError(log: AnsiLogger, message: string, error: unknown): void;
+export declare function inspectError(log: AnsiLogger, message: string, error: unknown): string;

package/dist/utils/export.d.ts

@@ -0,0 +1,12 @@
+export * from './network.js';
+export * from './commandLine.js';
+export * from './isValid.js';
+export * from './colorUtils.js';
+export * from './deepCopy.js';
+export * from './deepEqual.js';
+export * from './copyDirectory.js';
+export * from './createDirectory.js';
+export * from './createZip.js';
+export * from './wait.js';
+export * from './hex.js';
+export * from './error.js';

package/dist/utils/format.d.ts

@@ -0,0 +1,4 @@
+export declare function formatTimeStamp(timestamp: number): string;
+export declare function formatPercent(percent: number, digits?: number): string;
+export declare function formatBytes(bytes: number, digits?: number): string;
+export declare function formatUptime(seconds: number): string;

package/dist/utils/hex.d.ts

@@ -0,0 +1,4 @@
+export declare function bufferToHex(buffer: ArrayBufferLike): string;
+export declare function hexToBuffer(hex: string): Uint8Array;
+export declare function pemToBuffer(pem: string, validate?: boolean): Uint8Array;
+export declare function extractPrivateKeyRaw(pemPrivateKey: string): Uint8Array;

package/dist/utils/inspector.d.ts

@@ -0,0 +1,24 @@
+import EventEmitter from 'node:events';
+interface InspectorEvents {
+    start: [];
+    stop: [];
+    snapshot: [];
+    snapshot_done: [];
+    gc: [type?: 'major' | 'minor', execution?: 'sync' | 'async'];
+    gc_done: [type: 'major' | 'minor', execution: 'sync' | 'async'];
+}
+export declare class Inspector extends EventEmitter<InspectorEvents> {
+    private readonly name;
+    private readonly debug;
+    private readonly verbose;
+    private session;
+    private snapshotInterval?;
+    private snapshotInProgress;
+    private log;
+    constructor(name?: string, debug?: boolean, verbose?: boolean);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    takeHeapSnapshot(): Promise<void>;
+    runGarbageCollector(type?: 'major' | 'minor', execution?: 'sync' | 'async'): void;
+}
+export {};

package/dist/utils/isValid.d.ts

@@ -0,0 +1,10 @@
+export declare function isValidIpv4Address(ipv4Address: string): boolean;
+export declare function isValidNumber(value: unknown, min?: number, max?: number): value is number;
+export declare function isValidBoolean(value: unknown): value is boolean;
+export declare function isValidString(value: unknown, minLength?: number, maxLength?: number): value is string;
+export declare function isValidRegExp(value: unknown): value is RegExp;
+export declare function isValidObject(value: unknown, minLength?: number, maxLength?: number): value is object;
+export declare function isValidArray(value: unknown, minLength?: number, maxLength?: number): value is unknown[];
+export declare function isValidNull(value: unknown): value is null;
+export declare function isValidUndefined(value: unknown): value is undefined;
+export declare function parseVersionString(versionString: string): number | undefined;