@ecobridge.xyz/devicemanager 3.0.2

package/dist_ts/interfaces/index.d.ts

@@ -0,0 +1,330 @@
+/**
+ * Device Manager Type Definitions
+ */
+export type TDeviceType = 'scanner' | 'printer' | 'snmp' | 'ups' | 'speaker' | 'dlna-renderer' | 'dlna-server';
+export type TDeviceStatus = 'online' | 'offline' | 'busy' | 'error' | 'unknown';
+export type TConnectionState = 'disconnected' | 'connecting' | 'connected' | 'error';
+export type TScannerProtocol = 'sane' | 'escl';
+export type TScanFormat = 'png' | 'jpeg' | 'pdf' | 'tiff';
+export type TColorMode = 'color' | 'grayscale' | 'blackwhite';
+export type TScanSource = 'flatbed' | 'adf' | 'adf-duplex';
+export interface IDeviceInfo {
+    id: string;
+    name: string;
+    type: TDeviceType;
+    address: string;
+    port: number;
+    status: TDeviceStatus;
+    manufacturer?: string;
+    model?: string;
+    serialNumber?: string;
+    firmwareVersion?: string;
+}
+export interface IDeviceManagerOptions {
+    /** Enable auto-discovery on startup */
+    autoDiscovery?: boolean;
+    /** Discovery timeout in milliseconds */
+    discoveryTimeout?: number;
+    /** Enable retry with exponential backoff */
+    enableRetry?: boolean;
+    /** Maximum retry attempts */
+    maxRetries?: number;
+    /** Base delay for retry backoff in milliseconds */
+    retryBaseDelay?: number;
+}
+export interface IScannerInfo extends IDeviceInfo {
+    type: 'scanner';
+    protocol: TScannerProtocol;
+    supportedFormats: TScanFormat[];
+    supportedResolutions: number[];
+    supportedColorModes: TColorMode[];
+    supportedSources: TScanSource[];
+    hasAdf: boolean;
+    hasDuplex: boolean;
+    maxWidth?: number;
+    maxHeight?: number;
+}
+export interface IScanArea {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface IScanOptions {
+    /** Resolution in DPI (default: 300) */
+    resolution?: number;
+    /** Output format (default: 'png') */
+    format?: TScanFormat;
+    /** Color mode (default: 'color') */
+    colorMode?: TColorMode;
+    /** Scan source (default: 'flatbed') */
+    source?: TScanSource;
+    /** Scan area (default: full page) */
+    area?: IScanArea;
+    /** Document intent for optimization */
+    intent?: 'document' | 'photo' | 'preview';
+    /** Compression quality for JPEG (1-100) */
+    quality?: number;
+}
+export interface IScanResult {
+    /** Scanned image data */
+    data: Buffer;
+    /** Output format */
+    format: TScanFormat;
+    /** Image width in pixels */
+    width: number;
+    /** Image height in pixels */
+    height: number;
+    /** Scan resolution in DPI */
+    resolution: number;
+    /** Color mode used */
+    colorMode: TColorMode;
+    /** MIME type */
+    mimeType: string;
+}
+export interface IScannerCapabilities {
+    resolutions: number[];
+    formats: TScanFormat[];
+    colorModes: TColorMode[];
+    sources: TScanSource[];
+    maxWidth: number;
+    maxHeight: number;
+    minWidth: number;
+    minHeight: number;
+}
+export interface IPrinterInfo extends IDeviceInfo {
+    type: 'printer';
+    uri: string;
+    supportsColor: boolean;
+    supportsDuplex: boolean;
+    supportedMediaTypes: string[];
+    supportedMediaSizes: string[];
+    maxCopies: number;
+}
+export interface IPrintOptions {
+    /** Number of copies (default: 1) */
+    copies?: number;
+    /** Media size (e.g., 'iso_a4_210x297mm') */
+    mediaSize?: string;
+    /** Media type (e.g., 'stationery') */
+    mediaType?: string;
+    /** Print sides: 'one-sided', 'two-sided-long-edge', 'two-sided-short-edge' */
+    sides?: 'one-sided' | 'two-sided-long-edge' | 'two-sided-short-edge';
+    /** Print quality */
+    quality?: 'draft' | 'normal' | 'high';
+    /** Color mode */
+    colorMode?: 'color' | 'monochrome';
+    /** Job name */
+    jobName?: string;
+}
+export interface IPrintJob {
+    id: number;
+    name: string;
+    state: 'pending' | 'processing' | 'completed' | 'canceled' | 'aborted';
+    stateReason?: string;
+    createdAt: Date;
+    completedAt?: Date;
+    pagesPrinted?: number;
+    pagesTotal?: number;
+}
+export interface IPrinterCapabilities {
+    colorSupported: boolean;
+    duplexSupported: boolean;
+    mediaSizes: string[];
+    mediaTypes: string[];
+    resolutions: number[];
+    maxCopies: number;
+    sidesSupported: string[];
+    qualitySupported: string[];
+}
+export interface IDiscoveredDevice {
+    id: string;
+    name: string;
+    type: TDeviceType;
+    protocol: string;
+    address: string;
+    port: number;
+    txtRecords: Record<string, string>;
+    serviceType: string;
+}
+export interface IDiscoveryOptions {
+    /** Service types to discover */
+    serviceTypes?: string[];
+    /** Discovery timeout in ms */
+    timeout?: number;
+}
+export interface IRetryOptions {
+    /** Maximum number of retry attempts */
+    maxRetries?: number;
+    /** Base delay in milliseconds */
+    baseDelay?: number;
+    /** Maximum delay in milliseconds */
+    maxDelay?: number;
+    /** Delay multiplier for exponential backoff */
+    multiplier?: number;
+    /** Whether to add jitter to delays */
+    jitter?: boolean;
+}
+export type TDeviceManagerEvents = {
+    'scanner:found': (scanner: IScannerInfo) => void;
+    'scanner:lost': (scannerId: string) => void;
+    'printer:found': (printer: IPrinterInfo) => void;
+    'printer:lost': (printerId: string) => void;
+    'device:updated': (device: IDeviceInfo) => void;
+    'discovery:started': () => void;
+    'discovery:stopped': () => void;
+    'error': (error: Error) => void;
+};
+export interface IEsclCapabilities {
+    version: string;
+    makeAndModel: string;
+    serialNumber?: string;
+    uuid?: string;
+    adminUri?: string;
+    iconUri?: string;
+    platen?: IEsclInputSource;
+    adf?: IEsclInputSource;
+    adfDuplex?: IEsclInputSource;
+}
+export interface IEsclInputSource {
+    minWidth: number;
+    maxWidth: number;
+    minHeight: number;
+    maxHeight: number;
+    maxScanRegions: number;
+    supportedResolutions: number[];
+    colorModes: string[];
+    documentFormats: string[];
+}
+export interface IEsclScanStatus {
+    state: 'Idle' | 'Processing' | 'Stopped' | 'Testing';
+    adfState?: 'Empty' | 'Loaded' | 'Jammed' | 'Open' | 'Closed';
+    jobs?: IEsclJobInfo[];
+}
+export interface IEsclJobInfo {
+    jobUri: string;
+    jobUuid: string;
+    age: number;
+    imagesCompleted: number;
+    imagesToTransfer: number;
+    jobState: 'Pending' | 'Processing' | 'Completed' | 'Canceled' | 'Aborted';
+    jobStateReason?: string;
+}
+export interface ISaneDevice {
+    name: string;
+    vendor: string;
+    model: string;
+    type: string;
+}
+export interface ISaneOption {
+    name: string;
+    title: string;
+    description: string;
+    type: 'bool' | 'int' | 'fixed' | 'string' | 'button' | 'group';
+    unit: 'none' | 'pixel' | 'bit' | 'mm' | 'dpi' | 'percent' | 'microsecond';
+    size: number;
+    capabilities: number;
+    constraintType: 'none' | 'range' | 'word_list' | 'string_list';
+    constraint?: ISaneConstraint;
+}
+export interface ISaneConstraint {
+    range?: {
+        min: number;
+        max: number;
+        quant: number;
+    };
+    wordList?: number[];
+    stringList?: string[];
+}
+export interface ISaneParameters {
+    format: 'gray' | 'rgb' | 'red' | 'green' | 'blue';
+    lastFrame: boolean;
+    bytesPerLine: number;
+    pixelsPerLine: number;
+    lines: number;
+    depth: number;
+}
+export interface INetworkScanOptions {
+    /** CIDR notation (e.g., "192.168.1.0/24") */
+    ipRange?: string;
+    /** Start IP address for range scan */
+    startIp?: string;
+    /** End IP address for range scan */
+    endIp?: string;
+    /** Maximum concurrent probes (default: 50) */
+    concurrency?: number;
+    /** Timeout per probe in milliseconds (default: 2000) */
+    timeout?: number;
+    /** Ports to probe (default: [80, 443, 631, 6566, 9100, 7000, 1400, 8009]) */
+    ports?: number[];
+    /** Check for eSCL scanners (default: true) */
+    probeEscl?: boolean;
+    /** Check for IPP printers (default: true) */
+    probeIpp?: boolean;
+    /** Check for SANE scanners (default: true) */
+    probeSane?: boolean;
+    /** Check for AirPlay speakers (default: true) */
+    probeAirplay?: boolean;
+    /** Check for Sonos speakers (default: true) */
+    probeSonos?: boolean;
+    /** Check for Chromecast devices (default: true) */
+    probeChromecast?: boolean;
+}
+export interface INetworkScanDevice {
+    type: 'scanner' | 'printer' | 'speaker';
+    protocol: 'escl' | 'sane' | 'ipp' | 'jetdirect' | 'airplay' | 'sonos' | 'chromecast';
+    port: number;
+    name?: string;
+    model?: string;
+}
+export interface INetworkScanResult {
+    address: string;
+    devices: INetworkScanDevice[];
+}
+export interface INetworkScanProgress {
+    /** Total IPs to scan */
+    total: number;
+    /** IPs scanned so far */
+    scanned: number;
+    /** Percentage complete (0-100) */
+    percentage: number;
+    /** Current IP being scanned */
+    currentIp?: string;
+    /** Devices found so far */
+    devicesFound: number;
+}
+export type TNetworkScannerEvents = {
+    'progress': (progress: INetworkScanProgress) => void;
+    'device:found': (result: INetworkScanResult) => void;
+    'complete': (results: INetworkScanResult[]) => void;
+    'error': (error: Error) => void;
+    'cancelled': () => void;
+};
+import type { TFeatureType } from './feature.interfaces.js';
+/**
+ * Criteria for selecting devices from the manager.
+ * Identity selectors (id, address) match exactly.
+ * Attribute selectors (name, model, manufacturer) match partially (case-insensitive).
+ * Capability selectors filter by feature availability.
+ */
+export interface IDeviceSelector {
+    /** Exact match on device ID */
+    id?: string;
+    /** Exact match on IP address */
+    address?: string;
+    /** Partial match on device name (case-insensitive) */
+    name?: string;
+    /** Partial match on device model (case-insensitive) */
+    model?: string;
+    /** Partial match on manufacturer name (case-insensitive) */
+    manufacturer?: string;
+    /** Device must have this feature */
+    hasFeature?: TFeatureType;
+    /** Device must have ALL of these features */
+    hasFeatures?: TFeatureType[];
+    /** Device must have ANY of these features */
+    hasAnyFeature?: TFeatureType[];
+}
+export * from './feature.interfaces.js';
+export * from './smarthome.interfaces.js';
+export * from './homeassistant.interfaces.js';

package/dist_ts/interfaces/index.js

@@ -0,0 +1,16 @@
+/**
+ * Device Manager Type Definitions
+ */
+// ============================================================================
+// Feature Types (Universal Device Architecture)
+// ============================================================================
+export * from './feature.interfaces.js';
+// ============================================================================
+// Smart Home Types (Generic, Protocol-agnostic)
+// ============================================================================
+export * from './smarthome.interfaces.js';
+// ============================================================================
+// Home Assistant Specific Types
+// ============================================================================
+export * from './homeassistant.interfaces.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9pbnRlcmZhY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBa1pILCtFQUErRTtBQUMvRSxnREFBZ0Q7QUFDaEQsK0VBQStFO0FBRS9FLGNBQWMseUJBQXlCLENBQUM7QUFFeEMsK0VBQStFO0FBQy9FLGdEQUFnRDtBQUNoRCwrRUFBK0U7QUFFL0UsY0FBYywyQkFBMkIsQ0FBQztBQUUxQywrRUFBK0U7QUFDL0UsZ0NBQWdDO0FBQ2hDLCtFQUErRTtBQUUvRSxjQUFjLCtCQUErQixDQUFDIn0=

package/dist_ts/interfaces/smarthome.interfaces.d.ts

@@ -0,0 +1,282 @@
+/**
+ * Smart Home Device Interfaces
+ * Generic types for smart home features (lights, climate, sensors, etc.)
+ * Protocol-agnostic - can be implemented by Home Assistant, Hue, MQTT, etc.
+ */
+import type { IFeatureInfo } from './feature.interfaces.js';
+export type TLightProtocol = 'home-assistant' | 'hue' | 'mqtt' | 'zigbee';
+export interface ILightCapabilities {
+    supportsBrightness: boolean;
+    supportsColorTemp: boolean;
+    supportsRgb: boolean;
+    supportsHs: boolean;
+    supportsXy: boolean;
+    supportsEffects: boolean;
+    supportsTransition: boolean;
+    effects?: string[];
+    minMireds?: number;
+    maxMireds?: number;
+    minColorTempKelvin?: number;
+    maxColorTempKelvin?: number;
+}
+export interface ILightState {
+    isOn: boolean;
+    brightness?: number;
+    colorTemp?: number;
+    colorTempMireds?: number;
+    rgbColor?: [number, number, number];
+    hsColor?: [number, number];
+    xyColor?: [number, number];
+    effect?: string;
+}
+export interface ILightFeatureInfo extends IFeatureInfo {
+    type: 'light';
+    protocol: TLightProtocol;
+    capabilities: ILightCapabilities;
+    currentState: ILightState;
+}
+export type TClimateProtocol = 'home-assistant' | 'nest' | 'ecobee' | 'mqtt';
+export type THvacMode = 'off' | 'heat' | 'cool' | 'heat_cool' | 'auto' | 'dry' | 'fan_only';
+export type THvacAction = 'off' | 'heating' | 'cooling' | 'drying' | 'idle' | 'fan';
+export interface IClimateCapabilities {
+    hvacModes: THvacMode[];
+    presetModes?: string[];
+    fanModes?: string[];
+    swingModes?: string[];
+    supportsTargetTemp: boolean;
+    supportsTargetTempRange: boolean;
+    supportsHumidity: boolean;
+    supportsAuxHeat: boolean;
+    minTemp: number;
+    maxTemp: number;
+    tempStep: number;
+    minHumidity?: number;
+    maxHumidity?: number;
+}
+export interface IClimateState {
+    currentTemp?: number;
+    targetTemp?: number;
+    targetTempHigh?: number;
+    targetTempLow?: number;
+    hvacMode: THvacMode;
+    hvacAction?: THvacAction;
+    presetMode?: string;
+    fanMode?: string;
+    swingMode?: string;
+    humidity?: number;
+    targetHumidity?: number;
+    auxHeat?: boolean;
+}
+export interface IClimateFeatureInfo extends IFeatureInfo {
+    type: 'climate';
+    protocol: TClimateProtocol;
+    capabilities: IClimateCapabilities;
+    currentState: IClimateState;
+}
+export type TSensorProtocol = 'home-assistant' | 'mqtt' | 'snmp';
+export type TSensorDeviceClass = 'temperature' | 'humidity' | 'pressure' | 'illuminance' | 'battery' | 'power' | 'energy' | 'voltage' | 'current' | 'frequency' | 'gas' | 'co2' | 'pm25' | 'pm10' | 'signal_strength' | 'timestamp' | 'duration' | 'distance' | 'speed' | 'weight' | 'monetary' | 'data_size' | 'data_rate' | 'water' | 'irradiance' | 'precipitation' | 'precipitation_intensity' | 'wind_speed';
+export type TSensorStateClass = 'measurement' | 'total' | 'total_increasing';
+export interface ISensorCapabilities {
+    deviceClass?: TSensorDeviceClass;
+    stateClass?: TSensorStateClass;
+    unit?: string;
+    nativeUnit?: string;
+    precision?: number;
+}
+export interface ISensorState {
+    value: string | number | boolean;
+    numericValue?: number;
+    unit?: string;
+    lastUpdated: Date;
+}
+export interface ISensorFeatureInfo extends IFeatureInfo {
+    type: 'sensor';
+    protocol: TSensorProtocol;
+    capabilities: ISensorCapabilities;
+    currentState: ISensorState;
+}
+export type TCameraProtocol = 'home-assistant' | 'onvif' | 'rtsp';
+export interface ICameraCapabilities {
+    supportsStream: boolean;
+    supportsPtz: boolean;
+    supportsSnapshot: boolean;
+    supportsMotionDetection: boolean;
+    frontendStreamType?: 'hls' | 'web_rtc';
+    streamUrl?: string;
+}
+export interface ICameraState {
+    isRecording: boolean;
+    isStreaming: boolean;
+    motionDetected: boolean;
+}
+export interface ICameraFeatureInfo extends IFeatureInfo {
+    type: 'camera';
+    protocol: TCameraProtocol;
+    capabilities: ICameraCapabilities;
+    currentState: ICameraState;
+}
+export type TCoverProtocol = 'home-assistant' | 'mqtt' | 'somfy';
+export type TCoverDeviceClass = 'awning' | 'blind' | 'curtain' | 'damper' | 'door' | 'garage' | 'gate' | 'shade' | 'shutter' | 'window';
+export type TCoverState = 'open' | 'opening' | 'closed' | 'closing' | 'stopped' | 'unknown';
+export interface ICoverCapabilities {
+    deviceClass?: TCoverDeviceClass;
+    supportsOpen: boolean;
+    supportsClose: boolean;
+    supportsStop: boolean;
+    supportsPosition: boolean;
+    supportsTilt: boolean;
+}
+export interface ICoverStateInfo {
+    state: TCoverState;
+    position?: number;
+    tiltPosition?: number;
+}
+export interface ICoverFeatureInfo extends IFeatureInfo {
+    type: 'cover';
+    protocol: TCoverProtocol;
+    capabilities: ICoverCapabilities;
+    currentState: ICoverStateInfo;
+}
+export type TSwitchProtocol = 'home-assistant' | 'mqtt' | 'tasmota' | 'tuya';
+export type TSwitchDeviceClass = 'outlet' | 'switch';
+export interface ISwitchCapabilities {
+    deviceClass?: TSwitchDeviceClass;
+}
+export interface ISwitchState {
+    isOn: boolean;
+}
+export interface ISwitchFeatureInfo extends IFeatureInfo {
+    type: 'switch';
+    protocol: TSwitchProtocol;
+    capabilities: ISwitchCapabilities;
+    currentState: ISwitchState;
+}
+export type TLockProtocol = 'home-assistant' | 'mqtt' | 'august' | 'yale';
+export type TLockState = 'locked' | 'unlocked' | 'locking' | 'unlocking' | 'jammed' | 'unknown';
+export interface ILockCapabilities {
+    supportsOpen: boolean;
+}
+export interface ILockStateInfo {
+    state: TLockState;
+    isLocked: boolean;
+}
+export interface ILockFeatureInfo extends IFeatureInfo {
+    type: 'lock';
+    protocol: TLockProtocol;
+    capabilities: ILockCapabilities;
+    currentState: ILockStateInfo;
+}
+export type TFanProtocol = 'home-assistant' | 'mqtt' | 'bond';
+export type TFanDirection = 'forward' | 'reverse';
+export interface IFanCapabilities {
+    supportsSpeed: boolean;
+    supportsOscillate: boolean;
+    supportsDirection: boolean;
+    supportsPresetModes: boolean;
+    presetModes?: string[];
+    speedCount?: number;
+}
+export interface IFanState {
+    isOn: boolean;
+    percentage?: number;
+    presetMode?: string;
+    oscillating?: boolean;
+    direction?: TFanDirection;
+}
+export interface IFanFeatureInfo extends IFeatureInfo {
+    type: 'fan';
+    protocol: TFanProtocol;
+    capabilities: IFanCapabilities;
+    currentState: IFanState;
+}
+/**
+ * Light protocol client interface
+ * Implemented by HomeAssistantProtocol, HueProtocol, etc.
+ */
+export interface ILightProtocolClient {
+    turnOn(entityId: string, options?: {
+        brightness?: number;
+        colorTemp?: number;
+        rgb?: [number, number, number];
+        transition?: number;
+    }): Promise<void>;
+    turnOff(entityId: string, options?: {
+        transition?: number;
+    }): Promise<void>;
+    toggle(entityId: string): Promise<void>;
+    setBrightness(entityId: string, brightness: number, transition?: number): Promise<void>;
+    setColorTemp(entityId: string, kelvin: number, transition?: number): Promise<void>;
+    setRgbColor(entityId: string, r: number, g: number, b: number, transition?: number): Promise<void>;
+    setEffect(entityId: string, effect: string): Promise<void>;
+    getState(entityId: string): Promise<ILightState>;
+}
+/**
+ * Climate protocol client interface
+ */
+export interface IClimateProtocolClient {
+    setHvacMode(entityId: string, mode: THvacMode): Promise<void>;
+    setTargetTemp(entityId: string, temp: number): Promise<void>;
+    setTargetTempRange(entityId: string, low: number, high: number): Promise<void>;
+    setPresetMode(entityId: string, preset: string): Promise<void>;
+    setFanMode(entityId: string, mode: string): Promise<void>;
+    setSwingMode(entityId: string, mode: string): Promise<void>;
+    setAuxHeat(entityId: string, enabled: boolean): Promise<void>;
+    getState(entityId: string): Promise<IClimateState>;
+}
+/**
+ * Sensor protocol client interface (read-only)
+ */
+export interface ISensorProtocolClient {
+    getState(entityId: string): Promise<ISensorState>;
+}
+/**
+ * Camera protocol client interface
+ */
+export interface ICameraProtocolClient {
+    getSnapshot(entityId: string): Promise<Buffer>;
+    getSnapshotUrl(entityId: string): Promise<string>;
+    getStreamUrl(entityId: string): Promise<string>;
+    getState(entityId: string): Promise<ICameraState>;
+}
+/**
+ * Cover protocol client interface
+ */
+export interface ICoverProtocolClient {
+    open(entityId: string): Promise<void>;
+    close(entityId: string): Promise<void>;
+    stop(entityId: string): Promise<void>;
+    setPosition(entityId: string, position: number): Promise<void>;
+    setTiltPosition(entityId: string, position: number): Promise<void>;
+    getState(entityId: string): Promise<ICoverStateInfo>;
+}
+/**
+ * Switch protocol client interface
+ */
+export interface ISwitchProtocolClient {
+    turnOn(entityId: string): Promise<void>;
+    turnOff(entityId: string): Promise<void>;
+    toggle(entityId: string): Promise<void>;
+    getState(entityId: string): Promise<ISwitchState>;
+}
+/**
+ * Lock protocol client interface
+ */
+export interface ILockProtocolClient {
+    lock(entityId: string): Promise<void>;
+    unlock(entityId: string): Promise<void>;
+    open(entityId: string): Promise<void>;
+    getState(entityId: string): Promise<ILockStateInfo>;
+}
+/**
+ * Fan protocol client interface
+ */
+export interface IFanProtocolClient {
+    turnOn(entityId: string, percentage?: number): Promise<void>;
+    turnOff(entityId: string): Promise<void>;
+    toggle(entityId: string): Promise<void>;
+    setPercentage(entityId: string, percentage: number): Promise<void>;
+    setPresetMode(entityId: string, mode: string): Promise<void>;
+    setOscillating(entityId: string, oscillating: boolean): Promise<void>;
+    setDirection(entityId: string, direction: TFanDirection): Promise<void>;
+    getState(entityId: string): Promise<IFanState>;
+}

package/dist_ts/interfaces/smarthome.interfaces.js

@@ -0,0 +1,7 @@
+/**
+ * Smart Home Device Interfaces
+ * Generic types for smart home features (lights, climate, sensors, etc.)
+ * Protocol-agnostic - can be implemented by Home Assistant, Hue, MQTT, etc.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRob21lLmludGVyZmFjZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9pbnRlcmZhY2VzL3NtYXJ0aG9tZS5pbnRlcmZhY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUcifQ==

package/dist_ts/paths.d.ts

@@ -0,0 +1 @@
+export declare const packageDir: string;

package/dist_ts/paths.js

@@ -0,0 +1,3 @@
+import * as plugins from './plugins.js';
+export const packageDir = plugins.path.join(plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url), '../');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF0aHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9wYXRocy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQUN4QyxNQUFNLENBQUMsTUFBTSxVQUFVLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQ3pDLE9BQU8sQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLHdCQUF3QixDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQy9ELEtBQUssQ0FDTixDQUFDIn0=

package/dist_ts/plugins.d.ts

@@ -0,0 +1,23 @@
+import * as path from 'path';
+import * as net from 'net';
+import * as dgram from 'dgram';
+import * as events from 'events';
+export { path, net, dgram, events };
+import * as smartpath from '@push.rocks/smartpath';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartnetwork from '@push.rocks/smartnetwork';
+import { SmartRequest } from '@push.rocks/smartrequest';
+export { SmartRequest };
+export { smartpath, smartpromise, smartdelay, smartnetwork, };
+import * as bonjourService from 'bonjour-service';
+import ipp from 'ipp';
+import * as netSnmp from 'net-snmp';
+import * as sonos from 'sonos';
+import * as castv2Client from 'castv2-client';
+import WebSocket from 'ws';
+declare const nodeSsdp: {
+    Client: any;
+    Server: any;
+};
+export { bonjourService, ipp, nodeSsdp, netSnmp, sonos, castv2Client, WebSocket };