playlist-data-engine 1.1.0

package/dist/core/sensors/MotionDetector.d.ts

@@ -0,0 +1,58 @@
+import type { MotionData } from '../types/Environmental';
+export declare class MotionDetector {
+    private logger;
+    private isListening;
+    private lastMotion;
+    private motionCallback;
+    private lastProcessedTime;
+    private readonly minSampleIntervalMs;
+    private deltaBuffer;
+    private readonly bufferSize;
+    private confirmedActivity;
+    private candidateActivity;
+    private candidateStartTime;
+    private readonly confirmationMs;
+    /**
+     * Start listening for motion events
+     * @param callback Callback function to receive motion data
+     */
+    startMonitoring(callback: (data: MotionData) => void): void;
+    /**
+     * Stop listening for motion events
+     */
+    stopMonitoring(): void;
+    /**
+     * Get the last recorded motion data
+     */
+    getLastMotion(): MotionData | null;
+    /**
+     * Detect activity type based on smoothed motion data
+     * @param data MotionData to analyze
+     * @returns 'stationary' | 'walking' | 'running' | 'driving' | 'unknown'
+     *
+     * @remarks
+     * When the smoothing buffer has enough samples (from live monitoring),
+     * returns the confirmed activity state which only changes after the new
+     * state has been sustained for `confirmationMs`. This prevents rapid
+     * flickering between stationary/walking when the accelerometer oscillates
+     * during each footfall.
+     *
+     * Falls back to instantaneous classification when the buffer is empty
+     * (e.g. before monitoring starts or on devices without real accelerometers).
+     */
+    detectActivity(data: MotionData): 'stationary' | 'walking' | 'running' | 'driving' | 'unknown';
+    /**
+     * Feed a new acceleration delta into the smoothing buffer and update
+     * the confirmed activity state.
+     *
+     * The smoothing works bidirectionally:
+     * - stationary → walking requires sustained motion above the threshold
+     * - walking → stationary requires sustained stillness below the threshold
+     *
+     * Both directions require the new state to persist for `confirmationMs`
+     * before the confirmed state changes, preventing UI jitter.
+     */
+    private updateSmoothing;
+    private handleMotion;
+}
+//# sourceMappingURL=MotionDetector.d.ts.map

package/dist/core/sensors/MotionDetector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MotionDetector.d.ts","sourceRoot":"","sources":["../../../src/core/sensors/MotionDetector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAGzD,qBAAa,cAAc;IACvB,OAAO,CAAC,MAAM,CAAgC;IAC9C,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,UAAU,CAA2B;IAC7C,OAAO,CAAC,cAAc,CAA6C;IAInE,OAAO,CAAC,iBAAiB,CAAa;IACtC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAM;IAM1C,OAAO,CAAC,WAAW,CAAgB;IACnC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAM;IACjC,OAAO,CAAC,iBAAiB,CAA2E;IACpG,OAAO,CAAC,iBAAiB,CAA6E;IACtG,OAAO,CAAC,kBAAkB,CAAa;IACvC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAQ;IAEvC;;;OAGG;IACH,eAAe,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,GAAG,IAAI;IAiB3D;;OAEG;IACH,cAAc,IAAI,IAAI;IAatB;;OAEG;IACH,aAAa,IAAI,UAAU,GAAG,IAAI;IAIlC;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,YAAY,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS;IAyB9F;;;;;;;;;;OAUG;IACH,OAAO,CAAC,eAAe;IAmCvB,OAAO,CAAC,YAAY,CAkDlB;CACL"}

