homebridge

constructor(prefix?: string);

static readonly internal: Logger;

readonly prefix?: string;

debug: (message: string, ...parameters: any[]) => void;

error: (message: string, ...parameters: any[]) => void;

static forceColor: () => void;

info: (message: string, ...parameters: any[]) => void;

static isTimestampEnabled: () => boolean;

log: (level: LogLevel, message: string, ...parameters: any[]) => void;

static setDebugEnabled: (enabled?: boolean) => void;

static setTimestampEnabled: (enabled?: boolean) => void;

success: (message: string, ...parameters: any[]) => void;

warn: (message: string, ...parameters: any[]) => void;

static withPrefix: (prefix: string) => Logging;

constructor(message: string, details?: MatterErrorDetails);

constructor(message: string, details?: MatterErrorDetails);

constructor(message: string, code: string, details?: MatterErrorDetails);

readonly code: string;

readonly details?: MatterErrorDetails;

readonly recoverable: boolean;

readonly timestamp: Date;

readonly type: MatterErrorType;

constructor(message: string, details?: MatterErrorDetails);

constructor(message: string, details?: MatterErrorDetails);

constructor(displayName: string, uuid: string, category?: Categories);

category: Categories;

context: UnknownContext;

displayName: string;

services: Service[];

UUID: string;

addService: {
    (service: Service): Service;
    <S extends any>(
        serviceConstructor: S,
        ...constructorArgs: ConstructorArgs<S>
    ): Service;
};

configureController: (controller: Controller | ControllerConstructor) => void;

static deserialize: (json: SerializedPlatformAccessory) => PlatformAccessory;

getService: <T extends WithUUID<any>>(name: string | T) => Service | undefined;

getServiceById: <T extends WithUUID<any>>(
    uuid: string | T,
    subType: string
) => Service | undefined;

removeController: (controller: Controller) => void;

removeService: (service: Service) => void;

static serialize: (accessory: PlatformAccessory) => SerializedPlatformAccessory;

updateDisplayName: (name: string) => void;

static cachedAccessoryPath: () => string;

static configPath: () => string;

static matterPath: () => string;

static persistPath: () => string;

static setStoragePath: (...storagePathSegments: string[]) => void;

static storagePath: () => string;

accessory: AccessoryName | AccessoryIdentifier;

name: string;

uuid_base?: string;

getControllers?: () => Controller[];

getServices: () => Service[];

identify?: () => void;

new (logger: Logging, config: AccessoryConfig, api: API): AccessoryPlugin;

readonly hap: HAP;

readonly hapLegacyTypes: HAPLegacyTypes;

isMatterAvailable: () => boolean;

isMatterEnabled: () => boolean;

readonly matter?: MatterAPI;

on: ((event: 'didFinishLaunching', listener: () => void) => this) &
    ((event: 'shutdown', listener: () => void) => this);

readonly platformAccessory: typeof PlatformAccessory;

publishExternalAccessories: (
    pluginIdentifier: PluginIdentifier,
    accessories: PlatformAccessory[]
) => void;

registerAccessory: ((
    accessoryName: AccessoryName,
    constructor: AccessoryPluginConstructor
) => void) &
    ((
        pluginIdentifier: PluginIdentifier,
        accessoryName: AccessoryName,
        constructor: AccessoryPluginConstructor
    ) => void);

registerPlatform: (<Config extends PlatformConfig>(
    platformName: PlatformName,
    constructor: PlatformPluginConstructor<Config>
) => void) &
    (<Config extends PlatformConfig>(
        pluginIdentifier: PluginIdentifier,
        platformName: PlatformName,
        constructor: PlatformPluginConstructor<Config>
    ) => void);

registerPlatformAccessories: (
    pluginIdentifier: PluginIdentifier,
    platformName: PlatformName,
    accessories: PlatformAccessory[]
) => void;

readonly serverVersion: string;

unregisterPlatformAccessories: (
    pluginIdentifier: PluginIdentifier,
    platformName: PlatformName,
    accessories: PlatformAccessory[]
) => void;

updatePlatformAccessories: (accessories: PlatformAccessory[]) => void;

readonly user: typeof User;

readonly version: number;

versionGreaterOrEqual: (version: string) => boolean;

advertiser?: MDNSAdvertiser;

bind?: (InterfaceName | IPAddress) | (InterfaceName | IPAddress)[];

debugModeEnabled?: boolean;

disableIpc?: boolean;

env?: {
    DEBUG?: string;
    NODE_OPTIONS?: string;
};

firmwareRevision?: string;

hap?: BridgeHapConfig | boolean;

manufacturer?: string;

matter?: MatterConfig;

model?: string;

name: string;

pin: string;

port?: number;

serialNumber?: string;

setupID?: string;

username: MacAddress;

closureControl: ClosureControlHandlers;

colorControl: ColorControlHandlers;

doorLock: DoorLockHandlers;

