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;

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(displayName: string, uuid: string, category?: Categories);

category: Categories;

context: UnknownContext;

displayName: string;

reachable: boolean;

services: Service[];

UUID: string;

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

configureCameraSource: (cameraSource: LegacyCameraSource) => CameraController;

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;

getServiceByUUIDAndSubType: <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;

updateReachability: (reachable: boolean) => void;

static cachedAccessoryPath: () => string;

static configPath: () => 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;

readonly platformAccessory: typeof PlatformAccessory;

readonly serverVersion: string;

readonly user: typeof User;

readonly version: number;

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

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

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

registerAccessory: {
    (
        accessoryName: AccessoryName,
        constructor: AccessoryPluginConstructor
    ): void;
    (
        pluginIdentifier: string,
        accessoryName: string,
        constructor: AccessoryPluginConstructor
    ): void;
};

registerPlatform: {
    <Config extends PlatformConfig>(
        platformName: PlatformName,
        constructor: PlatformPluginConstructor<Config>
    ): void;
    <Config extends PlatformConfig>(
        pluginIdentifier: string,
        platformName: string,
        constructor: PlatformPluginConstructor<Config>
    ): void;
};

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

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

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

versionGreaterOrEqual: (version: string) => boolean;

advertiser?: MDNSAdvertiser;

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

disableIpc?: boolean;

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

firmwareRevision?: string;

manufacturer?: string;

model?: string;

name: string;

pin: string;

port?: number;

serialNumber?: string;

setupID?: string[4];

username: MacAddress;

configureAccessory: (accessory: PlatformAccessory) => void;

end: number;

start: number;

accessories: AccessoryConfig[];

bridge: BridgeConfiguration;

disabledPlugins?: PluginIdentifier[];

mdns?: any;

platforms: PlatformConfig[];

plugins?: PluginIdentifier[];

ports?: ExternalPortsConfiguration;

customPluginPath?: string;

customStoragePath?: string;

debugModeEnabled?: boolean;

forceColourLogging?: boolean;

hideQRCode?: boolean;

insecureAccess?: boolean;

keepOrphanedCachedAccessories?: boolean;

noLogTimestamps?: boolean;

strictPluginResolution?: boolean;

prefix: string;

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

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

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

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

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

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

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

emit: (event: 'identify') => boolean;

on: (event: 'identify', listener: () => void) => this;

name?: string;

platform: PlatformName | PlatformIdentifier;

new (logger: Logging, config: Config, api: API):
    | DynamicPlatformPlugin
    | StaticPlatformPlugin
    | IndependentPlatformPlugin;

(api: API): void | Promise<void>;

accessories: (callback: (foundAccessories: AccessoryPlugin[]) => void) => void;

DID_FINISH_LAUNCHING = 'didFinishLaunching'

SHUTDOWN = 'shutdown'

DEBUG = 'debug'

ERROR = 'error'

INFO = 'info'

SUCCESS = 'success'

WARN = 'warn'

IDENTIFY = 'identify'

ACCESSORY = 'accessory'

PLATFORM = 'platform'