package/dist/core/sensors/SteamAPIClient.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Performance metrics for API calls
+ */
+interface PerformanceMetrics {
+    successCount: number;
+    errorCount: number;
+    totalTime: number;
+    minTime: number;
+    maxTime: number;
+    lastCallTimestamp: number | null;
+}
+/**
+ * SteamAPIClient - Handles integration with Steam Web API
+ * Fetches currently played games and game metadata
+ */
+export declare class SteamAPIClient {
+    private apiKey;
+    private baseUrl;
+    private logger;
+    private currentGameApiMetrics;
+    private metadataApiMetrics;
+    private recentCurrentGameTimes;
+    private recentMetadataTimes;
+    private readonly maxRecentSamples;
+    constructor(apiKey?: string);
+    /**
+     * Calculate percentile from an array of numbers
+     */
+    private calculatePercentile;
+    /**
+     * Record performance metrics for current game API call
+     */
+    private recordCurrentGameApiCall;
+    /**
+     * Record performance metrics for metadata API call
+     */
+    private recordMetadataApiCall;
+    /**
+     * Get performance metrics for current game API
+     */
+    getCurrentGameApiMetrics(): PerformanceMetrics;
+    /**
+     * Get performance statistics for current game API
+     */
+    getCurrentGameApiStatistics(): {
+        average: number;
+        min: number;
+        max: number;
+        totalCalls: number;
+        successRate: number;
+        p95: number;
+        p99: number;
+    };
+    /**
+     * Get performance metrics for metadata API
+     */
+    getMetadataApiMetrics(): PerformanceMetrics;
+    /**
+     * Get performance statistics for metadata API
+     */
+    getMetadataApiStatistics(): {
+        average: number;
+        min: number;
+        max: number;
+        totalCalls: number;
+        successRate: number;
+        p95: number;
+        p99: number;
+    };
+    /**
+     * Reset all performance metrics
+     */
+    resetPerformanceMetrics(): void;
+    /**
+     * Get currently played game for a Steam user
+     * Uses ISteamUser/GetPlayerSummaries to detect real-time "in-game" status.
+     * GetPlayerSummaries returns `gameextrainfo` and `gameid` only when the user
+     * is actively in a game right now — unlike GetRecentlyPlayedGames which only
+     * shows games played in the last 2 weeks with no "currently playing" indicator.
+     */
+    getCurrentGame(steamUserId: string): Promise<{
+        name: string;
+        appId: number;
+        source: 'steam';
+        sessionDuration?: number;
+    } | null>;
+    /**
+     * Get game metadata (genre, description, etc.)
+     * Uses ISteamApps/GetAppList and store API to fetch game details
+     */
+    getGameMetadata(gameName: string): Promise<{
+        appId?: number;
+        name: string;
+        genre?: string[];
+        description?: string;
+    } | null>;
+    /**
+     * Find Steam app ID by game name
+     */
+    private findAppId;
+    /**
+     * Get game schema/stats for a game
+     * Uses ISteamUserStats/GetSchemaForGame
+     */
+    getGameSchema(appId: number): Promise<any>;
+}
+export {};
+//# sourceMappingURL=SteamAPIClient.d.ts.map

package/dist/core/sensors/SteamAPIClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SteamAPIClient.d.ts","sourceRoot":"","sources":["../../../src/core/sensors/SteamAPIClient.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,UAAU,kBAAkB;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;CACpC;AAED;;;GAGG;AACH,qBAAa,cAAc;IACvB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,OAAO,CAA0C;IACzD,OAAO,CAAC,MAAM,CAAgC;IAG9C,OAAO,CAAC,qBAAqB,CAO3B;IAGF,OAAO,CAAC,kBAAkB,CAOxB;IAGF,OAAO,CAAC,sBAAsB,CAAgB;IAC9C,OAAO,CAAC,mBAAmB,CAAgB;IAC3C,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAO;gBAE5B,MAAM,GAAE,MAAW;IAI/B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAO3B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAqBhC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAqB7B;;OAEG;IACH,wBAAwB,IAAI,kBAAkB;IAI9C;;OAEG;IACH,2BAA2B,IAAI;QAC3B,OAAO,EAAE,MAAM,CAAC;QAChB,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;QACZ,UAAU,EAAE,MAAM,CAAC;QACnB,WAAW,EAAE,MAAM,CAAC;QACpB,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;KACf;IAoBD;;OAEG;IACH,qBAAqB,IAAI,kBAAkB;IAI3C;;OAEG;IACH,wBAAwB,IAAI;QACxB,OAAO,EAAE,MAAM,CAAC;QAChB,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;QACZ,UAAU,EAAE,MAAM,CAAC;QACnB,WAAW,EAAE,MAAM,CAAC;QACpB,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;KACf;IAoBD;;OAEG;IACH,uBAAuB,IAAI,IAAI;IAqB/B;;;;;;OAMG;IACG,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC;QAC/C,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,OAAO,CAAC;QAChB,eAAe,CAAC,EAAE,MAAM,CAAC;KAC5B,GAAG,IAAI,CAAC;IA0CT;;;OAGG;IACG,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;QAC7C,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;QACjB,WAAW,CAAC,EAAE,MAAM,CAAC;KACxB,GAAG,IAAI,CAAC;IA2CT;;OAEG;YACW,SAAS;IA2BvB;;;OAGG;IACG,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;CAoBnD"}