fanControl: FanControlHandlers;

identify: IdentifyHandlers;

keypadInput: KeypadInputHandlers;

levelControl: LevelControlHandlers;

mediaPlayback: MediaPlaybackHandlers;

onOff: OnOffHandlers;

rvcCleanMode: RvcCleanModeHandlers;

rvcOperationalState: RvcOperationalStateHandlers;

rvcRunMode: RvcRunModeHandlers;

serviceArea: ServiceAreaHandlers;

thermostat: ThermostatHandlers;

valveConfigurationAndControl: ValveConfigurationAndControlHandlers;

windowCovering: WindowCoveringHandlers;

airQuality: {
    airQuality: number;
};

booleanState: {
    stateValue: boolean;
};

carbonMonoxideConcentrationMeasurement: {
    measuredValue: number | null;
    minMeasuredValue?: number | null;
    maxMeasuredValue?: number | null;
    measurementMedium: number;
    measurementUnit?: number;
};

colorControl: ColorControlState;

doorLock: DoorLockState;

electricalEnergyMeasurement: ElectricalEnergyMeasurementState;

electricalPowerMeasurement: ElectricalPowerMeasurementState;

fanControl: FanControlState;

identify: {
    identifyTime: number;
    identifyType: number;
};

illuminanceMeasurement: {
    measuredValue: number | null;
    minMeasuredValue?: number | null;
    maxMeasuredValue?: number | null;
};

levelControl: LevelControlState;

nitrogenDioxideConcentrationMeasurement: {
    measuredValue: number | null;
    minMeasuredValue?: number | null;
    maxMeasuredValue?: number | null;
    measurementMedium: number;
    measurementUnit?: number;
};

occupancySensing: {
    occupancy: {
        occupied: boolean;
    };
    occupancySensorType?: number;
    occupancySensorTypeBitmap?: {
        pir?: boolean;
        ultrasonic?: boolean;
        physicalContact?: boolean;
    };
};

onOff: OnOffState;

ozoneConcentrationMeasurement: {
    measuredValue: number | null;
    minMeasuredValue?: number | null;
    maxMeasuredValue?: number | null;
    measurementMedium: number;
    measurementUnit?: number;
};

pm10ConcentrationMeasurement: {
    measuredValue: number | null;
    minMeasuredValue?: number | null;
    maxMeasuredValue?: number | null;
    measurementMedium: number;
    measurementUnit?: number;
};

pm25ConcentrationMeasurement: {
    measuredValue: number | null;
    minMeasuredValue?: number | null;
    maxMeasuredValue?: number | null;
    measurementMedium: number;
    measurementUnit?: number;
};

powerSource: PowerSourceState;

relativeHumidityMeasurement: {
    measuredValue: number | null;
    minMeasuredValue?: number | null;
    maxMeasuredValue?: number | null;
};

rvcCleanMode: RvcCleanModeState;

rvcOperationalState: RvcOperationalState;

rvcRunMode: RvcRunModeState;

serviceArea: ServiceAreaState;

switch: {
    currentPosition: number;
    numberOfPositions?: number;
};

temperatureMeasurement: {
    measuredValue: number | null;
    minMeasuredValue?: number | null;
    maxMeasuredValue?: number | null;
};

thermostat: ThermostatState;

valveConfigurationAndControl: ValveConfigurationAndControlState;

windowCovering: WindowCoveringState;

moveToColorLogic?: MatterCommandHandler<{
    targetX: number;
    targetY: number;
    transitionTime: number;
}>;

moveToColorTemperatureLogic?: MatterCommandHandler<{
    colorTemperatureMireds: number;
    transitionTime: number;
}>;

moveToHueAndSaturationLogic?: MatterCommandHandler<{
    hue: number;
    saturation: number;
    transitionTime: number;
}>;

moveToHueLogic?: MatterCommandHandler<{
    targetHue: number;
    direction: ColorControl.Direction;
    transitionTime: number;
    isEnhancedHue: boolean;
}>;

moveToSaturationLogic?: MatterCommandHandler<{
    targetSaturation: number;
    transitionTime: number;
}>;

stopAllColorMovement?: MatterCommandHandler;

colorMode?: number;

colorTemperatureMireds?: number;

colorTempPhysicalMaxMireds?: number;

colorTempPhysicalMinMireds?: number;

colorX?: number;

colorY?: number;

coupleColorTempToLevelMinMireds?: number;

currentHue?: number;

currentSaturation?: number;

currentX?: number;

currentY?: number;

enhancedColorMode?: number;

enhancedCurrentHue?: number;

options?: number;

transitionTime?: number;

lockDoor?: MatterCommandHandler<DoorLock.LockDoorRequest>;

unlockDoor?: MatterCommandHandler<DoorLock.UnlockDoorRequest>;

actuatorEnabled?: boolean;

doorClosedEvents?: number;

doorOpenEvents?: number;

doorState?: number | null;