@matterbridge/core 3.9.0 → 3.9.1-dev-20260614-18d1a2e

package/dist/jestutils/jestDeviceManagerSpy.js

@@ -1,5 +1,5 @@
-import { jest } from '@jest/globals';
 import { DeviceManager } from '../deviceManager.js';
+const { jest } = await import('@jest/globals');
 export const destroyDeviceManagerSpy = jest.spyOn(DeviceManager.prototype, 'destroy');
 export const lengthDeviceManagerSpy = jest.spyOn(DeviceManager.prototype, 'length', 'get');
 export const sizeDeviceManagerSpy = jest.spyOn(DeviceManager.prototype, 'size', 'get');

package/dist/jestutils/jestFrontendSpy.d.ts

@@ -1,9 +1,7 @@
-export declare const wssSendSnackbarMessageFrontendSpy: import("jest-mock").SpiedFunction<(message: string, timeout?: number, severity?: "info" | "warning" | "error" | "success") => void>;
-export declare const wssSendCloseSnackbarMessageFrontendSpy: import("jest-mock").SpiedFunction<(message: string) => void>;
-export declare const wssSendUpdateRequiredFrontendSpy: import("jest-mock").SpiedFunction<(devVersion?: boolean) => void>;
-export declare const wssSendRefreshRequiredFrontendSpy: import("jest-mock").SpiedFunction<(changed: import("@matterbridge/types").RefreshRequiredChanged, params?: {
-    matter?: import("@matterbridge/types").ApiMatter;
-    lock?: string;
-}) => void>;
-export declare const wssSendRestartRequiredFrontendSpy: import("jest-mock").SpiedFunction<(snackbar?: boolean, fixed?: boolean) => void>;
-export declare const wssSendRestartNotRequiredFrontendSpy: import("jest-mock").SpiedFunction<(snackbar?: boolean) => void>;
+import { Frontend } from '../frontend.js';
+export declare const wssSendSnackbarMessageFrontendSpy: jest.SpiedFunction<typeof Frontend.prototype.wssSendSnackbarMessage>;
+export declare const wssSendCloseSnackbarMessageFrontendSpy: jest.SpiedFunction<typeof Frontend.prototype.wssSendCloseSnackbarMessage>;
+export declare const wssSendUpdateRequiredFrontendSpy: jest.SpiedFunction<typeof Frontend.prototype.wssSendUpdateRequired>;
+export declare const wssSendRefreshRequiredFrontendSpy: jest.SpiedFunction<typeof Frontend.prototype.wssSendRefreshRequired>;
+export declare const wssSendRestartRequiredFrontendSpy: jest.SpiedFunction<typeof Frontend.prototype.wssSendRestartRequired>;
+export declare const wssSendRestartNotRequiredFrontendSpy: jest.SpiedFunction<typeof Frontend.prototype.wssSendRestartNotRequired>;

package/dist/jestutils/jestFrontendSpy.js

@@ -1,5 +1,5 @@
-import { jest } from '@jest/globals';
 import { Frontend } from '../frontend.js';
+const { jest } = await import('@jest/globals');
 export const wssSendSnackbarMessageFrontendSpy = jest.spyOn(Frontend.prototype, 'wssSendSnackbarMessage');
 export const wssSendCloseSnackbarMessageFrontendSpy = jest.spyOn(Frontend.prototype, 'wssSendCloseSnackbarMessage');
 export const wssSendUpdateRequiredFrontendSpy = jest.spyOn(Frontend.prototype, 'wssSendUpdateRequired');

package/dist/jestutils/jestMatterTest.d.ts

@@ -5,7 +5,7 @@ import { AggregatorEndpoint } from '@matter/node/endpoints';
 import { DeviceTypeId } from '@matter/types/datatype';
 import { type PlatformMatterbridge } from '@matterbridge/types';
 export declare let environment: Environment;
-export declare let server: ServerNode<ServerNode.RootEndpoint>;
+export declare let server: ServerNode;
 export declare let aggregator: Endpoint<AggregatorEndpoint>;
 export declare function createTestEnvironment(): Promise<Environment>;
 export declare function destroyTestEnvironment(): Promise<void>;
@@ -13,9 +13,9 @@ export declare function getPlatformMatterbridge(): PlatformMatterbridge;
 export declare function flushAllEndpointNumberPersistence(targetServer: ServerNode, rounds?: number, ticks?: number, microTurns?: number, pause?: number): Promise<void>;
 export declare function assertAllEndpointNumbersPersisted(targetServer: ServerNode): Promise<number>;
 export declare function closeServerNodeStores(targetServer?: ServerNode): Promise<void>;
-export declare function createServerNode(port: number, deviceType?: DeviceTypeId, ticks?: number, microTurns?: number, pause?: number): Promise<[ServerNode<ServerNode.RootEndpoint>, Endpoint<AggregatorEndpoint>]>;
-export declare function startServerNode(ticks?: number, microTurns?: number, pause?: number): Promise<[ServerNode<ServerNode.RootEndpoint>, Endpoint<AggregatorEndpoint>]>;
+export declare function createServerNode(port: number, deviceType?: DeviceTypeId, ticks?: number, microTurns?: number, pause?: number): Promise<[ServerNode, Endpoint<AggregatorEndpoint>]>;
+export declare function startServerNode(ticks?: number, microTurns?: number, pause?: number): Promise<[ServerNode, Endpoint<AggregatorEndpoint>]>;
 export declare function stopServerNode(ticks?: number, microTurns?: number, pause?: number): Promise<void>;
 export declare function flushServerNode(ticks?: number, microTurns?: number, pause?: number): Promise<void>;