package/dist/core/sensors/WeatherAPIClient.d.ts

@@ -0,0 +1,360 @@
+import type { WeatherData, ForecastData, PerformanceMetrics, PerformanceStatistics, SolarInfo } from '../types/Environmental';
+import type { WeatherSensorConfig } from '../config/sensorConfig.js';
+interface CacheStatistics {
+    hits: number;
+    misses: number;
+}
+/**
+ * Severe weather alert types with XP bonus multipliers
+ */
+export declare enum SevereWeatherType {
+    Blizzard = "Blizzard",
+    Hurricane = "Hurricane",
+    Typhoon = "Typhoon",
+    Tornado = "Tornado",
+    None = "None"
+}
+/**
+ * Severe weather alert information
+ */
+export interface SevereWeatherAlert {
+    type: SevereWeatherType;
+    xpBonus: number;
+    severity: 'moderate' | 'high' | 'extreme';
+    message: string;
+    detectedAt: number;
+}
+export declare class WeatherAPIClient {
+    private apiKey;
+    private baseUrl;
+    private forecastUrl;
+    private cache;
+    private forecastCache;
+    private cacheTTL;
+    private forecastCacheTTL;
+    private cacheStats;
+    private useLocalStorage;
+    private logger;
+    private lastKnownLocation;
+    private weatherApiMetrics;
+    private forecastApiMetrics;
+    private recentWeatherApiTimes;
+    private recentForecastApiTimes;
+    private readonly maxRecentSamples;
+    constructor(apiKey?: string, cacheTTLMinutes?: number, useLocalStorage?: boolean);
+    constructor(config: WeatherSensorConfig);
+    /**
+     * Check if localStorage is available
+     */
+    private isLocalStorageAvailable;
+    /**
+     * Load cache from localStorage
+     */
+    private loadFromLocalStorage;
+    /**
+     * Save cache to localStorage
+     */
+    private saveToLocalStorage;
+    /**
+     * Start timing an API call
+     * @returns A function that when called, records the elapsed time
+     */
+    private startTiming;
+    /**
+     * Record performance metrics for weather API call
+     */
+    private recordWeatherApiCall;
+    /**
+     * Record performance metrics for forecast API call
+     */
+    private recordForecastApiCall;
+    /**
+     * Calculate percentile from an array of numbers
+     */
+    private calculatePercentile;
+    /**
+     * Get performance statistics for weather API
+     */
+    private getPerformanceStatistics;
+    /**
+     * Get performance metrics for weather API
+     * @returns Performance metrics for current weather API calls
+     */
+    getWeatherApiMetrics(): PerformanceMetrics;
+    /**
+     * Get performance statistics for weather API
+     * @returns Calculated performance statistics including average, min, max, success rate
+     */
+    getWeatherApiStatistics(): PerformanceStatistics & {
+        p95: number;
+        p99: number;
+    };
+    /**
+     * Get performance metrics for forecast API
+     * @returns Performance metrics for forecast API calls
+     */
+    getForecastApiMetrics(): PerformanceMetrics;
+    /**
+     * Get performance statistics for forecast API
+     * @returns Calculated performance statistics including average, min, max, success rate
+     */
+    getForecastApiStatistics(): PerformanceStatistics & {
+        p95: number;
+        p99: number;
+    };
+    /**
+     * Reset all performance metrics
+     */
+    resetPerformanceMetrics(): void;
+    /**
+     * Generate cache key from coordinates
+     * @param latitude Latitude
+     * @param longitude Longitude
+     * @returns Cache key string
+     */
+    private getCacheKey;
+    /**
+     * Check if a cache entry is still valid
+     * @param entry Cache entry to validate
+     * @returns True if entry is valid and within TTL
+     */
+    private isCacheEntryValid;
+    /**
+     * Calculate the moon phase for a given date using astronomical algorithms.
+     *
+     * Returns a value between 0 and 1 representing the moon's illumination phase:
+     * - 0.0 = New Moon (completely dark)
+     * - 0.25 = First Quarter (half illuminated, waxing)
+     * - 0.5 = Full Moon (fully illuminated)
+     * - 0.75 = Last Quarter (half illuminated, waning)
+     * - 1.0 = New Moon (cycle completes)
+     *
+     * Algorithm: Uses a simplified version of the Conway method combined with
+     * astronomical calculations based on the known date of a new moon reference.
+     *
+     * Reference: Based on the mean synodic month of 29.530588853 days
+     * (the average time from new moon to new moon).
+     *
+     * @param date The date for which to calculate the moon phase
+     * @returns Moon phase value between 0 and 1
+     */
+    private calculateMoonPhase;
+    /**
+     * Get solar information including sunrise, sunset, and day stage.
+     * Works WITHOUT API key using astronomical calculations (NOAA algorithm).
+     *
+     * @param latitude - Latitude in decimal degrees (-90 to 90)
+     * @param longitude - Longitude in decimal degrees (-180 to 180)
+     * @param date - Optional date for calculation (defaults to now)
+     * @returns SolarInfo object with sunrise, sunset, solar noon, and day stage
+     */
+    getSolarInfo(latitude: number, longitude: number, date?: Date): SolarInfo;
+    /**
+     * Calculate solar information using astronomical formulas (NOAA algorithm)
+     * Based on "Astronomical Algorithms" by Jean Meeus
+     */
+    private calculateSolarInfo;
+    /**
+     * Convert degrees to radians
+     */
+    private toRadians;
+    /**
+     * Convert radians to degrees
+     */
+    private toDegrees;
+    /**
+     * Calculate Julian Date from a Date object
+     * Julian Date is a continuous count of days since January 1, 4713 BC
+     */
+    private calculateJulianDate;
+    /**
+     * Calculate Julian Century from Julian Date
+     * Julian Century is used in solar position calculations
+     */
+    private calculateJulianCentury;
+    /**
+     * Calculate the sun's declination angle at a given Julian century
+     * Returns declination in degrees
+     */
+    private calculateSolarDeclination;
+    /**
+     * Calculate the equation of time (minutes)
+     * This accounts for the difference between apparent solar time and mean solar time
+     */
+    private calculateEquationOfTime;
+    /**
+     * Calculate hour angle for sunrise/sunset
+     * @param latitude - Latitude in degrees
+     * @param declination - Solar declination in degrees
+     * @param zenith - Zenith angle (90.833 for sunrise/sunset, 96 for civil twilight)
+     * @returns Hour angle in degrees, or NaN if sun doesn't rise/set (polar regions)
+     */
+    private calculateHourAngle;
+    /**
+     * Calculate sunrise or sunset time
+     * @param latitude - Latitude in degrees
+     * @param longitude - Longitude in degrees
+     * @param date - Date to calculate for
+     * @param isSunrise - True for sunrise, false for sunset
+     * @returns Date object with sunrise/sunset time (UTC), or Invalid Date for polar regions
+     */
+    private calculateSunriseSunset;
+    /**
+     * Calculate solar noon time
+     * @param latitude - Latitude in degrees (not used in calculation but kept for consistency)
+     * @param longitude - Longitude in degrees
+     * @param date - Date to calculate for
+     * @returns Date object with solar noon time (UTC)
+     */
+    private calculateSolarNoon;
+    /**
+     * Calculate twilight time (dawn or dusk)
+     * @param latitude - Latitude in degrees
+     * @param longitude - Longitude in degrees
+     * @param date - Date to calculate for
+     * @param type - Twilight type: 'civil' (6°), 'nautical' (12°), or 'astronomical' (18°)
+     * @param isDawn - True for dawn, false for dusk
+     * @returns Date object with twilight time (UTC), or Invalid Date for polar regions
+     */
+    private calculateTwilight;
+    /**
+     * Calculate current sun position (altitude and azimuth)
+     * @param latitude - Latitude in degrees
+     * @param longitude - Longitude in degrees
+     * @param date - Date/time to calculate for
+     * @returns Object with altitude and azimuth in degrees
+     */
+    private calculateSunPosition;
+    /**
+     * Determine the current day stage based on time relative to sunrise/sunset/twilight
+     */
+    private determineDayStage;
+    /**
+     * Fetch current weather for coordinates
+     * @param latitude Latitude
+     * @param longitude Longitude
+     * @returns Promise resolving to WeatherData or null if failed
+     */
+    getWeather(latitude: number, longitude: number): Promise<WeatherData | null>;
+    /**
+     * Invalidate all cached weather data
+     */
+    invalidateCache(): void;
+    /**
+     * Invalidate cache for a specific location
+     * @param latitude Latitude
+     * @param longitude Longitude
+     */
+    invalidateLocation(latitude: number, longitude: number): void;
+    /**
+     * Get cache statistics
+     * @returns Cache statistics object
+     */
+    getCacheStats(): CacheStatistics;
+    /**
+     * Reset cache statistics
+     */
+    resetCacheStats(): void;
+    /**
+     * Clear expired cache entries
+     * @returns Number of entries cleared
+     */
+    clearExpiredEntries(): number;
+    /**
+     * Get current cache size
+     * @returns Number of cached entries
+     */
+    getCacheSize(): number;
+    /**
+     * Get the last known location used for weather queries
+     * Used for tropical region detection in severe weather alerts
+     * @returns Last known location or null if no weather has been fetched
+     */
+    getLastKnownLocation(): {
+        latitude: number;
+        longitude: number;
+    } | null;
+    /**
+     * Check if a forecast cache entry is still valid
+     * @param entry Forecast cache entry to validate
+     * @returns True if entry is valid and within TTL
+     */
+    private isForecastCacheEntryValid;
+    /**
+     * Generate forecast cache key with hours limit
+     * @param latitude Latitude
+     * @param longitude Longitude
+     * @param hours Number of hours to forecast
+     * @returns Forecast cache key string
+     */
+    private getForecastCacheKey;
+    /**
+     * Fetch weather forecast for coordinates
+     * @param latitude Latitude
+     * @param longitude Longitude
+     * @param hours Number of hours to return (max 120 hours / 5 days)
+     * @returns Promise resolving to array of ForecastData or null if failed
+     */
+    getForecast(latitude: number, longitude: number, hours?: number): Promise<ForecastData[] | null>;
+    /**
+     * Get upcoming weather changes for XP modifier calculation
+     * @param latitude Latitude
+     * @param longitude Longitude
+     * @param hours Hours ahead to check (default: 12 hours)
+     * @returns Promise resolving to upcoming weather info or null
+     */
+    getUpcomingWeather(latitude: number, longitude: number, hours?: number): Promise<{
+        willRain: boolean;
+        willSnow: boolean;
+        rainProbability: number;
+        snowProbability: number;
+        worstWeatherType: string;
+    } | null>;
+    /**
+     * Detect severe weather conditions from current or forecast data
+     *
+     * Analyzes weather conditions to detect severe weather events including:
+     * - Blizzard: Heavy snow with high winds (>25 km/h)
+     * - Hurricane/Typhoon: Extreme wind speeds (>118 km/h) with rain/storm
+     * - Tornado: Tornado weather type detected (API-specific)
+     *
+     * @param weather Weather data to analyze
+     * @returns Severe weather alert or null if conditions are normal
+     */
+    detectSevereWeather(weather: WeatherData | ForecastData): SevereWeatherAlert | null;
+    /**
+     * Helper method to determine if a location is in tropical region
+     *
+     * Tropical regions are roughly between the Tropic of Cancer (23.5°N) and
+     * the Tropic of Capricorn (23.5°S). This is where hurricanes and typhoons
+     * are most likely to form.
+     *
+     * @param latitude Latitude in decimal degrees
+     * @returns True if in tropical region (between 23.5°N and 23.5°S)
+     */
+    private isTropicalRegion;
+    /**
+     * Get safety warning message for severe weather
+     *
+     * @param alert Severe weather alert
+     * @returns Safety warning message with recommendations
+     */
+    getSafetyWarning(alert: SevereWeatherAlert): string;
+    /**
+     * Invalidate all forecast cache
+     */
+    invalidateForecastCache(): void;
+    /**
+     * Invalidate forecast cache for a specific location
+     * @param latitude Latitude
+     * @param longitude Longitude
+     */
+    invalidateForecastLocation(latitude: number, longitude: number): void;
+    /**
+     * Clear expired forecast cache entries
+     * @returns Number of entries cleared
+     */
+    clearExpiredForecastEntries(): number;
+}
+export {};
+//# sourceMappingURL=WeatherAPIClient.d.ts.map

