@texturehq/device 1.12.0 → 1.13.0

package/dist/deviceModel/entities.d.ts

@@ -27,7 +27,7 @@ export declare const DeviceModelSchema: z.ZodObject<{
      * The type of the device.
      * @example "inverter"
      */
-    type: z.ZodEnum<["battery", "charger", "inverter", "thermostat", "vehicle", "other", "unknown"]>;
+    type: z.ZodEnum<["battery", "charger", "inverter", "meter", "thermostat", "vehicle", "other", "unknown"]>;
     /**
      * The manufacturer of the device.
      */
@@ -146,7 +146,7 @@ export declare const DeviceModelSchema: z.ZodObject<{
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     name: string;
-    type: "other" | "unknown" | "battery" | "charger" | "inverter" | "thermostat" | "vehicle";
+    type: "other" | "unknown" | "meter" | "battery" | "charger" | "inverter" | "thermostat" | "vehicle";
     slug: string;
     manufacturer: {
         name: string;
@@ -177,7 +177,7 @@ export declare const DeviceModelSchema: z.ZodObject<{
     }[];
 }, {
     name: string;
-    type: "other" | "unknown" | "battery" | "charger" | "inverter" | "thermostat" | "vehicle";
+    type: "other" | "unknown" | "meter" | "battery" | "charger" | "inverter" | "thermostat" | "vehicle";
     slug: string;
     manufacturer: {
         name: string;

package/dist/deviceState/index.d.ts

@@ -2,6 +2,7 @@ export * from "./battery";
 export * from "./charger";
 export * from "./common";
 export * from "./inverter";
+export * from "./meter";
 export * from "./thermostat";
 export * from "./vehicle";
 //# sourceMappingURL=index.d.ts.map

package/dist/deviceState/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/deviceState/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/deviceState/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC"}

package/dist/deviceState/index.js

@@ -18,6 +18,7 @@ __exportStar(require("./battery"), exports);
 __exportStar(require("./charger"), exports);
 __exportStar(require("./common"), exports);
 __exportStar(require("./inverter"), exports);
+__exportStar(require("./meter"), exports);
 __exportStar(require("./thermostat"), exports);
 __exportStar(require("./vehicle"), exports);
 //# sourceMappingURL=index.js.map

package/dist/deviceState/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/deviceState/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,4CAA0B;AAC1B,4CAA0B;AAC1B,2CAAyB;AACzB,6CAA2B;AAC3B,+CAA6B;AAC7B,4CAA0B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/deviceState/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,4CAA0B;AAC1B,4CAA0B;AAC1B,2CAAyB;AACzB,6CAA2B;AAC3B,0CAAwB;AACxB,+CAA6B;AAC7B,4CAA0B"}

package/dist/deviceState/meter.d.ts

@@ -0,0 +1,734 @@
+import { z } from "zod";
+/**
+ * Standard AMI (Advanced Metering Infrastructure) data collection intervals
+ */
+export declare const MeterIntervalLengthEnum: z.ZodEnum<["1_MINUTE", "5_MINUTE", "15_MINUTE", "30_MINUTE", "1_HOUR", "24_HOUR"]>;
+export type MeterIntervalLength = z.infer<typeof MeterIntervalLengthEnum>;
+/**
+ * Electrical measurements for a single phase
+ * Supports three-phase, split-phase, and single-phase meter configurations
+ */
+export declare const MeterMeasurementSchema: z.ZodObject<{
+    /**
+     * RMS voltage measurement
+     * @unit volts (V)
+     * @example 240.5
+     */
+    voltage: z.ZodOptional<z.ZodNumber>;
+    /**
+     * RMS current measurement
+     * @unit amperes (A)
+     * @example 15.2
+     */
+    current: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Real power measurement
+     * @unit kilowatts (kW)
+     * @example 3.6
+     */
+    realPower: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Reactive power measurement
+     * @unit kilovars (kVAR)
+     * @example 1.2
+     */
+    reactivePower: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Power factor measurement
+     * @unit ratio (dimensionless)
+     * @example 0.95
+     */
+    powerFactor: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    voltage?: number | undefined;
+    current?: number | undefined;
+    realPower?: number | undefined;
+    reactivePower?: number | undefined;
+    powerFactor?: number | undefined;
+}, {
+    voltage?: number | undefined;
+    current?: number | undefined;
+    realPower?: number | undefined;
+    reactivePower?: number | undefined;
+    powerFactor?: number | undefined;
+}>;
+export type MeterMeasurement = z.infer<typeof MeterMeasurementSchema>;
+/**
+ * Power quality metrics for advanced electrical monitoring
+ */
+export declare const PowerQualityMetricsSchema: z.ZodObject<{
+    /**
+     * Total Harmonic Distortion for voltage
+     * @unit percentage (%)
+     * @example 2.5
+     */
+    voltageTHD: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Total Harmonic Distortion for current
+     * @unit percentage (%)
+     * @example 4.2
+     */
+    currentTHD: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Frequency measurement
+     * @unit hertz (Hz)
+     * @example 59.98
+     */
+    frequency: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Voltage unbalance percentage
+     * @unit percentage (%)
+     * @example 1.2
+     */
+    voltageUnbalance: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Current unbalance percentage
+     * @unit percentage (%)
+     * @example 0.8
+     */
+    currentUnbalance: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Power factor displacement
+     * @unit ratio (dimensionless)
+     * @example 0.92
+     */
+    powerFactorDisplacement: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Total power factor
+     * @unit ratio (dimensionless)
+     * @example 0.89
+     */
+    totalPowerFactor: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    frequency?: number | undefined;
+    voltageTHD?: number | undefined;
+    currentTHD?: number | undefined;
+    voltageUnbalance?: number | undefined;
+    currentUnbalance?: number | undefined;
+    powerFactorDisplacement?: number | undefined;
+    totalPowerFactor?: number | undefined;
+}, {
+    frequency?: number | undefined;
+    voltageTHD?: number | undefined;
+    currentTHD?: number | undefined;
+    voltageUnbalance?: number | undefined;
+    currentUnbalance?: number | undefined;
+    powerFactorDisplacement?: number | undefined;
+    totalPowerFactor?: number | undefined;
+}>;
+export type PowerQualityMetrics = z.infer<typeof PowerQualityMetricsSchema>;
+/**
+ * Energy usage measurements for different types of power
+ */
+export declare const UsageMetricsSchema: z.ZodObject<{
+    /**
+     * Real energy usage over interval
+     * @unit kilowatt-hours (kWh)
+     * @example 5.25
+     */
+    kwhUsage: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Reactive energy usage over interval
+     * @unit kilovar-hours (kVARh)
+     * @example 2.1
+     */
+    kvarhUsage: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Apparent energy usage over interval
+     * @unit kilovolt-ampere-hours (kVAh)
+     * @example 5.7
+     */
+    kvahUsage: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    kwhUsage?: number | undefined;
+    kvarhUsage?: number | undefined;
+    kvahUsage?: number | undefined;
+}, {
+    kwhUsage?: number | undefined;
+    kvarhUsage?: number | undefined;
+    kvahUsage?: number | undefined;
+}>;
+export type UsageMetrics = z.infer<typeof UsageMetricsSchema>;
+/**
+ * Meter interval reading containing usage data and power quality metrics
+ */
+export declare const MeterIntervalReadingSchema: z.ZodObject<{
+    /**
+     * Interval start timestamp
+     * @example "2024-01-01T12:00:00.000Z"
+     */
+    startAt: z.ZodString;
+    /**
+     * Interval end timestamp
+     * @example "2024-01-01T13:00:00.000Z"
+     */
+    endAt: z.ZodString;
+    /**
+     * Energy usage metrics for this interval
+     */
+    usage: z.ZodOptional<z.ZodObject<{
+        /**
+         * Real energy usage over interval
+         * @unit kilowatt-hours (kWh)
+         * @example 5.25
+         */
+        kwhUsage: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Reactive energy usage over interval
+         * @unit kilovar-hours (kVARh)
+         * @example 2.1
+         */
+        kvarhUsage: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Apparent energy usage over interval
+         * @unit kilovolt-ampere-hours (kVAh)
+         * @example 5.7
+         */
+        kvahUsage: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        kwhUsage?: number | undefined;
+        kvarhUsage?: number | undefined;
+        kvahUsage?: number | undefined;
+    }, {
+        kwhUsage?: number | undefined;
+        kvarhUsage?: number | undefined;
+        kvahUsage?: number | undefined;
+    }>>;
+    /**
+     * Cost associated with this interval's usage
+     * @unit currency (e.g., USD)
+     * @example 0.65
+     */
+    cost: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Power quality metrics for this interval
+     */
+    powerQuality: z.ZodOptional<z.ZodObject<{
+        /**
+         * Total Harmonic Distortion for voltage
+         * @unit percentage (%)
+         * @example 2.5
+         */
+        voltageTHD: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Total Harmonic Distortion for current
+         * @unit percentage (%)
+         * @example 4.2
+         */
+        currentTHD: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Frequency measurement
+         * @unit hertz (Hz)
+         * @example 59.98
+         */
+        frequency: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Voltage unbalance percentage
+         * @unit percentage (%)
+         * @example 1.2
+         */
+        voltageUnbalance: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Current unbalance percentage
+         * @unit percentage (%)
+         * @example 0.8
+         */
+        currentUnbalance: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Power factor displacement
+         * @unit ratio (dimensionless)
+         * @example 0.92
+         */
+        powerFactorDisplacement: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Total power factor
+         * @unit ratio (dimensionless)
+         * @example 0.89
+         */
+        totalPowerFactor: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        frequency?: number | undefined;
+        voltageTHD?: number | undefined;
+        currentTHD?: number | undefined;
+        voltageUnbalance?: number | undefined;
+        currentUnbalance?: number | undefined;
+        powerFactorDisplacement?: number | undefined;
+        totalPowerFactor?: number | undefined;
+    }, {
+        frequency?: number | undefined;
+        voltageTHD?: number | undefined;
+        currentTHD?: number | undefined;
+        voltageUnbalance?: number | undefined;
+        currentUnbalance?: number | undefined;
+        powerFactorDisplacement?: number | undefined;
+        totalPowerFactor?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    startAt: string;
+    endAt: string;
+    usage?: {
+        kwhUsage?: number | undefined;
+        kvarhUsage?: number | undefined;
+        kvahUsage?: number | undefined;
+    } | undefined;
+    cost?: number | undefined;
+    powerQuality?: {
+        frequency?: number | undefined;
+        voltageTHD?: number | undefined;
+        currentTHD?: number | undefined;
+        voltageUnbalance?: number | undefined;
+        currentUnbalance?: number | undefined;
+        powerFactorDisplacement?: number | undefined;
+        totalPowerFactor?: number | undefined;
+    } | undefined;
+}, {
+    startAt: string;
+    endAt: string;
+    usage?: {
+        kwhUsage?: number | undefined;
+        kvarhUsage?: number | undefined;
+        kvahUsage?: number | undefined;
+    } | undefined;
+    cost?: number | undefined;
+    powerQuality?: {
+        frequency?: number | undefined;
+        voltageTHD?: number | undefined;
+        currentTHD?: number | undefined;
+        voltageUnbalance?: number | undefined;
+        currentUnbalance?: number | undefined;
+        powerFactorDisplacement?: number | undefined;
+        totalPowerFactor?: number | undefined;
+    } | undefined;
+}>;
+export type MeterIntervalReading = z.infer<typeof MeterIntervalReadingSchema>;
+/**
+ * Meter state supporting various electrical configurations:
+ * - Single-phase: Only phaseA is populated
+ * - Split-phase: phaseA and phaseB are populated (typical North American residential)
+ * - Three-phase: All phases (phaseA, phaseB, phaseC) are populated
+ */
+export declare const MeterStateSchema: z.ZodObject<{
+    /**
+     * Last reading timestamp
+     * @example "2024-01-01T12:00:00.000Z"
+     */
+    lastReadingAt: z.ZodOptional<z.ZodString>;
+    /**
+     * Phase A measurements (always present for any configuration)
+     */
+    phaseA: z.ZodObject<{
+        /**
+         * RMS voltage measurement
+         * @unit volts (V)
+         * @example 240.5
+         */
+        voltage: z.ZodOptional<z.ZodNumber>;
+        /**
+         * RMS current measurement
+         * @unit amperes (A)
+         * @example 15.2
+         */
+        current: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Real power measurement
+         * @unit kilowatts (kW)
+         * @example 3.6
+         */
+        realPower: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Reactive power measurement
+         * @unit kilovars (kVAR)
+         * @example 1.2
+         */
+        reactivePower: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Power factor measurement
+         * @unit ratio (dimensionless)
+         * @example 0.95
+         */
+        powerFactor: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        voltage?: number | undefined;
+        current?: number | undefined;
+        realPower?: number | undefined;
+        reactivePower?: number | undefined;
+        powerFactor?: number | undefined;
+    }, {
+        voltage?: number | undefined;
+        current?: number | undefined;
+        realPower?: number | undefined;
+        reactivePower?: number | undefined;
+        powerFactor?: number | undefined;
+    }>;
+    /**
+     * Phase B measurements (optional - used in split-phase and three-phase configurations)
+     */
+    phaseB: z.ZodOptional<z.ZodObject<{
+        /**
+         * RMS voltage measurement
+         * @unit volts (V)
+         * @example 240.5
+         */
+        voltage: z.ZodOptional<z.ZodNumber>;
+        /**
+         * RMS current measurement
+         * @unit amperes (A)
+         * @example 15.2
+         */
+        current: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Real power measurement
+         * @unit kilowatts (kW)
+         * @example 3.6
+         */
+        realPower: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Reactive power measurement
+         * @unit kilovars (kVAR)
+         * @example 1.2
+         */
+        reactivePower: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Power factor measurement
+         * @unit ratio (dimensionless)
+         * @example 0.95
+         */
+        powerFactor: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        voltage?: number | undefined;
+        current?: number | undefined;
+        realPower?: number | undefined;
+        reactivePower?: number | undefined;
+        powerFactor?: number | undefined;
+    }, {
+        voltage?: number | undefined;
+        current?: number | undefined;
+        realPower?: number | undefined;
+        reactivePower?: number | undefined;
+        powerFactor?: number | undefined;
+    }>>;
+    /**
+     * Phase C measurements (optional - used in three-phase configurations only)
+     */
+    phaseC: z.ZodOptional<z.ZodObject<{
+        /**
+         * RMS voltage measurement
+         * @unit volts (V)
+         * @example 240.5
+         */
+        voltage: z.ZodOptional<z.ZodNumber>;
+        /**
+         * RMS current measurement
+         * @unit amperes (A)
+         * @example 15.2
+         */
+        current: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Real power measurement
+         * @unit kilowatts (kW)
+         * @example 3.6
+         */
+        realPower: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Reactive power measurement
+         * @unit kilovars (kVAR)
+         * @example 1.2
+         */
+        reactivePower: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Power factor measurement
+         * @unit ratio (dimensionless)
+         * @example 0.95
+         */
+        powerFactor: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        voltage?: number | undefined;
+        current?: number | undefined;
+        realPower?: number | undefined;
+        reactivePower?: number | undefined;
+        powerFactor?: number | undefined;
+    }, {
+        voltage?: number | undefined;
+        current?: number | undefined;
+        realPower?: number | undefined;
+        reactivePower?: number | undefined;
+        powerFactor?: number | undefined;
+    }>>;
+    /**
+     * Latest interval reading with usage data and power quality metrics
+     */
+    lastIntervalReading: z.ZodOptional<z.ZodObject<{
+        /**
+         * Interval start timestamp
+         * @example "2024-01-01T12:00:00.000Z"
+         */
+        startAt: z.ZodString;
+        /**
+         * Interval end timestamp
+         * @example "2024-01-01T13:00:00.000Z"
+         */
+        endAt: z.ZodString;
+        /**
+         * Energy usage metrics for this interval
+         */
+        usage: z.ZodOptional<z.ZodObject<{
+            /**
+             * Real energy usage over interval
+             * @unit kilowatt-hours (kWh)
+             * @example 5.25
+             */
+            kwhUsage: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Reactive energy usage over interval
+             * @unit kilovar-hours (kVARh)
+             * @example 2.1
+             */
+            kvarhUsage: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Apparent energy usage over interval
+             * @unit kilovolt-ampere-hours (kVAh)
+             * @example 5.7
+             */
+            kvahUsage: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            kwhUsage?: number | undefined;
+            kvarhUsage?: number | undefined;
+            kvahUsage?: number | undefined;
+        }, {
+            kwhUsage?: number | undefined;
+            kvarhUsage?: number | undefined;
+            kvahUsage?: number | undefined;
+        }>>;
+        /**
+         * Cost associated with this interval's usage
+         * @unit currency (e.g., USD)
+         * @example 0.65
+         */
+        cost: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Power quality metrics for this interval
+         */
+        powerQuality: z.ZodOptional<z.ZodObject<{
+            /**
+             * Total Harmonic Distortion for voltage
+             * @unit percentage (%)
+             * @example 2.5
+             */
+            voltageTHD: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Total Harmonic Distortion for current
+             * @unit percentage (%)
+             * @example 4.2
+             */
+            currentTHD: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Frequency measurement
+             * @unit hertz (Hz)
+             * @example 59.98
+             */
+            frequency: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Voltage unbalance percentage
+             * @unit percentage (%)
+             * @example 1.2
+             */
+            voltageUnbalance: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Current unbalance percentage
+             * @unit percentage (%)
+             * @example 0.8
+             */
+            currentUnbalance: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Power factor displacement
+             * @unit ratio (dimensionless)
+             * @example 0.92
+             */
+            powerFactorDisplacement: z.ZodOptional<z.ZodNumber>;
+            /**
+             * Total power factor
+             * @unit ratio (dimensionless)
+             * @example 0.89
+             */
+            totalPowerFactor: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            frequency?: number | undefined;
+            voltageTHD?: number | undefined;
+            currentTHD?: number | undefined;
+            voltageUnbalance?: number | undefined;
+            currentUnbalance?: number | undefined;
+            powerFactorDisplacement?: number | undefined;
+            totalPowerFactor?: number | undefined;
+        }, {
+            frequency?: number | undefined;
+            voltageTHD?: number | undefined;
+            currentTHD?: number | undefined;
+            voltageUnbalance?: number | undefined;
+            currentUnbalance?: number | undefined;
+            powerFactorDisplacement?: number | undefined;
+            totalPowerFactor?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        startAt: string;
+        endAt: string;
+        usage?: {
+            kwhUsage?: number | undefined;
+            kvarhUsage?: number | undefined;
+            kvahUsage?: number | undefined;
+        } | undefined;
+        cost?: number | undefined;
+        powerQuality?: {
+            frequency?: number | undefined;
+            voltageTHD?: number | undefined;
+            currentTHD?: number | undefined;
+            voltageUnbalance?: number | undefined;
+            currentUnbalance?: number | undefined;
+            powerFactorDisplacement?: number | undefined;
+            totalPowerFactor?: number | undefined;
+        } | undefined;
+    }, {
+        startAt: string;
+        endAt: string;
+        usage?: {
+            kwhUsage?: number | undefined;
+            kvarhUsage?: number | undefined;
+            kvahUsage?: number | undefined;
+        } | undefined;
+        cost?: number | undefined;
+        powerQuality?: {
+            frequency?: number | undefined;
+            voltageTHD?: number | undefined;
+            currentTHD?: number | undefined;
+            voltageUnbalance?: number | undefined;
+            currentUnbalance?: number | undefined;
+            powerFactorDisplacement?: number | undefined;
+            totalPowerFactor?: number | undefined;
+        } | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    phaseA: {
+        voltage?: number | undefined;
+        current?: number | undefined;
+        realPower?: number | undefined;
+        reactivePower?: number | undefined;
+        powerFactor?: number | undefined;
+    };
+    lastReadingAt?: string | undefined;
+    phaseB?: {
+        voltage?: number | undefined;
+        current?: number | undefined;
+        realPower?: number | undefined;
+        reactivePower?: number | undefined;
+        powerFactor?: number | undefined;
+    } | undefined;
+    phaseC?: {
+        voltage?: number | undefined;
+        current?: number | undefined;
+        realPower?: number | undefined;
+        reactivePower?: number | undefined;
+        powerFactor?: number | undefined;
+    } | undefined;
+    lastIntervalReading?: {
+        startAt: string;
+        endAt: string;
+        usage?: {
+            kwhUsage?: number | undefined;
+            kvarhUsage?: number | undefined;
+            kvahUsage?: number | undefined;
+        } | undefined;
+        cost?: number | undefined;
+        powerQuality?: {
+            frequency?: number | undefined;
+            voltageTHD?: number | undefined;
+            currentTHD?: number | undefined;
+            voltageUnbalance?: number | undefined;
+            currentUnbalance?: number | undefined;
+            powerFactorDisplacement?: number | undefined;
+            totalPowerFactor?: number | undefined;
+        } | undefined;
+    } | undefined;
+}, {
+    phaseA: {
+        voltage?: number | undefined;
+        current?: number | undefined;
+        realPower?: number | undefined;
+        reactivePower?: number | undefined;
+        powerFactor?: number | undefined;
+    };
+    lastReadingAt?: string | undefined;
+    phaseB?: {
+        voltage?: number | undefined;
+        current?: number | undefined;
+        realPower?: number | undefined;
+        reactivePower?: number | undefined;
+        powerFactor?: number | undefined;
+    } | undefined;
+    phaseC?: {
+        voltage?: number | undefined;
+        current?: number | undefined;
+        realPower?: number | undefined;
+        reactivePower?: number | undefined;
+        powerFactor?: number | undefined;
+    } | undefined;
+    lastIntervalReading?: {
+        startAt: string;
+        endAt: string;
+        usage?: {
+            kwhUsage?: number | undefined;
+            kvarhUsage?: number | undefined;
+            kvahUsage?: number | undefined;
+        } | undefined;
+        cost?: number | undefined;
+        powerQuality?: {
+            frequency?: number | undefined;
+            voltageTHD?: number | undefined;
+            currentTHD?: number | undefined;
+            voltageUnbalance?: number | undefined;
+            currentUnbalance?: number | undefined;
+            powerFactorDisplacement?: number | undefined;
+            totalPowerFactor?: number | undefined;
+        } | undefined;
+    } | undefined;
+}>;
+export type MeterState = z.infer<typeof MeterStateSchema>;
+export declare const MeterStaticStateSchema: z.ZodObject<{
+    /**
+     * The owner of the meter
+     * @example "john.doe@utility.com"
+     */
+    owner: z.ZodString;
+    /**
+     * The unique meter identifier
+     * @example "METER_12345"
+     */
+    meterId: z.ZodString;
+    /**
+     * The meter manufacturer
+     * @example "Aclara"
+     */
+    manufacturer: z.ZodString;
+    /**
+     * The meter's serial number
+     * @example "SN123456789"
+     */
+    serialNumber: z.ZodString;
+    /**
+     * The meter's data collection interval length
+     * @example "15_MINUTE"
+     */
+    intervalLength: z.ZodEnum<["1_MINUTE", "5_MINUTE", "15_MINUTE", "30_MINUTE", "1_HOUR", "24_HOUR"]>;
+}, "strip", z.ZodTypeAny, {
+    manufacturer: string;
+    owner: string;
+    meterId: string;
+    serialNumber: string;
+    intervalLength: "1_MINUTE" | "5_MINUTE" | "15_MINUTE" | "30_MINUTE" | "1_HOUR" | "24_HOUR";
+}, {
+    manufacturer: string;
+    owner: string;
+    meterId: string;
+    serialNumber: string;
+    intervalLength: "1_MINUTE" | "5_MINUTE" | "15_MINUTE" | "30_MINUTE" | "1_HOUR" | "24_HOUR";
+}>;
+export type MeterStaticState = z.infer<typeof MeterStaticStateSchema>;
+//# sourceMappingURL=meter.d.ts.map

package/dist/deviceState/meter.d.ts.map

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

package/dist/deviceState/meter.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeterStaticStateSchema = exports.MeterStateSchema = exports.MeterIntervalReadingSchema = exports.UsageMetricsSchema = exports.PowerQualityMetricsSchema = exports.MeterMeasurementSchema = exports.MeterIntervalLengthEnum = void 0;
+const zod_1 = require("zod");
+/**
+ * Standard AMI (Advanced Metering Infrastructure) data collection intervals
+ */
+exports.MeterIntervalLengthEnum = zod_1.z.enum(["1_MINUTE", "5_MINUTE", "15_MINUTE", "30_MINUTE", "1_HOUR", "24_HOUR"]);
+/**
+ * Electrical measurements for a single phase
+ * Supports three-phase, split-phase, and single-phase meter configurations
+ */
+exports.MeterMeasurementSchema = zod_1.z.object({
+    /**
+     * RMS voltage measurement
+     * @unit volts (V)
+     * @example 240.5
+     */
+    voltage: zod_1.z.number().optional().describe("RMS voltage in volts (V)"),
+    /**
+     * RMS current measurement
+     * @unit amperes (A)
+     * @example 15.2
+     */
+    current: zod_1.z.number().optional().describe("RMS current in amperes (A)"),
+    /**
+     * Real power measurement
+     * @unit kilowatts (kW)
+     * @example 3.6
+     */
+    realPower: zod_1.z.number().optional().describe("Real power in kilowatts (kW)"),
+    /**
+     * Reactive power measurement
+     * @unit kilovars (kVAR)
+     * @example 1.2
+     */
+    reactivePower: zod_1.z.number().optional().describe("Reactive power in kilovars (kVAR)"),
+    /**
+     * Power factor measurement
+     * @unit ratio (dimensionless)
+     * @example 0.95
+     */
+    powerFactor: zod_1.z.number().optional().describe("Power factor (ratio)"),
+});
+/**
+ * Power quality metrics for advanced electrical monitoring
+ */
+exports.PowerQualityMetricsSchema = zod_1.z.object({
+    /**
+     * Total Harmonic Distortion for voltage
+     * @unit percentage (%)
+     * @example 2.5
+     */
+    voltageTHD: zod_1.z.number().optional().describe("Total Harmonic Distortion for voltage (%)"),
+    /**
+     * Total Harmonic Distortion for current
+     * @unit percentage (%)
+     * @example 4.2
+     */
+    currentTHD: zod_1.z.number().optional().describe("Total Harmonic Distortion for current (%)"),
+    /**
+     * Frequency measurement
+     * @unit hertz (Hz)
+     * @example 59.98
+     */
+    frequency: zod_1.z.number().optional().describe("Electrical frequency in hertz (Hz)"),
+    /**
+     * Voltage unbalance percentage
+     * @unit percentage (%)
+     * @example 1.2
+     */
+    voltageUnbalance: zod_1.z.number().optional().describe("Voltage unbalance percentage (%)"),
+    /**
+     * Current unbalance percentage
+     * @unit percentage (%)
+     * @example 0.8
+     */
+    currentUnbalance: zod_1.z.number().optional().describe("Current unbalance percentage (%)"),
+    /**
+     * Power factor displacement
+     * @unit ratio (dimensionless)
+     * @example 0.92
+     */
+    powerFactorDisplacement: zod_1.z.number().optional().describe("Power factor displacement (ratio)"),
+    /**
+     * Total power factor
+     * @unit ratio (dimensionless)
+     * @example 0.89
+     */
+    totalPowerFactor: zod_1.z.number().optional().describe("Total power factor including harmonics (ratio)"),
+});
+/**
+ * Energy usage measurements for different types of power
+ */
+exports.UsageMetricsSchema = zod_1.z.object({
+    /**
+     * Real energy usage over interval
+     * @unit kilowatt-hours (kWh)
+     * @example 5.25
+     */
+    kwhUsage: zod_1.z.number().optional().describe("Real energy usage in kilowatt-hours (kWh)"),
+    /**
+     * Reactive energy usage over interval
+     * @unit kilovar-hours (kVARh)
+     * @example 2.1
+     */
+    kvarhUsage: zod_1.z.number().optional().describe("Reactive energy usage in kilovar-hours (kVARh)"),
+    /**
+     * Apparent energy usage over interval
+     * @unit kilovolt-ampere-hours (kVAh)
+     * @example 5.7
+     */
+    kvahUsage: zod_1.z.number().optional().describe("Apparent energy usage in kilovolt-ampere-hours (kVAh)"),
+});
+/**
+ * Meter interval reading containing usage data and power quality metrics
+ */
+exports.MeterIntervalReadingSchema = zod_1.z.object({
+    /**
+     * Interval start timestamp
+     * @example "2024-01-01T12:00:00.000Z"
+     */
+    startAt: zod_1.z.string().datetime().describe("Interval start timestamp"),
+    /**
+     * Interval end timestamp
+     * @example "2024-01-01T13:00:00.000Z"
+     */
+    endAt: zod_1.z.string().datetime().describe("Interval end timestamp"),
+    /**
+     * Energy usage metrics for this interval
+     */
+    usage: exports.UsageMetricsSchema.optional().describe("Energy usage metrics for this interval"),
+    /**
+     * Cost associated with this interval's usage
+     * @unit currency (e.g., USD)
+     * @example 0.65
+     */
+    cost: zod_1.z.number().optional().describe("Cost associated with this interval's usage"),
+    /**
+     * Power quality metrics for this interval
+     */
+    powerQuality: exports.PowerQualityMetricsSchema.optional().describe("Power quality metrics for this interval"),
+});
+/**
+ * Meter state supporting various electrical configurations:
+ * - Single-phase: Only phaseA is populated
+ * - Split-phase: phaseA and phaseB are populated (typical North American residential)
+ * - Three-phase: All phases (phaseA, phaseB, phaseC) are populated
+ */
+exports.MeterStateSchema = zod_1.z.object({
+    /**
+     * Last reading timestamp
+     * @example "2024-01-01T12:00:00.000Z"
+     */
+    lastReadingAt: zod_1.z.string().datetime().optional().describe("Last meter reading timestamp"),
+    /**
+     * Phase A measurements (always present for any configuration)
+     */
+    phaseA: exports.MeterMeasurementSchema.describe("Phase A electrical measurements"),
+    /**
+     * Phase B measurements (optional - used in split-phase and three-phase configurations)
+     */
+    phaseB: exports.MeterMeasurementSchema.optional().describe("Phase B electrical measurements"),
+    /**
+     * Phase C measurements (optional - used in three-phase configurations only)
+     */
+    phaseC: exports.MeterMeasurementSchema.optional().describe("Phase C electrical measurements"),
+    /**
+     * Latest interval reading with usage data and power quality metrics
+     */
+    lastIntervalReading: exports.MeterIntervalReadingSchema.optional().describe("Latest interval reading"),
+});
+exports.MeterStaticStateSchema = zod_1.z.object({
+    /**
+     * The owner of the meter
+     * @example "john.doe@utility.com"
+     */
+    owner: zod_1.z.string().describe("The owner of the meter"),
+    /**
+     * The unique meter identifier
+     * @example "METER_12345"
+     */
+    meterId: zod_1.z.string().describe("The unique meter identifier"),
+    /**
+     * The meter manufacturer
+     * @example "Aclara"
+     */
+    manufacturer: zod_1.z.string().describe("The meter manufacturer"),
+    /**
+     * The meter's serial number
+     * @example "SN123456789"
+     */
+    serialNumber: zod_1.z.string().describe("The meter's serial number"),
+    /**
+     * The meter's data collection interval length
+     * @example "15_MINUTE"
+     */
+    intervalLength: exports.MeterIntervalLengthEnum.describe("The meter's data collection interval length"),
+});
+//# sourceMappingURL=meter.js.map

package/dist/deviceState/meter.js.map

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

package/dist/deviceType/entities.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
-export declare const DeviceTypes: readonly ["battery", "charger", "inverter", "thermostat", "vehicle", "other", "unknown"];
+export declare const DeviceTypes: readonly ["battery", "charger", "inverter", "meter", "thermostat", "vehicle", "other", "unknown"];
 export type DeviceType = (typeof DeviceTypes)[number];
-export declare const DeviceTypeEnum: z.ZodEnum<["battery", "charger", "inverter", "thermostat", "vehicle", "other", "unknown"]>;
+export declare const DeviceTypeEnum: z.ZodEnum<["battery", "charger", "inverter", "meter", "thermostat", "vehicle", "other", "unknown"]>;
 export declare const DeviceTypeLabelMap: Record<DeviceType, string>;
 //# sourceMappingURL=entities.d.ts.map

package/dist/deviceType/entities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entities.d.ts","sourceRoot":"","sources":["../../src/deviceType/entities.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,WAAW,0FAA2F,CAAC;AACpH,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AACtD,eAAO,MAAM,cAAc,4FAAsB,CAAC;AAElD,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAQzD,CAAC"}
+{"version":3,"file":"entities.d.ts","sourceRoot":"","sources":["../../src/deviceType/entities.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,WAAW,mGASd,CAAC;AACX,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AACtD,eAAO,MAAM,cAAc,qGAAsB,CAAC;AAElD,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CASzD,CAAC"}

package/dist/deviceType/entities.js

@@ -2,12 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeviceTypeLabelMap = exports.DeviceTypeEnum = exports.DeviceTypes = void 0;
 const zod_1 = require("zod");
-exports.DeviceTypes = ["battery", "charger", "inverter", "thermostat", "vehicle", "other", "unknown"];
+exports.DeviceTypes = [
+    "battery",
+    "charger",
+    "inverter",
+    "meter",
+    "thermostat",
+    "vehicle",
+    "other",
+    "unknown",
+];
 exports.DeviceTypeEnum = zod_1.z.enum(exports.DeviceTypes);
 exports.DeviceTypeLabelMap = {
     battery: "Battery",
     charger: "Charger",
     inverter: "Inverter",
+    meter: "Meter",
     thermostat: "Thermostat",
     vehicle: "Vehicle",
     other: "Other",

package/dist/deviceType/entities.js.map

@@ -1 +1 @@
-{"version":3,"file":"entities.js","sourceRoot":"","sources":["../../src/deviceType/entities.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAEX,QAAA,WAAW,GAAG,CAAC,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,CAAU,CAAC;AAEvG,QAAA,cAAc,GAAG,OAAC,CAAC,IAAI,CAAC,mBAAW,CAAC,CAAC;AAErC,QAAA,kBAAkB,GAA+B;IAC5D,OAAO,EAAE,SAAS;IAClB,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,UAAU;IACpB,UAAU,EAAE,YAAY;IACxB,OAAO,EAAE,SAAS;IAClB,KAAK,EAAE,OAAO;IACd,OAAO,EAAE,SAAS;CACnB,CAAC"}
+{"version":3,"file":"entities.js","sourceRoot":"","sources":["../../src/deviceType/entities.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAEX,QAAA,WAAW,GAAG;IACzB,SAAS;IACT,SAAS;IACT,UAAU;IACV,OAAO;IACP,YAAY;IACZ,SAAS;IACT,OAAO;IACP,SAAS;CACD,CAAC;AAEE,QAAA,cAAc,GAAG,OAAC,CAAC,IAAI,CAAC,mBAAW,CAAC,CAAC;AAErC,QAAA,kBAAkB,GAA+B;IAC5D,OAAO,EAAE,SAAS;IAClB,OAAO,EAAE,SAAS;IAClB,QAAQ,EAAE,UAAU;IACpB,KAAK,EAAE,OAAO;IACd,UAAU,EAAE,YAAY;IACxB,OAAO,EAAE,SAAS;IAClB,KAAK,EAAE,OAAO;IACd,OAAO,EAAE,SAAS;CACnB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@texturehq/device",
-  "version": "1.12.0",
+  "version": "1.13.0",
   "author": "Will Laeri <will@texture.energy>",
   "description": "A type-safe client for validating device data",
   "main": "dist/index.js",
@@ -42,5 +42,9 @@
     "@texturehq/logger": {
       "optional": true
     }
+  },
+  "resolutions": {
+    "form-data": "^4.0.4",
+    "axios": "^1.12.0"
   }
 }