-export declare function addDevice(owner: ServerNode<ServerNode.RootEndpoint> | Endpoint<AggregatorEndpoint>, device: Endpoint, rounds?: number, pause?: number): Promise<boolean>;
-export declare function deleteDevice(owner: ServerNode<ServerNode.RootEndpoint> | Endpoint<AggregatorEndpoint>, device: Endpoint, rounds?: number, pause?: number): Promise<boolean>;
+export declare function addDevice(owner: ServerNode | Endpoint<AggregatorEndpoint>, device: Endpoint, rounds?: number, pause?: number): Promise<boolean>;
+export declare function deleteDevice(owner: ServerNode | Endpoint<AggregatorEndpoint>, device: Endpoint, rounds?: number, pause?: number): Promise<boolean>;

package/dist/jestutils/jestMatterTest.js

@@ -56,10 +56,10 @@ export function getPlatformMatterbridge() {
         matterbridgePluginDirectory: path.join(HOMEDIR, 'Matterbridge'),
         matterbridgeCertDirectory: path.join(HOMEDIR, '.mattercert'),
         globalModulesDirectory: path.join(HOMEDIR, 'node_modules'),
-        matterbridgeVersion: '3.9.0',
-        matterbridgeLatestVersion: '3.9.0',
-        matterbridgeDevVersion: '3.9.0',
-        frontendVersion: '3.9.0',
+        matterbridgeVersion: '3.9.1',
+        matterbridgeLatestVersion: '3.9.1',
+        matterbridgeDevVersion: '3.9.1',
+        frontendVersion: '3.9.1',
         bridgeMode: '',
         restartMode: '',
         virtualMode: 'mounted_switch',

package/dist/jestutils/jestMatterbridgeEndpointSpy.d.ts

@@ -1,55 +1,7 @@
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
-export declare const setClusterMatterbridgeEndpointSpy: import("jest-mock").SpiedFunction<{
-    <T extends import("@matter/node").Behavior.Type>(cluster: T, value: import("@matter/node").Behavior.StateOf<T>, log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
-    <T extends import("@matter/types").ClusterType>(cluster: T, value: Partial<T["Typing"] extends {
-        Attributes: infer Attributes;
-    } ? Attributes : {}>, log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
-    (cluster: import("@matter/types").ClusterId | string, value: Record<string, boolean | number | bigint | string | object | undefined | null>, log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
-}>;
-export declare const setAttributeMatterbridgeEndpointSpy: import("jest-mock").SpiedFunction<{
-    <T extends import("@matter/node").Behavior.Type, A extends keyof import("@matter/node").Behavior.StateOf<T>>(clusterId: T, attribute: A, value: import("@matter/node").Behavior.StateOf<T>[A], log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
-    <T extends import("@matter/types").ClusterType, A extends keyof (T["Typing"] extends {
-        Attributes: infer Attributes;
-    } ? Attributes : {})>(clusterId: T, attribute: A, value: (T["Typing"] extends {
-        Attributes: infer Attributes;
-    } ? Attributes : {})[A], log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
-    (clusterId: import("@matter/types").ClusterId | string, attribute: string, value: boolean | number | bigint | string | object | null, log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
-}>;
-export declare const updateAttributeMatterbridgeEndpointSpy: import("jest-mock").SpiedFunction<{
-    <T extends import("@matter/node").Behavior.Type, A extends keyof import("@matter/node").Behavior.StateOf<T>>(cluster: T, attribute: A, value: import("@matter/node").Behavior.StateOf<T>[A], log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
-    <T extends import("@matter/types").ClusterType, A extends keyof (T["Typing"] extends {
-        Attributes: infer Attributes;
-    } ? Attributes : {})>(cluster: T, attribute: A, value: (T["Typing"] extends {
-        Attributes: infer Attributes;
-    } ? Attributes : {})[A], log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
-    (cluster: import("@matter/types").ClusterId | string, attribute: string, value: boolean | number | bigint | string | object | null, log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
-}>;
-export declare const subscribeAttributeMatterbridgeEndpointSpy: import("jest-mock").SpiedFunction<{
-    <T extends import("@matter/node").Behavior.Type, A extends keyof import("@matter/node").Behavior.StateOf<T>>(cluster: T, attribute: A, listener: (newValue: import("@matter/node").Behavior.StateOf<T>[A], oldValue: import("@matter/node").Behavior.StateOf<T>[A], context: import("@matter/node").ActionContext) => void, log?: import("node-ansi-logger").AnsiLogger): MatterbridgeEndpoint;
-    <T extends import("@matter/types").ClusterType, A extends keyof (T["Typing"] extends {
-        Attributes: infer Attributes;
-    } ? Attributes : {})>(cluster: T, attribute: A, listener: (newValue: (T["Typing"] extends {
-        Attributes: infer Attributes;
-    } ? Attributes : {})[A], oldValue: (T["Typing"] extends {
-        Attributes: infer Attributes;
-    } ? Attributes : {})[A], context: import("@matter/node").ActionContext) => void, log?: import("node-ansi-logger").AnsiLogger): MatterbridgeEndpoint;
-    (cluster: import("@matter/types").ClusterId | string, attribute: string, listener: (newValue: any, oldValue: any, context: import("@matter/node").ActionContext) => void, log?: import("node-ansi-logger").AnsiLogger): MatterbridgeEndpoint;
-}>;
-export declare const triggerEventMatterbridgeEndpointSpy: import("jest-mock").SpiedFunction<{
-    <T extends import("@matter/node").Behavior.Type, E extends keyof ((T extends {
-        Interface: infer N extends import("@matter/types").ClusterTyping;
-    } ? N : import("@matter/types").ClusterTyping)["Events"] & {}) & string>(cluster: T, event: E, payload: E extends keyof ((T extends {
-        Interface: infer N extends import("@matter/types").ClusterTyping;
-    } ? N : import("@matter/types").ClusterTyping)["Events"] & {}) & string ? ((T extends {
-        Interface: infer N extends import("@matter/types").ClusterTyping;
-    } ? N : import("@matter/types").ClusterTyping)["Events"] & {})[E] : never, log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
-    <T extends import("@matter/types").ClusterType, E extends keyof (T["Typing"] extends {
-        Events: infer Events;
-    } ? Events : Record<string, never>) & string>(cluster: T, event: E, payload: E extends keyof (T["Typing"] extends {
-        Events: infer Events;
-    } ? Events : Record<string, never>) ? (T["Typing"] extends {
-        Events: infer Events;
-    } ? Events : Record<string, never>)[E] : never, log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
-    (cluster: import("@matter/types").ClusterId | string, event: string, payload: Record<string, boolean | number | bigint | string | object | undefined | null>, log?: import("node-ansi-logger").AnsiLogger): Promise<boolean>;
-}>;
-export declare const triggerSwitchEventMatterbridgeEndpointSpy: import("jest-mock").SpiedFunction<(event: "Single" | "Double" | "Long" | "Press" | "Release", log?: import("node-ansi-logger").AnsiLogger) => Promise<boolean>>;
+export declare const setClusterMatterbridgeEndpointSpy: jest.SpiedFunction<typeof MatterbridgeEndpoint.prototype.setCluster>;
+export declare const setAttributeMatterbridgeEndpointSpy: jest.SpiedFunction<typeof MatterbridgeEndpoint.prototype.setAttribute>;
+export declare const updateAttributeMatterbridgeEndpointSpy: jest.SpiedFunction<typeof MatterbridgeEndpoint.prototype.updateAttribute>;
+export declare const subscribeAttributeMatterbridgeEndpointSpy: jest.SpiedFunction<typeof MatterbridgeEndpoint.prototype.subscribeAttribute>;
+export declare const triggerEventMatterbridgeEndpointSpy: jest.SpiedFunction<typeof MatterbridgeEndpoint.prototype.triggerEvent>;
+export declare const triggerSwitchEventMatterbridgeEndpointSpy: jest.SpiedFunction<typeof MatterbridgeEndpoint.prototype.triggerSwitchEvent>;

package/dist/jestutils/jestMatterbridgeEndpointSpy.js

@@ -1,5 +1,5 @@
-import { jest } from '@jest/globals';
 import { MatterbridgeEndpoint } from '../matterbridgeEndpoint.js';
+const { jest } = await import('@jest/globals');
 export const setClusterMatterbridgeEndpointSpy = jest.spyOn(MatterbridgeEndpoint.prototype, 'setCluster');
 export const setAttributeMatterbridgeEndpointSpy = jest.spyOn(MatterbridgeEndpoint.prototype, 'setAttribute');
 export const updateAttributeMatterbridgeEndpointSpy = jest.spyOn(MatterbridgeEndpoint.prototype, 'updateAttribute');

package/dist/jestutils/jestMatterbridgePlatformSpy.d.ts

@@ -1,60 +1,43 @@
-export declare const destroyMatterbridgePlatformSpy: import("jest-mock").SpiedGetter<string | boolean | import("node-ansi-logger").AnsiLogger | Promise<void> | import("../matterbridgePlatform.js").PlatformConfig | import("../matterbridgePlatform.js").PlatformMatterbridge | import("node-persist-manager").NodeStorage> | import("jest-mock").SpiedSetter<string | boolean | import("node-ansi-logger").AnsiLogger | Promise<void> | import("../matterbridgePlatform.js").PlatformConfig | import("../matterbridgePlatform.js").PlatformMatterbridge | import("node-persist-manager").NodeStorage>;
-export declare const onStartMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(reason?: string) => Promise<void>>;
-export declare const onConfigureMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<() => Promise<void>>;
-export declare const onShutdownMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(reason?: string) => Promise<void>>;
-export declare const onChangeLoggerLevelMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(logLevel: import("node-ansi-logger").LogLevel) => Promise<void>>;
-export declare const onActionMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(action: string, value?: string, id?: string, formData?: import("../matterbridgePlatform.js").PlatformConfig) => Promise<void>>;
-export declare const onConfigChangedMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(config: import("../matterbridgePlatform.js").PlatformConfig) => Promise<void>>;
-export declare const saveConfigMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(config: import("../matterbridgePlatform.js").PlatformConfig) => void>;
-export declare const getSchemaMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<() => Promise<import("../matterbridgePlatform.js").PlatformSchema | undefined>>;
-export declare const setSchemaMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(schema: import("../matterbridgePlatform.js").PlatformSchema) => void>;
-export declare const wssSendRestartRequiredMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(snackbar?: boolean, fixed?: boolean) => void>;
-export declare const wssSendSnackbarMessageMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(message: string, timeout?: number, severity?: "error" | "success" | "info" | "warning") => void>;
-export declare const sizeMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<() => number>;
-export declare const getDevicesMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<() => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint[]>;
-export declare const getDeviceByNameMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(deviceName: string) => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint | undefined>;
-export declare const getDeviceByUniqueIdMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(uniqueId: string) => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint | undefined>;
-export declare const getDeviceBySerialNumberMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(serialNumber: string) => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint | undefined>;
-export declare const getDeviceByIdMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(id: string) => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint | undefined>;
-export declare const getDeviceByOriginalIdMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(originalId: string) => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint | undefined>;
-export declare const getDeviceByNumberMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(number: import("@matter/types").EndpointNumber | number) => import("../matterbridgeEndpoint.js").MatterbridgeEndpoint | undefined>;
-export declare const hasDeviceNameMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(deviceName: string) => boolean>;
-export declare const hasDeviceUniqueIdMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(deviceUniqueId: string) => boolean>;
-export declare const registerVirtualDeviceMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(name: string, type: "light" | "outlet" | "switch" | "mounted_switch", callback: () => Promise<void>) => Promise<boolean>>;
-export declare const registerDeviceMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(device: import("../matterbridgeEndpoint.js").MatterbridgeEndpoint) => Promise<void>>;
-export declare const unregisterDeviceMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(device: import("../matterbridgeEndpoint.js").MatterbridgeEndpoint) => Promise<void>>;
-export declare const unregisterAllDevicesMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(delay?: number) => Promise<void>>;
-export declare const saveSelectsMatterbridgePlatformSpy: import("jest-mock").SpiedGetter<string | boolean | import("node-ansi-logger").AnsiLogger | Promise<void> | import("../matterbridgePlatform.js").PlatformConfig | import("../matterbridgePlatform.js").PlatformMatterbridge | import("node-persist-manager").NodeStorage> | import("jest-mock").SpiedSetter<string | boolean | import("node-ansi-logger").AnsiLogger | Promise<void> | import("../matterbridgePlatform.js").PlatformConfig | import("../matterbridgePlatform.js").PlatformMatterbridge | import("node-persist-manager").NodeStorage>;
-export declare const clearSelectMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<() => Promise<void>>;
-export declare const clearDeviceSelectMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(serial: string) => Promise<void>>;
-export declare const clearEntitySelectMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(name: string) => Promise<void>>;
-export declare const setSelectDeviceMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(serial: string, name: string, configUrl?: string, icon?: string, entities?: {
-    name: string;
-    description: string;
-    icon?: string;
-}[]) => void>;
-export declare const getSelectDeviceMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(serial: string) => {
-    serial: string;
-    name: string;
-    configUrl?: string;
-    icon?: string;
-    entities?: {
-        name: string;
-        description: string;
-        icon?: string;
-    }[];
-} | undefined>;
-export declare const setSelectDeviceEntityMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(serial: string, entityName: string, entityDescription: string, entityIcon?: string) => void>;
-export declare const getSelectDevicesMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<() => import("@matterbridge/types").ApiSelectDevice[]>;
-export declare const setSelectEntityMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(name: string, description: string, icon?: string) => void>;
-export declare const getSelectEntityMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(name: string) => {
-    name: string;
-    description: string;
-    icon?: string | undefined;
-} | undefined>;
-export declare const getSelectEntitiesMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<() => import("@matterbridge/types").ApiSelectEntity[]>;
-export declare const verifyMatterbridgeVersionMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(requiredVersion: string, destroy?: boolean) => boolean>;
-export declare const validateDeviceMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(device: string | string[], log?: boolean) => boolean>;
-export declare const validateEntityMatterbridgePlatformSpy: import("jest-mock").SpiedFunction<(device: string, entity: string, log?: boolean) => boolean>;
-export declare const clearEndpointNumbersMatterbridgePlatformSpy: import("jest-mock").SpiedGetter<string | boolean | import("node-ansi-logger").AnsiLogger | Promise<void> | import("../matterbridgePlatform.js").PlatformConfig | import("../matterbridgePlatform.js").PlatformMatterbridge | import("node-persist-manager").NodeStorage> | import("jest-mock").SpiedSetter<string | boolean | import("node-ansi-logger").AnsiLogger | Promise<void> | import("../matterbridgePlatform.js").PlatformConfig | import("../matterbridgePlatform.js").PlatformMatterbridge | import("node-persist-manager").NodeStorage>;
-export declare const checkEndpointNumbersMatterbridgePlatformSpy: import("jest-mock").SpiedGetter<string | boolean | import("node-ansi-logger").AnsiLogger | Promise<void> | import("../matterbridgePlatform.js").PlatformConfig | import("../matterbridgePlatform.js").PlatformMatterbridge | import("node-persist-manager").NodeStorage> | import("jest-mock").SpiedSetter<string | boolean | import("node-ansi-logger").AnsiLogger | Promise<void> | import("../matterbridgePlatform.js").PlatformConfig | import("../matterbridgePlatform.js").PlatformMatterbridge | import("node-persist-manager").NodeStorage>;
+import { MatterbridgePlatform } from '../matterbridgePlatform.js';
+export declare const destroyMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.destroy>;
+export declare const onStartMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.onStart>;
+export declare const onConfigureMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.onConfigure>;
+export declare const onShutdownMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.onShutdown>;
+export declare const onChangeLoggerLevelMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.onChangeLoggerLevel>;
+export declare const onActionMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.onAction>;
+export declare const onConfigChangedMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.onConfigChanged>;
+export declare const saveConfigMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.saveConfig>;
+export declare const getSchemaMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getSchema>;
+export declare const setSchemaMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.setSchema>;
+export declare const wssSendRestartRequiredMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.wssSendRestartRequired>;
+export declare const wssSendSnackbarMessageMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.wssSendSnackbarMessage>;
+export declare const sizeMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.size>;
+export declare const getDevicesMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getDevices>;
+export declare const getDeviceByNameMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getDeviceByName>;
+export declare const getDeviceByUniqueIdMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getDeviceByUniqueId>;
+export declare const getDeviceBySerialNumberMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getDeviceBySerialNumber>;
+export declare const getDeviceByIdMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getDeviceById>;
+export declare const getDeviceByOriginalIdMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getDeviceByOriginalId>;
+export declare const getDeviceByNumberMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getDeviceByNumber>;
+export declare const hasDeviceNameMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.hasDeviceName>;
+export declare const hasDeviceUniqueIdMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.hasDeviceUniqueId>;
+export declare const registerVirtualDeviceMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.registerVirtualDevice>;
+export declare const registerDeviceMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.registerDevice>;
+export declare const unregisterDeviceMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.unregisterDevice>;
+export declare const unregisterAllDevicesMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.unregisterAllDevices>;
+export declare const saveSelectsMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.saveSelects>;
+export declare const clearSelectMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.clearSelect>;
+export declare const clearDeviceSelectMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.clearDeviceSelect>;
+export declare const clearEntitySelectMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.clearEntitySelect>;
+export declare const setSelectDeviceMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.setSelectDevice>;
+export declare const getSelectDeviceMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getSelectDevice>;
+export declare const setSelectDeviceEntityMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.setSelectDeviceEntity>;
+export declare const getSelectDevicesMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getSelectDevices>;
+export declare const setSelectEntityMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.setSelectEntity>;
+export declare const getSelectEntityMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getSelectEntity>;
+export declare const getSelectEntitiesMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.getSelectEntities>;
+export declare const verifyMatterbridgeVersionMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.verifyMatterbridgeVersion>;
+export declare const validateDeviceMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.validateDevice>;
+export declare const validateEntityMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.validateEntity>;
+export declare const clearEndpointNumbersMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.clearEndpointNumbers>;
+export declare const checkEndpointNumbersMatterbridgePlatformSpy: jest.SpiedFunction<typeof MatterbridgePlatform.prototype.checkEndpointNumbers>;

package/dist/jestutils/jestMatterbridgePlatformSpy.js

@@ -1,5 +1,5 @@
-import { jest } from '@jest/globals';
 import { MatterbridgePlatform } from '../matterbridgePlatform.js';
+const { jest } = await import('@jest/globals');
 export const destroyMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'destroy');
 export const onStartMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'onStart');
 export const onConfigureMatterbridgePlatformSpy = jest.spyOn(MatterbridgePlatform.prototype, 'onConfigure');

package/dist/jestutils/jestMatterbridgeSpy.d.ts

@@ -1,4 +1,5 @@
-export declare const addBridgedEndpointMatterbridgeSpy: import("jest-mock").SpiedFunction<(pluginName: string, device: import("../matterbridgeEndpoint.js").MatterbridgeEndpoint) => Promise<void>>;
-export declare const removeBridgedEndpointMatterbridgeSpy: import("jest-mock").SpiedFunction<(pluginName: string, device: import("../matterbridgeEndpoint.js").MatterbridgeEndpoint) => Promise<void>>;
-export declare const removeAllBridgedEndpointsMatterbridgeSpy: import("jest-mock").SpiedFunction<(pluginName: string, delay?: number) => Promise<void>>;
-export declare const addVirtualEndpointMatterbridgeSpy: import("jest-mock").SpiedFunction<(pluginName: string, name: string, type: "light" | "outlet" | "switch" | "mounted_switch", callback: () => Promise<void>) => Promise<boolean>>;
+import { Matterbridge } from '../matterbridge.js';
+export declare const addBridgedEndpointMatterbridgeSpy: jest.SpiedFunction<typeof Matterbridge.prototype.addBridgedEndpoint>;
+export declare const removeBridgedEndpointMatterbridgeSpy: jest.SpiedFunction<typeof Matterbridge.prototype.removeBridgedEndpoint>;
+export declare const removeAllBridgedEndpointsMatterbridgeSpy: jest.SpiedFunction<typeof Matterbridge.prototype.removeAllBridgedEndpoints>;
+export declare const addVirtualEndpointMatterbridgeSpy: jest.SpiedFunction<typeof Matterbridge.prototype.addVirtualEndpoint>;

package/dist/jestutils/jestMatterbridgeSpy.js

@@ -1,5 +1,5 @@
-import { jest } from '@jest/globals';
 import { Matterbridge } from '../matterbridge.js';
+const { jest } = await import('@jest/globals');
 export const addBridgedEndpointMatterbridgeSpy = jest.spyOn(Matterbridge.prototype, 'addBridgedEndpoint');
 export const removeBridgedEndpointMatterbridgeSpy = jest.spyOn(Matterbridge.prototype, 'removeBridgedEndpoint');
 export const removeAllBridgedEndpointsMatterbridgeSpy = jest.spyOn(Matterbridge.prototype, 'removeAllBridgedEndpoints');

package/dist/jestutils/jestMatterbridgeTest.d.ts

@@ -1,5 +1,5 @@
-import { Endpoint, ServerNode } from '@matter/node';
-import { AggregatorEndpoint } from '@matter/node/endpoints';
+import { type Endpoint, type ServerNode } from '@matter/node';
+import { type AggregatorEndpoint } from '@matter/node/endpoints';
 import type { DeviceManager } from '../deviceManager.js';
 import type { Frontend } from '../frontend.js';
 import { Matterbridge } from '../matterbridge.js';
@@ -12,7 +12,7 @@ export declare let devices: DeviceManager;
 export declare function startMatterbridge(bridgeMode?: 'bridge' | 'childbridge' | 'controller' | '', frontendPort?: number, matterPort?: number, passcode?: number, discriminator?: number, pluginSize?: number, devicesSize?: number): Promise<Matterbridge>;
 export declare function stopMatterbridge(cleanupPause?: number, destroyPause?: number, closeMdns?: boolean, closeRuntime?: boolean): Promise<void>;
 export declare function createMatterbridgeEnvironment(): Promise<Matterbridge>;
-export declare function startMatterbridgeEnvironment(port?: number, createOnly?: boolean): Promise<[ServerNode<ServerNode.RootEndpoint>, Endpoint<AggregatorEndpoint>]>;
+export declare function startMatterbridgeEnvironment(port?: number, createOnly?: boolean): Promise<[ServerNode, Endpoint<AggregatorEndpoint>]>;
 export declare function addMatterbridgePlatform(platform: MatterbridgePlatform, name?: string): void;
 export declare function stopMatterbridgeEnvironment(createOnly?: boolean): Promise<void>;
 export declare function destroyMatterbridgeEnvironment(cleanupPause?: number, destroyPause?: number, closeMdns?: boolean, closeRuntime?: boolean): Promise<void>;

package/dist/jestutils/jestMatterbridgeTest.js

@@ -109,7 +109,7 @@ export async function createMatterbridgeEnvironment() {
     matterbridge = await Matterbridge.loadInstance(false);
     expect(matterbridge).toBeDefined();
     expect(matterbridge).toBeInstanceOf(Matterbridge);
-    matterbridge.matterbridgeVersion = '3.9.0';
+    matterbridge.matterbridgeVersion = '3.9.1';
     matterbridge.bridgeMode = 'bridge';
     matterbridge.rootDirectory = path.join(HOMEDIR);
     matterbridge.homeDirectory = path.join(HOMEDIR);

package/dist/jestutils/jestPluginManagerSpy.d.ts

@@ -1,47 +1,40 @@
-export declare const destroyPluginSpy: import("jest-mock").SpiedFunction<() => void>;
-export declare const checkDependenciesPluginSpy: import("jest-mock").SpiedFunction<(packageJson: Record<string, unknown> & {
-    name?: string;
-    dependencies?: string[] | Record<string, string>;
-    devDependencies?: string[] | Record<string, string>;
-    peerDependencies?: string[] | Record<string, string>;
-    optionalDependencies?: string[] | Record<string, string>;
-    bundledDependencies?: string[] | Record<string, string>;
-    bundleDependencies?: string[] | Record<string, string>;
-}) => boolean>;
-export declare const lengthPluginSpy: import("jest-mock").SpiedGetter<number>;
-export declare const sizePluginSpy: import("jest-mock").SpiedGetter<number>;
-export declare const hasPluginSpy: import("jest-mock").SpiedFunction<(name: string) => boolean>;
-export declare const getPluginSpy: import("jest-mock").SpiedFunction<(name: string) => import("../pluginManager.js").Plugin | undefined>;
-export declare const setPluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin) => import("../pluginManager.js").Plugin>;
-export declare const clearPluginSpy: import("jest-mock").SpiedFunction<() => void>;
-export declare const arrayPluginSpy: import("jest-mock").SpiedFunction<() => import("../pluginManager.js").Plugin[]>;
-export declare const storagePluginArraySpy: import("jest-mock").SpiedFunction<() => import("@matterbridge/types").StoragePlugin[]>;
-export declare const apiPluginArraySpy: import("jest-mock").SpiedFunction<() => import("@matterbridge/types").ApiPlugin[]>;
-export declare const iteratorPluginSpy: import("jest-mock").SpiedFunction<() => MapIterator<import("../pluginManager.js").Plugin>>;
-export declare const forEachPluginSpy: import("jest-mock").SpiedFunction<(callback: (plugin: import("../pluginManager.js").Plugin) => Promise<void>) => Promise<void>>;
-export declare const logLevelPluginSpy: import("jest-mock").SpiedSetter<import("node-ansi-logger").LogLevel>;
-export declare const loadFromStoragePluginSpy: import("jest-mock").SpiedFunction<() => Promise<import("@matterbridge/types").StoragePlugin[]>>;
-export declare const saveToStoragePluginSpy: import("jest-mock").SpiedFunction<() => Promise<number>>;
-export declare const resolvePluginSpy: import("jest-mock").SpiedFunction<(nameOrPath: string) => Promise<string | null>>;
-export declare const installPluginSpy: import("jest-mock").SpiedFunction<(packageName: string) => void>;
-export declare const uninstallPluginSpy: import("jest-mock").SpiedFunction<(packageName: string) => void>;
-export declare const getAuthorPluginSpy: import("jest-mock").SpiedFunction<(packageJson: Record<string, string | number | Record<string, string | number | object>>) => string>;
-export declare const getDescriptionPluginSpy: import("jest-mock").SpiedFunction<(packageJson: Record<string, string | number | Record<string, string | number | object>>) => string>;
-export declare const getHomepagePluginSpy: import("jest-mock").SpiedFunction<(packageJson: Record<string, string | number | Record<string, string | number | object>>) => string | undefined>;
-export declare const getHelpPluginSpy: import("jest-mock").SpiedFunction<(packageJson: Record<string, string | number | Record<string, string | number | object>>) => string | undefined>;
-export declare const getChangelogPluginSpy: import("jest-mock").SpiedFunction<(packageJson: Record<string, string | number | Record<string, string | number | object>>) => string | undefined>;
-export declare const getFundingPluginSpy: import("jest-mock").SpiedFunction<(packageJson: Record<string, any>) => string | undefined>;
-export declare const parsePluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin | import("@matterbridge/types").PluginName) => Promise<Record<string, string | number | object> | null>>;
-export declare const addPluginSpy: import("jest-mock").SpiedFunction<(nameOrPath: string) => Promise<import("../pluginManager.js").Plugin | null>>;
-export declare const enablePluginSpy: import("jest-mock").SpiedFunction<(nameOrPath: string) => Promise<import("../pluginManager.js").Plugin | null>>;
-export declare const disablePluginSpy: import("jest-mock").SpiedFunction<(nameOrPath: string) => Promise<import("../pluginManager.js").Plugin | null>>;
-export declare const removePluginSpy: import("jest-mock").SpiedFunction<(nameOrPath: string) => Promise<import("../pluginManager.js").Plugin | null>>;
-export declare const loadPluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin | import("@matterbridge/types").PluginName, start?: boolean, message?: string, configure?: boolean) => Promise<import("../matterbridgePlatform.js").MatterbridgePlatform | undefined>>;
-export declare const startPluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin | import("@matterbridge/types").PluginName, message?: string, configure?: boolean) => Promise<import("../pluginManager.js").Plugin | undefined>>;
-export declare const configurePluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin | import("@matterbridge/types").PluginName) => Promise<import("../pluginManager.js").Plugin | undefined>>;
-export declare const shutdownPluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin | import("@matterbridge/types").PluginName, reason?: string, removeAllDevices?: boolean, force?: boolean) => Promise<import("../pluginManager.js").Plugin | undefined>>;
-export declare const loadConfigPluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin) => Promise<import("@matterbridge/types").PlatformConfig>>;
-export declare const saveConfigFromPluginPluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin, restartRequired?: boolean) => Promise<void>>;
-export declare const saveConfigFromJsonPluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin, config: import("@matterbridge/types").PlatformConfig, restartRequired?: boolean) => Promise<void>>;
-export declare const loadSchemaPluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin) => Promise<import("@matterbridge/types").PlatformSchema>>;
-export declare const getDefaultSchemaPluginSpy: import("jest-mock").SpiedFunction<(plugin: import("../pluginManager.js").Plugin) => import("@matterbridge/types").PlatformSchema>;
+import { PluginManager } from '../pluginManager.js';
+export declare const destroyPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.destroy>;
+export declare const checkDependenciesPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.checkDependencies>;
+export declare const lengthPluginSpy: jest.SpiedGetter<typeof PluginManager.prototype.length>;
+export declare const sizePluginSpy: jest.SpiedGetter<typeof PluginManager.prototype.size>;
+export declare const hasPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.has>;
+export declare const getPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.get>;
+export declare const setPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.set>;
+export declare const clearPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.clear>;
+export declare const arrayPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.array>;
+export declare const storagePluginArraySpy: jest.SpiedFunction<typeof PluginManager.prototype.storagePluginArray>;
+export declare const apiPluginArraySpy: jest.SpiedFunction<typeof PluginManager.prototype.apiPluginArray>;
+export declare const iteratorPluginSpy: jest.SpiedFunction<(typeof PluginManager.prototype)[typeof Symbol.iterator]>;
+export declare const forEachPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.forEach>;
+export declare const logLevelPluginSpy: jest.SpiedSetter<typeof PluginManager.prototype.logLevel>;
+export declare const loadFromStoragePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.loadFromStorage>;
+export declare const saveToStoragePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.saveToStorage>;
+export declare const resolvePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.resolve>;
+export declare const installPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.install>;
+export declare const uninstallPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.uninstall>;
+export declare const getAuthorPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.getAuthor>;
+export declare const getDescriptionPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.getDescription>;
+export declare const getHomepagePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.getHomepage>;
+export declare const getHelpPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.getHelp>;
+export declare const getChangelogPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.getChangelog>;
+export declare const getFundingPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.getFunding>;
+export declare const parsePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.parse>;
+export declare const addPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.add>;
+export declare const enablePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.enable>;
+export declare const disablePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.disable>;
+export declare const removePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.remove>;
+export declare const loadPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.load>;
+export declare const startPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.start>;
+export declare const configurePluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.configure>;
+export declare const shutdownPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.shutdown>;
+export declare const loadConfigPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.loadConfig>;
+export declare const saveConfigFromPluginPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.saveConfigFromPlugin>;
+export declare const saveConfigFromJsonPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.saveConfigFromJson>;
+export declare const loadSchemaPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.loadSchema>;
+export declare const getDefaultSchemaPluginSpy: jest.SpiedFunction<typeof PluginManager.prototype.getDefaultSchema>;

package/dist/jestutils/jestPluginManagerSpy.js

@@ -1,5 +1,5 @@
-import { jest } from '@jest/globals';
 import { PluginManager } from '../pluginManager.js';
+const { jest } = await import('@jest/globals');
 export const destroyPluginSpy = jest.spyOn(PluginManager.prototype, 'destroy');
 export const checkDependenciesPluginSpy = jest.spyOn(PluginManager.prototype, 'checkDependencies');
 export const lengthPluginSpy = jest.spyOn(PluginManager.prototype, 'length', 'get');

package/dist/jestutils/jestSetupTest.d.ts

@@ -1,4 +1,3 @@
-import type { jest } from '@jest/globals';
 import { AnsiLogger } from 'node-ansi-logger';
 export declare const originalProcessArgv: readonly string[];
 export declare const originalProcessEnv: Readonly<Record<string, string | undefined>>;

package/dist/jestutils/logKeepAlives.d.ts

@@ -1,2 +1,2 @@
-import { AnsiLogger } from 'node-ansi-logger';
+import { type AnsiLogger } from 'node-ansi-logger';
 export declare function logKeepAlives(log?: AnsiLogger): number;

package/dist/jestutils/matterRequest.d.ts

@@ -1,5 +1,5 @@
 import { ColorControl } from '@matter/types/clusters/color-control';
-import { LevelControl } from '@matter/types/clusters/level-control';
+import { type LevelControl } from '@matter/types/clusters/level-control';
 export declare function getMoveToLevelRequest(level: number, transitionTime: number, executeIfOff: boolean): LevelControl.MoveToLevelRequest;
 export declare function getMoveToColorTemperatureRequest(colorTemperatureMireds: number, transitionTime: number, executeIfOff: boolean): ColorControl.MoveToColorTemperatureRequest;
 export declare function getMoveToHueRequest(hue: number, transitionTime: number, executeIfOff: boolean): ColorControl.MoveToHueRequest;

package/dist/matterbridge.d.ts

@@ -1,13 +1,13 @@
 import '@matter/nodejs';
 import EventEmitter from 'node:events';
-import { StorageContext, StorageManager, StorageService } from '@matter/general';
+import { type StorageContext, type StorageManager, StorageService } from '@matter/general';
 import { Endpoint, ServerNode } from '@matter/node';
 import { AggregatorEndpoint } from '@matter/node/endpoints/aggregator';
-import { DeviceCertification } from '@matter/protocol';
+import { type DeviceCertification } from '@matter/protocol';
 import { DeviceTypeId, VendorId } from '@matter/types/datatype';
 import type { ApiMatter, MaybePromise, PlatformMatterbridge, SharedMatterbridge, SystemInformation } from '@matterbridge/types';
 import { AnsiLogger, LogLevel } from 'node-ansi-logger';
-import { NodeStorage, NodeStorageManager } from 'node-persist-manager';
+import { type NodeStorage, NodeStorageManager } from 'node-persist-manager';
 import { DeviceManager } from './deviceManager.js';
 import { Frontend } from './frontend.js';
 import { MatterbridgeEndpoint } from './matterbridgeEndpoint.js';
@@ -96,7 +96,7 @@ export declare class Matterbridge extends EventEmitter<MatterbridgeEvents> {
     discriminator: number | undefined;
     initialDiscriminator: number | undefined;
     certification: DeviceCertification.Configuration | undefined;
-    serverNode: ServerNode<ServerNode.RootEndpoint> | undefined;
+    serverNode: ServerNode | undefined;
     aggregatorNode: Endpoint<AggregatorEndpoint> | undefined;
     aggregatorVendorId: VendorId;
     aggregatorVendorName: string;
@@ -105,7 +105,7 @@ export declare class Matterbridge extends EventEmitter<MatterbridgeEvents> {
     aggregatorDeviceType: DeviceTypeId;
     aggregatorSerialNumber: string | undefined;
     aggregatorUniqueId: string | undefined;
-    controllerNode: ServerNode<ServerNode.RootEndpoint> | undefined;
+    controllerNode: ServerNode | undefined;
     controllerVendorId: VendorId;
     controllerVendorName: string;
     controllerProductId: number;
@@ -142,7 +142,7 @@ export declare class Matterbridge extends EventEmitter<MatterbridgeEvents> {
     private stopMatterStorage;
     private createServerNodeContext;
     private createServerNode;
-    getServerNodeData(serverNode: ServerNode<ServerNode.RootEndpoint>): ApiMatter;
+    getServerNodeData(serverNode: ServerNode): ApiMatter;
     private startServerNode;
     private stopServerNode;
     private createAggregatorNode;