package/dist/core/sensors/WeatherAPIClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WeatherAPIClient.d.ts","sourceRoot":"","sources":["../../../src/core/sensors/WeatherAPIClient.ts"],"names":[],"mappings":"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"}

package/dist/core/sensors/schemas/weather.schema.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Zod validation schemas for OpenWeatherMap API responses
+ *
+ * These schemas validate the structure of responses from:
+ * - Current Weather API: https://api.openweathermap.org/data/2.5/weather
+ * - 5-Day/3-Hour Forecast API: https://api.openweathermap.org/data/2.5/forecast
+ *
+ * Reference: https://openweathermap.org/api
+ */
+import { z } from 'zod';
+/**
+ * OpenWeatherMap Current Weather API Response Schema
+ *
+ * Validates responses from the /weather endpoint
+ *
+ * Example response structure:
+ * {
+ *   "coord": { "lon": 10.99, "lat": 44.34 },
+ *   "weather": [{ "id": 501, "main": "Rain", "description": "moderate rain", "icon": "10d" }],
+ *   "main": { "temp": 298.48, "pressure": 1015, "humidity": 64 },
+ *   "wind": { "speed": 0.62, "deg": 349 },
+ *   "sys": { "sunrise": 1661834187, "sunset": 1661882248 }
+ * }
+ */
+export declare const OpenWeatherMapCurrentResponseSchema: z.ZodObject<{
+    coord: z.ZodOptional<z.ZodObject<{
+        lon: z.ZodNumber;
+        lat: z.ZodNumber;
+    }, z.core.$strip>>;
+    weather: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        main: z.ZodString;
+        description: z.ZodString;
+        icon: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    base: z.ZodOptional<z.ZodString>;
+    main: z.ZodObject<{
+        temp: z.ZodNumber;
+        feels_like: z.ZodOptional<z.ZodNumber>;
+        temp_min: z.ZodOptional<z.ZodNumber>;
+        temp_max: z.ZodOptional<z.ZodNumber>;
+        pressure: z.ZodNumber;
+        humidity: z.ZodNumber;
+        sea_level: z.ZodOptional<z.ZodNumber>;
+        grnd_level: z.ZodOptional<z.ZodNumber>;
+        temp_kf: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    visibility: z.ZodOptional<z.ZodNumber>;
+    wind: z.ZodOptional<z.ZodObject<{
+        speed: z.ZodNumber;
+        deg: z.ZodOptional<z.ZodNumber>;
+        gust: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    rain: z.ZodOptional<z.ZodObject<{
+        '1h': z.ZodOptional<z.ZodNumber>;
+        '3h': z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    snow: z.ZodOptional<z.ZodObject<{
+        '1h': z.ZodOptional<z.ZodNumber>;
+        '3h': z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    clouds: z.ZodOptional<z.ZodObject<{
+        all: z.ZodNumber;
+    }, z.core.$strip>>;
+    dt: z.ZodNumber;
+    sys: z.ZodObject<{
+        type: z.ZodOptional<z.ZodNumber>;
+        id: z.ZodOptional<z.ZodNumber>;
+        country: z.ZodOptional<z.ZodString>;
+        sunrise: z.ZodNumber;
+        sunset: z.ZodNumber;
+        pod: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    timezone: z.ZodOptional<z.ZodNumber>;
+    id: z.ZodOptional<z.ZodNumber>;
+    name: z.ZodOptional<z.ZodString>;
+    cod: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const OpenWeatherMapForecastResponseSchema: z.ZodObject<{
+    cod: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    message: z.ZodOptional<z.ZodNumber>;
+    cnt: z.ZodOptional<z.ZodNumber>;
+    list: z.ZodArray<z.ZodObject<{
+        dt: z.ZodNumber;
+        main: z.ZodObject<{
+            temp: z.ZodNumber;
+            feels_like: z.ZodOptional<z.ZodNumber>;
+            temp_min: z.ZodOptional<z.ZodNumber>;
+            temp_max: z.ZodOptional<z.ZodNumber>;
+            pressure: z.ZodNumber;
+            humidity: z.ZodNumber;
+            sea_level: z.ZodOptional<z.ZodNumber>;
+            grnd_level: z.ZodOptional<z.ZodNumber>;
+            temp_kf: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        weather: z.ZodArray<z.ZodObject<{
+            id: z.ZodNumber;
+            main: z.ZodString;
+            description: z.ZodString;
+            icon: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        clouds: z.ZodOptional<z.ZodObject<{
+            all: z.ZodNumber;
+        }, z.core.$strip>>;
+        wind: z.ZodOptional<z.ZodObject<{
+            speed: z.ZodNumber;
+            deg: z.ZodOptional<z.ZodNumber>;
+            gust: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        visibility: z.ZodOptional<z.ZodNumber>;
+        pop: z.ZodOptional<z.ZodNumber>;
+        rain: z.ZodOptional<z.ZodObject<{
+            '1h': z.ZodOptional<z.ZodNumber>;
+            '3h': z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        snow: z.ZodOptional<z.ZodObject<{
+            '1h': z.ZodOptional<z.ZodNumber>;
+            '3h': z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        sys: z.ZodOptional<z.ZodObject<{
+            pod: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        dt_txt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    city: z.ZodOptional<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        coord: z.ZodObject<{
+            lon: z.ZodNumber;
+            lat: z.ZodNumber;
+        }, z.core.$strip>;
+        country: z.ZodOptional<z.ZodString>;
+        population: z.ZodOptional<z.ZodNumber>;
+        timezone: z.ZodOptional<z.ZodNumber>;
+        sunrise: z.ZodOptional<z.ZodNumber>;
+        sunset: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Type exports for validated data
+ */
+export type OpenWeatherMapCurrentResponse = z.infer<typeof OpenWeatherMapCurrentResponseSchema>;
+export type OpenWeatherMapForecastResponse = z.infer<typeof OpenWeatherMapForecastResponseSchema>;
+//# sourceMappingURL=weather.schema.d.ts.map

package/dist/core/sensors/schemas/weather.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"weather.schema.d.ts","sourceRoot":"","sources":["../../../../src/core/sensors/schemas/weather.schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA+ExB;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgB9C,CAAC;AAyCH,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAe/C,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAC;AAChG,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAC"}