homebridge-powerview-universal 4.3.2

package/dist/platform.d.ts

@@ -0,0 +1,113 @@
+import type { API, Characteristic, DynamicPlatformPlugin, Logging, PlatformAccessory, Service } from 'homebridge';
+import { type HubCapabilities } from './hubCapabilities.js';
+import { HubPosition, type PowerViewShade } from './powerviewHub.js';
+import { type CharacteristicCallback } from './platformAccessory.js';
+import { type PositionMap } from './shadeUtils.js';
+import { ShadeKind, type PowerViewPlatformConfig, type SceneContext, type ShadeContext } from './settings.js';
+export declare class PowerViewPlatform implements DynamicPlatformPlugin {
+    readonly log: Logging;
+    readonly api: API;
+    readonly Service: typeof Service;
+    readonly Characteristic: typeof Characteristic;
+    readonly accessories: Map<number, PlatformAccessory<ShadeContext>>;
+    private readonly handlers;
+    hubVersion?: string;
+    hubCapabilities?: HubCapabilities;
+    private hubName?;
+    private readonly hub;
+    private readonly batteryPoll;
+    private readonly quietHours;
+    private readonly syncPositionsOnStart;
+    private readonly exposeScenes;
+    private readonly refreshShades;
+    private readonly pollShadesForUpdate;
+    private readonly strictErrors;
+    private readonly forceRollerShades;
+    private readonly forceTopBottomShades;
+    private readonly forceHorizontalShades;
+    private readonly forceVerticalShades;
+    private readonly lastPositions;
+    /** Consecutive shade lists a known shade has been missing from. */
+    private readonly missingFromList;
+    private readonly positionsOmittedLogged;
+    private readonly unsupportedCapabilityLogged;
+    /** Shades with a background refresh already in flight, so reads don't pile up. */
+    private readonly pendingRefresh;
+    /** When each shade last had a background read, so bursts don't stack up. */
+    private readonly lastBackgroundRefresh;
+    /** Travel timers per shade/position, so a re-target cancels the old arrival. */
+    private readonly travelTimers;
+    readonly sceneAccessories: Map<number, PlatformAccessory<SceneContext>>;
+    private readonly batteryRefreshDisabled;
+    private readonly posKindErrorLogged;
+    private batteryPollTimer?;
+    private shadePollTimer?;
+    private shuttingDown;
+    constructor(log: Logging, config: PowerViewPlatformConfig, api: API);
+    private onLaunch;
+    cachePositions(shadeId: number, positions: PositionMap | null): void;
+    getCachedPosition(shadeId: number, position: HubPosition): number | undefined;
+    shadeType(shade: PowerViewShade): ShadeKind;
+    private warnUnsupportedCapabilityOnce;
+    configureAccessory(accessory: PlatformAccessory): void;
+    private ensureWindowCoveringCategory;
+    private registerHandler;
+    private addShadeAccessory;
+    private updateShadeAccessory;
+    private removeShadeAccessory;
+    updateShades(): Promise<void>;
+    private pollShades;
+    /**
+     * Re-reads positions once at startup for shades the hub has no position for.
+     *
+     * The hub only holds a position for a while after a set or refresh, and a
+     * shade moved by remote is never reported at all — so without this, a
+     * restored cache would be served to HomeKit indefinitely with nothing ever
+     * correcting it. Startup is the one moment where an RF wake per shade buys
+     * accuracy without recurring cost; quiet hours guard the unattended restart.
+     */
+    private syncPositionsAtStartup;
+    stopShade(shadeId: number): Promise<void>;
+    private scheduleBatteryPoll;
+    private pollBatteryLevels;
+    updateHubInfo(): Promise<void>;
+    private updateShade;
+    getPosition(shadeId: number, position: HubPosition, callback: CharacteristicCallback): Promise<void>;
+    /**
+     * Refreshes a shade off the HomeKit read path, deduped per shade and rate
+     * limited per shade.
+     *
+     * `refresh` is the expensive kind: it wakes the motor over RF, takes seconds,
+     * and is what used to move shades at 05:54. It is only justified when the hub
+     * has no position at all. Servicing an ordinary read uses the cheap cached
+     * read, which never touches the radio.
+     */
+    private scheduleBackgroundRefresh;
+    private resolvePositionValue;
+    private updatePosition;
+    setPosition(shadeId: number, position: HubPosition, value: number, callback: (error: Error | null) => void): Promise<void>;
+    /**
+     * Publishes one stateless switch per hub scene.
+     *
+     * A scene is the only way to move a group together: it is a single call the
+     * hub expands itself, so every motor gets its RF command at once. Driving the
+     * same shades individually costs one serialised write each and they visibly
+     * stagger.
+     */
+    updateScenes(): Promise<void>;
+    private addSceneAccessory;
+    private wireSceneSwitch;
+    /**
+     * Marks the shade arrived once its estimated travel has elapsed.
+     *
+     * Estimated rather than polled: this hub reports no positions on a cached
+     * read, so confirming arrival would mean an RF round-trip that wakes the motor
+     * again the moment it stopped. The startup sync and any later refresh correct
+     * the value if the shade did not make it.
+     */
+    private scheduleArrival;
+    jogShade(shadeId: number): Promise<Partial<Record<HubPosition, number>> | null>;
+    jogShadeOnIdentify(shadeId: number): Promise<void>;
+    private notePositionsOmittedOnce;
+    warnPositionKindErrorOnce(shadeId: number): void;
+}