@texturehq/device 1.12.0 → 1.14.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (19) hide show
  1. package/dist/deviceModel/entities.d.ts +13 -3
  2. package/dist/deviceModel/entities.d.ts.map +1 -1
  3. package/dist/deviceState/index.d.ts +1 -0
  4. package/dist/deviceState/index.d.ts.map +1 -1
  5. package/dist/deviceState/index.js +1 -0
  6. package/dist/deviceState/index.js.map +1 -1
  7. package/dist/deviceState/meter.d.ts +734 -0
  8. package/dist/deviceState/meter.d.ts.map +1 -0
  9. package/dist/deviceState/meter.js +200 -0
  10. package/dist/deviceState/meter.js.map +1 -0
  11. package/dist/deviceType/entities.d.ts +2 -2
  12. package/dist/deviceType/entities.d.ts.map +1 -1
  13. package/dist/deviceType/entities.js +11 -1
  14. package/dist/deviceType/entities.js.map +1 -1
  15. package/dist/manufacturer/entities.d.ts +15 -0
  16. package/dist/manufacturer/entities.d.ts.map +1 -1
  17. package/dist/manufacturer/entities.js +11 -0
  18. package/dist/manufacturer/entities.js.map +1 -1
  19. package/package.json +7 -1
package/dist/deviceModel/entities.d.ts CHANGED
@@ -27,14 +27,16 @@ export declare const DeviceModelSchema: z.ZodObject<{
27
27
  * The type of the device.
28
28
  * @example "inverter"
29
29
  */
30
- type: z.ZodEnum<["battery", "charger", "inverter", "thermostat", "vehicle", "other", "unknown"]>;
30
+ type: z.ZodEnum<["battery", "charger", "inverter", "meter", "thermostat", "vehicle", "other", "unknown"]>;
31
31
  /**
32
32
  * The manufacturer of the device.
33
33
  */
34
34
  manufacturer: z.ZodObject<{
35
+ id: z.ZodOptional<z.ZodString>;
35
36
  slug: z.ZodString;
36
37
  name: z.ZodString;
37
38
  supportLevel: z.ZodEnum<["planned", "development", "uat", "production", "blocked"]>;
39
+ supportsGridServices: z.ZodOptional<z.ZodBoolean>;
38
40
  logo: z.ZodObject<{
39
41
  url: z.ZodString;
40
42
  alt: z.ZodString;
@@ -105,6 +107,8 @@ export declare const DeviceModelSchema: z.ZodObject<{
105
107
  url: string;
106
108
  alt: string;
107
109
  };
110
+ id?: string | undefined;
111
+ supportsGridServices?: boolean | undefined;
108
112
  }, {
109
113
  name: string;
110
114
  slug: string;
@@ -127,6 +131,8 @@ export declare const DeviceModelSchema: z.ZodObject<{
127
131
  url: string;
128
132
  alt: string;
129
133
  };
134
+ id?: string | undefined;
135
+ supportsGridServices?: boolean | undefined;
130
136
  }>;
131
137
  /**
132
138
  * The commands available for the device.
@@ -146,7 +152,7 @@ export declare const DeviceModelSchema: z.ZodObject<{
146
152
  }>, "many">;
147
153
  }, "strip", z.ZodTypeAny, {
148
154
  name: string;
149
- type: "other" | "unknown" | "battery" | "charger" | "inverter" | "thermostat" | "vehicle";
155
+ type: "other" | "unknown" | "meter" | "battery" | "charger" | "inverter" | "thermostat" | "vehicle";
150
156
  slug: string;
151
157
  manufacturer: {
152
158
  name: string;
@@ -170,6 +176,8 @@ export declare const DeviceModelSchema: z.ZodObject<{
170
176
  url: string;
171
177
  alt: string;
172
178
  };
179
+ id?: string | undefined;
180
+ supportsGridServices?: boolean | undefined;
173
181
  };
174
182
  available_commands: {
175
183
  slug: string;
@@ -177,7 +185,7 @@ export declare const DeviceModelSchema: z.ZodObject<{
177
185
  }[];
178
186
  }, {
179
187
  name: string;
180
- type: "other" | "unknown" | "battery" | "charger" | "inverter" | "thermostat" | "vehicle";
188
+ type: "other" | "unknown" | "meter" | "battery" | "charger" | "inverter" | "thermostat" | "vehicle";
181
189
  slug: string;
182
190
  manufacturer: {
183
191
  name: string;
@@ -201,6 +209,8 @@ export declare const DeviceModelSchema: z.ZodObject<{
201
209
  url: string;
202
210
  alt: string;
203
211
  };
212
+ id?: string | undefined;
213
+ supportsGridServices?: boolean | undefined;
204
214
  };
205
215
  available_commands: {
206
216
  slug: string;
package/dist/deviceModel/entities.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"entities.d.ts","sourceRoot":"","sources":["../../src/deviceModel/entities.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,sBAAsB;IACjC;;OAEG;;;;;;;;;EAGH,CAAC;AAEH,eAAO,MAAM,iBAAiB;IAC5B;;;OAGG;;IAEH;;;OAGG;;IAEH;;;OAGG;;IAEH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEH;;OAEG;;QA7BH;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6BH,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}
1
+ {"version":3,"file":"entities.d.ts","sourceRoot":"","sources":["../../src/deviceModel/entities.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,sBAAsB;IACjC;;OAEG;;;;;;;;;EAGH,CAAC;AAEH,eAAO,MAAM,iBAAiB;IAC5B;;;OAGG;;IAEH;;;OAGG;;IAEH;;;OAGG;;IAEH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEH;;OAEG;;QA7BH;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6BH,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}
package/dist/deviceState/index.d.ts CHANGED
@@ -2,6 +2,7 @@ export * from "./battery";
2
2
  export * from "./charger";
3
3
  export * from "./common";
4
4
  export * from "./inverter";
5
+ export * from "./meter";
5
6
  export * from "./thermostat";
6
7
  export * from "./vehicle";
7
8
  //# sourceMappingURL=index.d.ts.map
package/dist/deviceState/index.d.ts.map CHANGED
@@ -1 +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"}
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,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC"}
package/dist/deviceState/index.js CHANGED
@@ -18,6 +18,7 @@ __exportStar(require("./battery"), exports);
18
18
  __exportStar(require("./charger"), exports);
19
19
  __exportStar(require("./common"), exports);
20
20
  __exportStar(require("./inverter"), exports);
21
+ __exportStar(require("./meter"), exports);
21
22
  __exportStar(require("./thermostat"), exports);
22
23
  __exportStar(require("./vehicle"), exports);
23
24
  //# sourceMappingURL=index.js.map
package/dist/deviceState/index.js.map CHANGED
@@ -1 +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"}
1
+ {"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 ADDED
@@ -0,0 +1,734 @@
1
+ import { z } from "zod";
2
+ /**
3
+ * Standard AMI (Advanced Metering Infrastructure) data collection intervals
4
+ */
5
+ export declare const MeterIntervalLengthEnum: z.ZodEnum<["1_MINUTE", "5_MINUTE", "15_MINUTE", "30_MINUTE", "1_HOUR", "24_HOUR"]>;
6
+ export type MeterIntervalLength = z.infer<typeof MeterIntervalLengthEnum>;
7
+ /**
8
+ * Electrical measurements for a single phase
9
+ * Supports three-phase, split-phase, and single-phase meter configurations
10
+ */
11
+ export declare const MeterMeasurementSchema: z.ZodObject<{
12
+ /**
13
+ * RMS voltage measurement
14
+ * @unit volts (V)
15
+ * @example 240.5
16
+ */
17
+ voltage: z.ZodOptional<z.ZodNumber>;
18
+ /**
19
+ * RMS current measurement
20
+ * @unit amperes (A)
21
+ * @example 15.2
22
+ */
23
+ current: z.ZodOptional<z.ZodNumber>;
24
+ /**
25
+ * Real power measurement
26
+ * @unit kilowatts (kW)
27
+ * @example 3.6
28
+ */
29
+ realPower: z.ZodOptional<z.ZodNumber>;
30
+ /**
31
+ * Reactive power measurement
32
+ * @unit kilovars (kVAR)
33
+ * @example 1.2
34
+ */
35
+ reactivePower: z.ZodOptional<z.ZodNumber>;
36
+ /**
37
+ * Power factor measurement
38
+ * @unit ratio (dimensionless)
39
+ * @example 0.95
40
+ */
41
+ powerFactor: z.ZodOptional<z.ZodNumber>;
42
+ }, "strip", z.ZodTypeAny, {
43
+ voltage?: number | undefined;
44
+ current?: number | undefined;
45
+ realPower?: number | undefined;
46
+ reactivePower?: number | undefined;
47
+ powerFactor?: number | undefined;
48
+ }, {
49
+ voltage?: number | undefined;
50
+ current?: number | undefined;
51
+ realPower?: number | undefined;
52
+ reactivePower?: number | undefined;
53
+ powerFactor?: number | undefined;
54
+ }>;
55
+ export type MeterMeasurement = z.infer<typeof MeterMeasurementSchema>;
56
+ /**
57
+ * Power quality metrics for advanced electrical monitoring
58
+ */
59
+ export declare const PowerQualityMetricsSchema: z.ZodObject<{
60
+ /**
61
+ * Total Harmonic Distortion for voltage
62
+ * @unit percentage (%)
63
+ * @example 2.5
64
+ */
65
+ voltageTHD: z.ZodOptional<z.ZodNumber>;
66
+ /**
67
+ * Total Harmonic Distortion for current
68
+ * @unit percentage (%)
69
+ * @example 4.2
70
+ */
71
+ currentTHD: z.ZodOptional<z.ZodNumber>;
72
+ /**
73
+ * Frequency measurement
74
+ * @unit hertz (Hz)
75
+ * @example 59.98
76
+ */
77
+ frequency: z.ZodOptional<z.ZodNumber>;
78
+ /**
79
+ * Voltage unbalance percentage
80
+ * @unit percentage (%)
81
+ * @example 1.2
82
+ */
83
+ voltageUnbalance: z.ZodOptional<z.ZodNumber>;
84
+ /**
85
+ * Current unbalance percentage
86
+ * @unit percentage (%)
87
+ * @example 0.8
88
+ */
89
+ currentUnbalance: z.ZodOptional<z.ZodNumber>;
90
+ /**
91
+ * Power factor displacement
92
+ * @unit ratio (dimensionless)
93
+ * @example 0.92
94
+ */
95
+ powerFactorDisplacement: z.ZodOptional<z.ZodNumber>;
96
+ /**
97
+ * Total power factor
98
+ * @unit ratio (dimensionless)
99
+ * @example 0.89
100
+ */
101
+ totalPowerFactor: z.ZodOptional<z.ZodNumber>;
102
+ }, "strip", z.ZodTypeAny, {
103
+ frequency?: number | undefined;
104
+ voltageTHD?: number | undefined;
105
+ currentTHD?: number | undefined;
106
+ voltageUnbalance?: number | undefined;
107
+ currentUnbalance?: number | undefined;
108
+ powerFactorDisplacement?: number | undefined;
109
+ totalPowerFactor?: number | undefined;
110
+ }, {
111
+ frequency?: number | undefined;
112
+ voltageTHD?: number | undefined;
113
+ currentTHD?: number | undefined;
114
+ voltageUnbalance?: number | undefined;
115
+ currentUnbalance?: number | undefined;
116
+ powerFactorDisplacement?: number | undefined;
117
+ totalPowerFactor?: number | undefined;
118
+ }>;
119
+ export type PowerQualityMetrics = z.infer<typeof PowerQualityMetricsSchema>;
120
+ /**
121
+ * Energy usage measurements for different types of power
122
+ */
123
+ export declare const UsageMetricsSchema: z.ZodObject<{
124
+ /**
125
+ * Real energy usage over interval
126
+ * @unit kilowatt-hours (kWh)
127
+ * @example 5.25
128
+ */
129
+ kwhUsage: z.ZodOptional<z.ZodNumber>;
130
+ /**
131
+ * Reactive energy usage over interval
132
+ * @unit kilovar-hours (kVARh)
133
+ * @example 2.1
134
+ */
135
+ kvarhUsage: z.ZodOptional<z.ZodNumber>;
136
+ /**
137
+ * Apparent energy usage over interval
138
+ * @unit kilovolt-ampere-hours (kVAh)
139
+ * @example 5.7
140
+ */
141
+ kvahUsage: z.ZodOptional<z.ZodNumber>;
142
+ }, "strip", z.ZodTypeAny, {
143
+ kwhUsage?: number | undefined;
144
+ kvarhUsage?: number | undefined;
145
+ kvahUsage?: number | undefined;
146
+ }, {
147
+ kwhUsage?: number | undefined;
148
+ kvarhUsage?: number | undefined;
149
+ kvahUsage?: number | undefined;
150
+ }>;
151
+ export type UsageMetrics = z.infer<typeof UsageMetricsSchema>;
152
+ /**
153
+ * Meter interval reading containing usage data and power quality metrics
154
+ */
155
+ export declare const MeterIntervalReadingSchema: z.ZodObject<{
156
+ /**
157
+ * Interval start timestamp
158
+ * @example "2024-01-01T12:00:00.000Z"
159
+ */
160
+ startAt: z.ZodString;
161
+ /**
162
+ * Interval end timestamp
163
+ * @example "2024-01-01T13:00:00.000Z"
164
+ */
165
+ endAt: z.ZodString;
166
+ /**
167
+ * Energy usage metrics for this interval
168
+ */
169
+ usage: z.ZodOptional<z.ZodObject<{
170
+ /**
171
+ * Real energy usage over interval
172
+ * @unit kilowatt-hours (kWh)
173
+ * @example 5.25
174
+ */
175
+ kwhUsage: z.ZodOptional<z.ZodNumber>;
176
+ /**
177
+ * Reactive energy usage over interval
178
+ * @unit kilovar-hours (kVARh)
179
+ * @example 2.1
180
+ */
181
+ kvarhUsage: z.ZodOptional<z.ZodNumber>;
182
+ /**
183
+ * Apparent energy usage over interval
184
+ * @unit kilovolt-ampere-hours (kVAh)
185
+ * @example 5.7
186
+ */
187
+ kvahUsage: z.ZodOptional<z.ZodNumber>;
188
+ }, "strip", z.ZodTypeAny, {
189
+ kwhUsage?: number | undefined;
190
+ kvarhUsage?: number | undefined;
191
+ kvahUsage?: number | undefined;
192
+ }, {
193
+ kwhUsage?: number | undefined;
194
+ kvarhUsage?: number | undefined;
195
+ kvahUsage?: number | undefined;
196
+ }>>;
197
+ /**
198
+ * Cost associated with this interval's usage
199
+ * @unit currency (e.g., USD)
200
+ * @example 0.65
201
+ */
202
+ cost: z.ZodOptional<z.ZodNumber>;
203
+ /**
204
+ * Power quality metrics for this interval
205
+ */
206
+ powerQuality: z.ZodOptional<z.ZodObject<{
207
+ /**
208
+ * Total Harmonic Distortion for voltage
209
+ * @unit percentage (%)
210
+ * @example 2.5
211
+ */
212
+ voltageTHD: z.ZodOptional<z.ZodNumber>;
213
+ /**
214
+ * Total Harmonic Distortion for current
215
+ * @unit percentage (%)
216
+ * @example 4.2
217
+ */
218
+ currentTHD: z.ZodOptional<z.ZodNumber>;
219
+ /**
220
+ * Frequency measurement
221
+ * @unit hertz (Hz)
222
+ * @example 59.98
223
+ */
224
+ frequency: z.ZodOptional<z.ZodNumber>;
225
+ /**
226
+ * Voltage unbalance percentage
227
+ * @unit percentage (%)
228
+ * @example 1.2
229
+ */
230
+ voltageUnbalance: z.ZodOptional<z.ZodNumber>;
231
+ /**
232
+ * Current unbalance percentage
233
+ * @unit percentage (%)
234
+ * @example 0.8
235
+ */
236
+ currentUnbalance: z.ZodOptional<z.ZodNumber>;
237
+ /**
238
+ * Power factor displacement
239
+ * @unit ratio (dimensionless)
240
+ * @example 0.92
241
+ */
242
+ powerFactorDisplacement: z.ZodOptional<z.ZodNumber>;
243
+ /**
244
+ * Total power factor
245
+ * @unit ratio (dimensionless)
246
+ * @example 0.89
247
+ */
248
+ totalPowerFactor: z.ZodOptional<z.ZodNumber>;
249
+ }, "strip", z.ZodTypeAny, {
250
+ frequency?: number | undefined;
251
+ voltageTHD?: number | undefined;
252
+ currentTHD?: number | undefined;
253
+ voltageUnbalance?: number | undefined;
254
+ currentUnbalance?: number | undefined;
255
+ powerFactorDisplacement?: number | undefined;
256
+ totalPowerFactor?: number | undefined;
257
+ }, {
258
+ frequency?: number | undefined;
259
+ voltageTHD?: number | undefined;
260
+ currentTHD?: number | undefined;
261
+ voltageUnbalance?: number | undefined;
262
+ currentUnbalance?: number | undefined;
263
+ powerFactorDisplacement?: number | undefined;
264
+ totalPowerFactor?: number | undefined;
265
+ }>>;
266
+ }, "strip", z.ZodTypeAny, {
267
+ startAt: string;
268
+ endAt: string;
269
+ usage?: {
270
+ kwhUsage?: number | undefined;
271
+ kvarhUsage?: number | undefined;
272
+ kvahUsage?: number | undefined;
273
+ } | undefined;
274
+ cost?: number | undefined;
275
+ powerQuality?: {
276
+ frequency?: number | undefined;
277
+ voltageTHD?: number | undefined;
278
+ currentTHD?: number | undefined;
279
+ voltageUnbalance?: number | undefined;
280
+ currentUnbalance?: number | undefined;
281
+ powerFactorDisplacement?: number | undefined;
282
+ totalPowerFactor?: number | undefined;
283
+ } | undefined;
284
+ }, {
285
+ startAt: string;
286
+ endAt: string;
287
+ usage?: {
288
+ kwhUsage?: number | undefined;
289
+ kvarhUsage?: number | undefined;
290
+ kvahUsage?: number | undefined;
291
+ } | undefined;
292
+ cost?: number | undefined;
293
+ powerQuality?: {
294
+ frequency?: number | undefined;
295
+ voltageTHD?: number | undefined;
296
+ currentTHD?: number | undefined;
297
+ voltageUnbalance?: number | undefined;
298
+ currentUnbalance?: number | undefined;
299
+ powerFactorDisplacement?: number | undefined;
300
+ totalPowerFactor?: number | undefined;
301
+ } | undefined;
302
+ }>;
303
+ export type MeterIntervalReading = z.infer<typeof MeterIntervalReadingSchema>;
304
+ /**
305
+ * Meter state supporting various electrical configurations:
306
+ * - Single-phase: Only phaseA is populated
307
+ * - Split-phase: phaseA and phaseB are populated (typical North American residential)
308
+ * - Three-phase: All phases (phaseA, phaseB, phaseC) are populated
309
+ */
310
+ export declare const MeterStateSchema: z.ZodObject<{
311
+ /**
312
+ * Last reading timestamp
313
+ * @example "2024-01-01T12:00:00.000Z"
314
+ */
315
+ lastReadingAt: z.ZodOptional<z.ZodString>;
316
+ /**
317
+ * Phase A measurements (always present for any configuration)
318
+ */
319
+ phaseA: z.ZodObject<{
320
+ /**
321
+ * RMS voltage measurement
322
+ * @unit volts (V)
323
+ * @example 240.5
324
+ */
325
+ voltage: z.ZodOptional<z.ZodNumber>;
326
+ /**
327
+ * RMS current measurement
328
+ * @unit amperes (A)
329
+ * @example 15.2
330
+ */
331
+ current: z.ZodOptional<z.ZodNumber>;
332
+ /**
333
+ * Real power measurement
334
+ * @unit kilowatts (kW)
335
+ * @example 3.6
336
+ */
337
+ realPower: z.ZodOptional<z.ZodNumber>;
338
+ /**
339
+ * Reactive power measurement
340
+ * @unit kilovars (kVAR)
341
+ * @example 1.2
342
+ */
343
+ reactivePower: z.ZodOptional<z.ZodNumber>;
344
+ /**
345
+ * Power factor measurement
346
+ * @unit ratio (dimensionless)
347
+ * @example 0.95
348
+ */
349
+ powerFactor: z.ZodOptional<z.ZodNumber>;
350
+ }, "strip", z.ZodTypeAny, {
351
+ voltage?: number | undefined;
352
+ current?: number | undefined;
353
+ realPower?: number | undefined;
354
+ reactivePower?: number | undefined;
355
+ powerFactor?: number | undefined;
356
+ }, {
357
+ voltage?: number | undefined;
358
+ current?: number | undefined;
359
+ realPower?: number | undefined;
360
+ reactivePower?: number | undefined;
361
+ powerFactor?: number | undefined;
362
+ }>;
363
+ /**
364
+ * Phase B measurements (optional - used in split-phase and three-phase configurations)
365
+ */
366
+ phaseB: z.ZodOptional<z.ZodObject<{
367
+ /**
368
+ * RMS voltage measurement
369
+ * @unit volts (V)
370
+ * @example 240.5
371
+ */
372
+ voltage: z.ZodOptional<z.ZodNumber>;
373
+ /**
374
+ * RMS current measurement
375
+ * @unit amperes (A)
376
+ * @example 15.2
377
+ */
378
+ current: z.ZodOptional<z.ZodNumber>;
379
+ /**
380
+ * Real power measurement
381
+ * @unit kilowatts (kW)
382
+ * @example 3.6
383
+ */
384
+ realPower: z.ZodOptional<z.ZodNumber>;
385
+ /**
386
+ * Reactive power measurement
387
+ * @unit kilovars (kVAR)
388
+ * @example 1.2
389
+ */
390
+ reactivePower: z.ZodOptional<z.ZodNumber>;
391
+ /**
392
+ * Power factor measurement
393
+ * @unit ratio (dimensionless)
394
+ * @example 0.95
395
+ */
396
+ powerFactor: z.ZodOptional<z.ZodNumber>;
397
+ }, "strip", z.ZodTypeAny, {
398
+ voltage?: number | undefined;
399
+ current?: number | undefined;
400
+ realPower?: number | undefined;
401
+ reactivePower?: number | undefined;
402
+ powerFactor?: number | undefined;
403
+ }, {
404
+ voltage?: number | undefined;
405
+ current?: number | undefined;
406
+ realPower?: number | undefined;
407
+ reactivePower?: number | undefined;
408
+ powerFactor?: number | undefined;
409
+ }>>;
410
+ /**
411
+ * Phase C measurements (optional - used in three-phase configurations only)
412
+ */
413
+ phaseC: z.ZodOptional<z.ZodObject<{
414
+ /**
415
+ * RMS voltage measurement
416
+ * @unit volts (V)
417
+ * @example 240.5
418
+ */
419
+ voltage: z.ZodOptional<z.ZodNumber>;
420
+ /**
421
+ * RMS current measurement
422
+ * @unit amperes (A)
423
+ * @example 15.2
424
+ */
425
+ current: z.ZodOptional<z.ZodNumber>;
426
+ /**
427
+ * Real power measurement
428
+ * @unit kilowatts (kW)
429
+ * @example 3.6
430
+ */
431
+ realPower: z.ZodOptional<z.ZodNumber>;
432
+ /**
433
+ * Reactive power measurement
434
+ * @unit kilovars (kVAR)
435
+ * @example 1.2
436
+ */
437
+ reactivePower: z.ZodOptional<z.ZodNumber>;
438
+ /**
439
+ * Power factor measurement
440
+ * @unit ratio (dimensionless)
441
+ * @example 0.95
442
+ */
443
+ powerFactor: z.ZodOptional<z.ZodNumber>;
444
+ }, "strip", z.ZodTypeAny, {
445
+ voltage?: number | undefined;
446
+ current?: number | undefined;
447
+ realPower?: number | undefined;
448
+ reactivePower?: number | undefined;
449
+ powerFactor?: number | undefined;
450
+ }, {
451
+ voltage?: number | undefined;
452
+ current?: number | undefined;
453
+ realPower?: number | undefined;
454
+ reactivePower?: number | undefined;
455
+ powerFactor?: number | undefined;
456
+ }>>;
457
+ /**
458
+ * Latest interval reading with usage data and power quality metrics
459
+ */
460
+ lastIntervalReading: z.ZodOptional<z.ZodObject<{
461
+ /**
462
+ * Interval start timestamp
463
+ * @example "2024-01-01T12:00:00.000Z"
464
+ */
465
+ startAt: z.ZodString;
466
+ /**
467
+ * Interval end timestamp
468
+ * @example "2024-01-01T13:00:00.000Z"
469
+ */
470
+ endAt: z.ZodString;
471
+ /**
472
+ * Energy usage metrics for this interval
473
+ */
474
+ usage: z.ZodOptional<z.ZodObject<{
475
+ /**
476
+ * Real energy usage over interval
477
+ * @unit kilowatt-hours (kWh)
478
+ * @example 5.25
479
+ */
480
+ kwhUsage: z.ZodOptional<z.ZodNumber>;
481
+ /**
482
+ * Reactive energy usage over interval
483
+ * @unit kilovar-hours (kVARh)
484
+ * @example 2.1
485
+ */
486
+ kvarhUsage: z.ZodOptional<z.ZodNumber>;
487
+ /**
488
+ * Apparent energy usage over interval
489
+ * @unit kilovolt-ampere-hours (kVAh)
490
+ * @example 5.7
491
+ */
492
+ kvahUsage: z.ZodOptional<z.ZodNumber>;
493
+ }, "strip", z.ZodTypeAny, {
494
+ kwhUsage?: number | undefined;
495
+ kvarhUsage?: number | undefined;
496
+ kvahUsage?: number | undefined;
497
+ }, {
498
+ kwhUsage?: number | undefined;
499
+ kvarhUsage?: number | undefined;
500
+ kvahUsage?: number | undefined;
501
+ }>>;
502
+ /**
503
+ * Cost associated with this interval's usage
504
+ * @unit currency (e.g., USD)
505
+ * @example 0.65
506
+ */
507
+ cost: z.ZodOptional<z.ZodNumber>;
508
+ /**
509
+ * Power quality metrics for this interval
510
+ */
511
+ powerQuality: z.ZodOptional<z.ZodObject<{
512
+ /**
513
+ * Total Harmonic Distortion for voltage
514
+ * @unit percentage (%)
515
+ * @example 2.5
516
+ */
517
+ voltageTHD: z.ZodOptional<z.ZodNumber>;
518
+ /**
519
+ * Total Harmonic Distortion for current
520
+ * @unit percentage (%)
521
+ * @example 4.2
522
+ */
523
+ currentTHD: z.ZodOptional<z.ZodNumber>;
524
+ /**
525
+ * Frequency measurement
526
+ * @unit hertz (Hz)
527
+ * @example 59.98
528
+ */
529
+ frequency: z.ZodOptional<z.ZodNumber>;
530
+ /**
531
+ * Voltage unbalance percentage
532
+ * @unit percentage (%)
533
+ * @example 1.2
534
+ */
535
+ voltageUnbalance: z.ZodOptional<z.ZodNumber>;
536
+ /**
537
+ * Current unbalance percentage
538
+ * @unit percentage (%)
539
+ * @example 0.8
540
+ */
541
+ currentUnbalance: z.ZodOptional<z.ZodNumber>;
542
+ /**
543
+ * Power factor displacement
544
+ * @unit ratio (dimensionless)
545
+ * @example 0.92
546
+ */
547
+ powerFactorDisplacement: z.ZodOptional<z.ZodNumber>;
548
+ /**
549
+ * Total power factor
550
+ * @unit ratio (dimensionless)
551
+ * @example 0.89
552
+ */
553
+ totalPowerFactor: z.ZodOptional<z.ZodNumber>;
554
+ }, "strip", z.ZodTypeAny, {
555
+ frequency?: number | undefined;
556
+ voltageTHD?: number | undefined;
557
+ currentTHD?: number | undefined;
558
+ voltageUnbalance?: number | undefined;
559
+ currentUnbalance?: number | undefined;
560
+ powerFactorDisplacement?: number | undefined;
561
+ totalPowerFactor?: number | undefined;
562
+ }, {
563
+ frequency?: number | undefined;
564
+ voltageTHD?: number | undefined;
565
+ currentTHD?: number | undefined;
566
+ voltageUnbalance?: number | undefined;
567
+ currentUnbalance?: number | undefined;
568
+ powerFactorDisplacement?: number | undefined;
569
+ totalPowerFactor?: number | undefined;
570
+ }>>;
571
+ }, "strip", z.ZodTypeAny, {
572
+ startAt: string;
573
+ endAt: string;
574
+ usage?: {
575
+ kwhUsage?: number | undefined;
576
+ kvarhUsage?: number | undefined;
577
+ kvahUsage?: number | undefined;
578
+ } | undefined;
579
+ cost?: number | undefined;
580
+ powerQuality?: {
581
+ frequency?: number | undefined;
582
+ voltageTHD?: number | undefined;
583
+ currentTHD?: number | undefined;
584
+ voltageUnbalance?: number | undefined;
585
+ currentUnbalance?: number | undefined;
586
+ powerFactorDisplacement?: number | undefined;
587
+ totalPowerFactor?: number | undefined;
588
+ } | undefined;
589
+ }, {
590
+ startAt: string;
591
+ endAt: string;
592
+ usage?: {
593
+ kwhUsage?: number | undefined;
594
+ kvarhUsage?: number | undefined;
595
+ kvahUsage?: number | undefined;
596
+ } | undefined;
597
+ cost?: number | undefined;
598
+ powerQuality?: {
599
+ frequency?: number | undefined;
600
+ voltageTHD?: number | undefined;
601
+ currentTHD?: number | undefined;
602
+ voltageUnbalance?: number | undefined;
603
+ currentUnbalance?: number | undefined;
604
+ powerFactorDisplacement?: number | undefined;
605
+ totalPowerFactor?: number | undefined;
606
+ } | undefined;
607
+ }>>;
608
+ }, "strip", z.ZodTypeAny, {
609
+ phaseA: {
610
+ voltage?: number | undefined;
611
+ current?: number | undefined;
612
+ realPower?: number | undefined;
613
+ reactivePower?: number | undefined;
614
+ powerFactor?: number | undefined;
615
+ };
616
+ lastReadingAt?: string | undefined;
617
+ phaseB?: {
618
+ voltage?: number | undefined;
619
+ current?: number | undefined;
620
+ realPower?: number | undefined;
621
+ reactivePower?: number | undefined;
622
+ powerFactor?: number | undefined;
623
+ } | undefined;
624
+ phaseC?: {
625
+ voltage?: number | undefined;
626
+ current?: number | undefined;
627
+ realPower?: number | undefined;
628
+ reactivePower?: number | undefined;
629
+ powerFactor?: number | undefined;
630
+ } | undefined;
631
+ lastIntervalReading?: {
632
+ startAt: string;
633
+ endAt: string;
634
+ usage?: {
635
+ kwhUsage?: number | undefined;
636
+ kvarhUsage?: number | undefined;
637
+ kvahUsage?: number | undefined;
638
+ } | undefined;
639
+ cost?: number | undefined;
640
+ powerQuality?: {
641
+ frequency?: number | undefined;
642
+ voltageTHD?: number | undefined;
643
+ currentTHD?: number | undefined;
644
+ voltageUnbalance?: number | undefined;
645
+ currentUnbalance?: number | undefined;
646
+ powerFactorDisplacement?: number | undefined;
647
+ totalPowerFactor?: number | undefined;
648
+ } | undefined;
649
+ } | undefined;
650
+ }, {
651
+ phaseA: {
652
+ voltage?: number | undefined;
653
+ current?: number | undefined;
654
+ realPower?: number | undefined;
655
+ reactivePower?: number | undefined;
656
+ powerFactor?: number | undefined;
657
+ };
658
+ lastReadingAt?: string | undefined;
659
+ phaseB?: {
660
+ voltage?: number | undefined;
661
+ current?: number | undefined;
662
+ realPower?: number | undefined;
663
+ reactivePower?: number | undefined;
664
+ powerFactor?: number | undefined;
665
+ } | undefined;
666
+ phaseC?: {
667
+ voltage?: number | undefined;
668
+ current?: number | undefined;
669
+ realPower?: number | undefined;
670
+ reactivePower?: number | undefined;
671
+ powerFactor?: number | undefined;
672
+ } | undefined;
673
+ lastIntervalReading?: {
674
+ startAt: string;
675
+ endAt: string;
676
+ usage?: {
677
+ kwhUsage?: number | undefined;
678
+ kvarhUsage?: number | undefined;
679
+ kvahUsage?: number | undefined;
680
+ } | undefined;
681
+ cost?: number | undefined;
682
+ powerQuality?: {
683
+ frequency?: number | undefined;
684
+ voltageTHD?: number | undefined;
685
+ currentTHD?: number | undefined;
686
+ voltageUnbalance?: number | undefined;
687
+ currentUnbalance?: number | undefined;
688
+ powerFactorDisplacement?: number | undefined;
689
+ totalPowerFactor?: number | undefined;
690
+ } | undefined;
691
+ } | undefined;
692
+ }>;
693
+ export type MeterState = z.infer<typeof MeterStateSchema>;
694
+ export declare const MeterStaticStateSchema: z.ZodObject<{
695
+ /**
696
+ * The owner of the meter
697
+ * @example "john.doe@utility.com"
698
+ */
699
+ owner: z.ZodString;
700
+ /**
701
+ * The unique meter identifier
702
+ * @example "METER_12345"
703
+ */
704
+ meterId: z.ZodString;
705
+ /**
706
+ * The meter manufacturer
707
+ * @example "Aclara"
708
+ */
709
+ manufacturer: z.ZodString;
710
+ /**
711
+ * The meter's serial number
712
+ * @example "SN123456789"
713
+ */
714
+ serialNumber: z.ZodString;
715
+ /**
716
+ * The meter's data collection interval length
717
+ * @example "15_MINUTE"
718
+ */
719
+ intervalLength: z.ZodEnum<["1_MINUTE", "5_MINUTE", "15_MINUTE", "30_MINUTE", "1_HOUR", "24_HOUR"]>;
720
+ }, "strip", z.ZodTypeAny, {
721
+ manufacturer: string;
722
+ owner: string;
723
+ meterId: string;
724
+ serialNumber: string;
725
+ intervalLength: "1_MINUTE" | "5_MINUTE" | "15_MINUTE" | "30_MINUTE" | "1_HOUR" | "24_HOUR";
726
+ }, {
727
+ manufacturer: string;
728
+ owner: string;
729
+ meterId: string;
730
+ serialNumber: string;
731
+ intervalLength: "1_MINUTE" | "5_MINUTE" | "15_MINUTE" | "30_MINUTE" | "1_HOUR" | "24_HOUR";
732
+ }>;
733
+ export type MeterStaticState = z.infer<typeof MeterStaticStateSchema>;
734
+ //# sourceMappingURL=meter.d.ts.map
package/dist/deviceState/meter.d.ts.map ADDED
@@ -0,0 +1 @@
1
+ {"version":3,"file":"meter.d.ts","sourceRoot":"","sources":["../../src/deviceState/meter.ts"],"names":[],"mappings":"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"}
package/dist/deviceState/meter.js ADDED
@@ -0,0 +1,200 @@
1
+ "use strict";
2
+ Object.defineProperty(exports, "__esModule", { value: true });
3
+ exports.MeterStaticStateSchema = exports.MeterStateSchema = exports.MeterIntervalReadingSchema = exports.UsageMetricsSchema = exports.PowerQualityMetricsSchema = exports.MeterMeasurementSchema = exports.MeterIntervalLengthEnum = void 0;
4
+ const zod_1 = require("zod");
5
+ /**
6
+ * Standard AMI (Advanced Metering Infrastructure) data collection intervals
7
+ */
8
+ exports.MeterIntervalLengthEnum = zod_1.z.enum(["1_MINUTE", "5_MINUTE", "15_MINUTE", "30_MINUTE", "1_HOUR", "24_HOUR"]);
9
+ /**
10
+ * Electrical measurements for a single phase
11
+ * Supports three-phase, split-phase, and single-phase meter configurations
12
+ */
13
+ exports.MeterMeasurementSchema = zod_1.z.object({
14
+ /**
15
+ * RMS voltage measurement
16
+ * @unit volts (V)
17
+ * @example 240.5
18
+ */
19
+ voltage: zod_1.z.number().optional().describe("RMS voltage in volts (V)"),
20
+ /**
21
+ * RMS current measurement
22
+ * @unit amperes (A)
23
+ * @example 15.2
24
+ */
25
+ current: zod_1.z.number().optional().describe("RMS current in amperes (A)"),
26
+ /**
27
+ * Real power measurement
28
+ * @unit kilowatts (kW)
29
+ * @example 3.6
30
+ */
31
+ realPower: zod_1.z.number().optional().describe("Real power in kilowatts (kW)"),
32
+ /**
33
+ * Reactive power measurement
34
+ * @unit kilovars (kVAR)
35
+ * @example 1.2
36
+ */
37
+ reactivePower: zod_1.z.number().optional().describe("Reactive power in kilovars (kVAR)"),
38
+ /**
39
+ * Power factor measurement
40
+ * @unit ratio (dimensionless)
41
+ * @example 0.95
42
+ */
43
+ powerFactor: zod_1.z.number().optional().describe("Power factor (ratio)"),
44
+ });
45
+ /**
46
+ * Power quality metrics for advanced electrical monitoring
47
+ */
48
+ exports.PowerQualityMetricsSchema = zod_1.z.object({
49
+ /**
50
+ * Total Harmonic Distortion for voltage
51
+ * @unit percentage (%)
52
+ * @example 2.5
53
+ */
54
+ voltageTHD: zod_1.z.number().optional().describe("Total Harmonic Distortion for voltage (%)"),
55
+ /**
56
+ * Total Harmonic Distortion for current
57
+ * @unit percentage (%)
58
+ * @example 4.2
59
+ */
60
+ currentTHD: zod_1.z.number().optional().describe("Total Harmonic Distortion for current (%)"),
61
+ /**
62
+ * Frequency measurement
63
+ * @unit hertz (Hz)
64
+ * @example 59.98
65
+ */
66
+ frequency: zod_1.z.number().optional().describe("Electrical frequency in hertz (Hz)"),
67
+ /**
68
+ * Voltage unbalance percentage
69
+ * @unit percentage (%)
70
+ * @example 1.2
71
+ */
72
+ voltageUnbalance: zod_1.z.number().optional().describe("Voltage unbalance percentage (%)"),
73
+ /**
74
+ * Current unbalance percentage
75
+ * @unit percentage (%)
76
+ * @example 0.8
77
+ */
78
+ currentUnbalance: zod_1.z.number().optional().describe("Current unbalance percentage (%)"),
79
+ /**
80
+ * Power factor displacement
81
+ * @unit ratio (dimensionless)
82
+ * @example 0.92
83
+ */
84
+ powerFactorDisplacement: zod_1.z.number().optional().describe("Power factor displacement (ratio)"),
85
+ /**
86
+ * Total power factor
87
+ * @unit ratio (dimensionless)
88
+ * @example 0.89
89
+ */
90
+ totalPowerFactor: zod_1.z.number().optional().describe("Total power factor including harmonics (ratio)"),
91
+ });
92
+ /**
93
+ * Energy usage measurements for different types of power
94
+ */
95
+ exports.UsageMetricsSchema = zod_1.z.object({
96
+ /**
97
+ * Real energy usage over interval
98
+ * @unit kilowatt-hours (kWh)
99
+ * @example 5.25
100
+ */
101
+ kwhUsage: zod_1.z.number().optional().describe("Real energy usage in kilowatt-hours (kWh)"),
102
+ /**
103
+ * Reactive energy usage over interval
104
+ * @unit kilovar-hours (kVARh)
105
+ * @example 2.1
106
+ */
107
+ kvarhUsage: zod_1.z.number().optional().describe("Reactive energy usage in kilovar-hours (kVARh)"),
108
+ /**
109
+ * Apparent energy usage over interval
110
+ * @unit kilovolt-ampere-hours (kVAh)
111
+ * @example 5.7
112
+ */
113
+ kvahUsage: zod_1.z.number().optional().describe("Apparent energy usage in kilovolt-ampere-hours (kVAh)"),
114
+ });
115
+ /**
116
+ * Meter interval reading containing usage data and power quality metrics
117
+ */
118
+ exports.MeterIntervalReadingSchema = zod_1.z.object({
119
+ /**
120
+ * Interval start timestamp
121
+ * @example "2024-01-01T12:00:00.000Z"
122
+ */
123
+ startAt: zod_1.z.string().datetime().describe("Interval start timestamp"),
124
+ /**
125
+ * Interval end timestamp
126
+ * @example "2024-01-01T13:00:00.000Z"
127
+ */
128
+ endAt: zod_1.z.string().datetime().describe("Interval end timestamp"),
129
+ /**
130
+ * Energy usage metrics for this interval
131
+ */
132
+ usage: exports.UsageMetricsSchema.optional().describe("Energy usage metrics for this interval"),
133
+ /**
134
+ * Cost associated with this interval's usage
135
+ * @unit currency (e.g., USD)
136
+ * @example 0.65
137
+ */
138
+ cost: zod_1.z.number().optional().describe("Cost associated with this interval's usage"),
139
+ /**
140
+ * Power quality metrics for this interval
141
+ */
142
+ powerQuality: exports.PowerQualityMetricsSchema.optional().describe("Power quality metrics for this interval"),
143
+ });
144
+ /**
145
+ * Meter state supporting various electrical configurations:
146
+ * - Single-phase: Only phaseA is populated
147
+ * - Split-phase: phaseA and phaseB are populated (typical North American residential)
148
+ * - Three-phase: All phases (phaseA, phaseB, phaseC) are populated
149
+ */
150
+ exports.MeterStateSchema = zod_1.z.object({
151
+ /**
152
+ * Last reading timestamp
153
+ * @example "2024-01-01T12:00:00.000Z"
154
+ */
155
+ lastReadingAt: zod_1.z.string().datetime().optional().describe("Last meter reading timestamp"),
156
+ /**
157
+ * Phase A measurements (always present for any configuration)
158
+ */
159
+ phaseA: exports.MeterMeasurementSchema.describe("Phase A electrical measurements"),
160
+ /**
161
+ * Phase B measurements (optional - used in split-phase and three-phase configurations)
162
+ */
163
+ phaseB: exports.MeterMeasurementSchema.optional().describe("Phase B electrical measurements"),
164
+ /**
165
+ * Phase C measurements (optional - used in three-phase configurations only)
166
+ */
167
+ phaseC: exports.MeterMeasurementSchema.optional().describe("Phase C electrical measurements"),
168
+ /**
169
+ * Latest interval reading with usage data and power quality metrics
170
+ */
171
+ lastIntervalReading: exports.MeterIntervalReadingSchema.optional().describe("Latest interval reading"),
172
+ });
173
+ exports.MeterStaticStateSchema = zod_1.z.object({
174
+ /**
175
+ * The owner of the meter
176
+ * @example "john.doe@utility.com"
177
+ */
178
+ owner: zod_1.z.string().describe("The owner of the meter"),
179
+ /**
180
+ * The unique meter identifier
181
+ * @example "METER_12345"
182
+ */
183
+ meterId: zod_1.z.string().describe("The unique meter identifier"),
184
+ /**
185
+ * The meter manufacturer
186
+ * @example "Aclara"
187
+ */
188
+ manufacturer: zod_1.z.string().describe("The meter manufacturer"),
189
+ /**
190
+ * The meter's serial number
191
+ * @example "SN123456789"
192
+ */
193
+ serialNumber: zod_1.z.string().describe("The meter's serial number"),
194
+ /**
195
+ * The meter's data collection interval length
196
+ * @example "15_MINUTE"
197
+ */
198
+ intervalLength: exports.MeterIntervalLengthEnum.describe("The meter's data collection interval length"),
199
+ });
200
+ //# sourceMappingURL=meter.js.map
package/dist/deviceState/meter.js.map ADDED
@@ -0,0 +1 @@
1
+ {"version":3,"file":"meter.js","sourceRoot":"","sources":["../../src/deviceState/meter.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAExB;;GAEG;AACU,QAAA,uBAAuB,GAAG,OAAC,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC;AAIvH;;;GAGG;AACU,QAAA,sBAAsB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC7C;;;;OAIG;IACH,OAAO,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,0BAA0B,CAAC;IACnE;;;;OAIG;IACH,OAAO,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,4BAA4B,CAAC;IACrE;;;;OAIG;IACH,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,8BAA8B,CAAC;IACzE;;;;OAIG;IACH,aAAa,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,mCAAmC,CAAC;IAClF;;;;OAIG;IACH,WAAW,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,sBAAsB,CAAC;CACpE,CAAC,CAAC;AAIH;;GAEG;AACU,QAAA,yBAAyB,GAAG,OAAC,CAAC,MAAM,CAAC;IAChD;;;;OAIG;IACH,UAAU,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,2CAA2C,CAAC;IACvF;;;;OAIG;IACH,UAAU,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,2CAA2C,CAAC;IACvF;;;;OAIG;IACH,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,oCAAoC,CAAC;IAC/E;;;;OAIG;IACH,gBAAgB,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,kCAAkC,CAAC;IACpF;;;;OAIG;IACH,gBAAgB,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,kCAAkC,CAAC;IACpF;;;;OAIG;IACH,uBAAuB,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,mCAAmC,CAAC;IAC5F;;;;OAIG;IACH,gBAAgB,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,gDAAgD,CAAC;CACnG,CAAC,CAAC;AAIH;;GAEG;AACU,QAAA,kBAAkB,GAAG,OAAC,CAAC,MAAM,CAAC;IACzC;;;;OAIG;IACH,QAAQ,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,2CAA2C,CAAC;IACrF;;;;OAIG;IACH,UAAU,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,gDAAgD,CAAC;IAC5F;;;;OAIG;IACH,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,uDAAuD,CAAC;CACnG,CAAC,CAAC;AAIH;;GAEG;AACU,QAAA,0BAA0B,GAAG,OAAC,CAAC,MAAM,CAAC;IACjD;;;OAGG;IACH,OAAO,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,0BAA0B,CAAC;IACnE;;;OAGG;IACH,KAAK,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,wBAAwB,CAAC;IAC/D;;OAEG;IACH,KAAK,EAAE,0BAAkB,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,wCAAwC,CAAC;IACvF;;;;OAIG;IACH,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,4CAA4C,CAAC;IAClF;;OAEG;IACH,YAAY,EAAE,iCAAyB,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,yCAAyC,CAAC;CACvG,CAAC,CAAC;AAIH;;;;;GAKG;AACU,QAAA,gBAAgB,GAAG,OAAC,CAAC,MAAM,CAAC;IACvC;;;OAGG;IACH,aAAa,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,8BAA8B,CAAC;IACxF;;OAEG;IACH,MAAM,EAAE,8BAAsB,CAAC,QAAQ,CAAC,iCAAiC,CAAC;IAC1E;;OAEG;IACH,MAAM,EAAE,8BAAsB,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,iCAAiC,CAAC;IACrF;;OAEG;IACH,MAAM,EAAE,8BAAsB,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,iCAAiC,CAAC;IACrF;;OAEG;IACH,mBAAmB,EAAE,kCAA0B,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,yBAAyB,CAAC;CAC/F,CAAC,CAAC;AAIU,QAAA,sBAAsB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC7C;;;OAGG;IACH,KAAK,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,wBAAwB,CAAC;IACpD;;;OAGG;IACH,OAAO,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,6BAA6B,CAAC;IAC3D;;;OAGG;IACH,YAAY,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,wBAAwB,CAAC;IAC3D;;;OAGG;IACH,YAAY,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,2BAA2B,CAAC;IAC9D;;;OAGG;IACH,cAAc,EAAE,+BAAuB,CAAC,QAAQ,CAAC,6CAA6C,CAAC;CAChG,CAAC,CAAC"}
package/dist/deviceType/entities.d.ts CHANGED
@@ -1,6 +1,6 @@
1
1
  import { z } from "zod";
2
- export declare const DeviceTypes: readonly ["battery", "charger", "inverter", "thermostat", "vehicle", "other", "unknown"];
2
+ export declare const DeviceTypes: readonly ["battery", "charger", "inverter", "meter", "thermostat", "vehicle", "other", "unknown"];
3
3
  export type DeviceType = (typeof DeviceTypes)[number];
4
- export declare const DeviceTypeEnum: z.ZodEnum<["battery", "charger", "inverter", "thermostat", "vehicle", "other", "unknown"]>;
4
+ export declare const DeviceTypeEnum: z.ZodEnum<["battery", "charger", "inverter", "meter", "thermostat", "vehicle", "other", "unknown"]>;
5
5
  export declare const DeviceTypeLabelMap: Record<DeviceType, string>;
6
6
  //# sourceMappingURL=entities.d.ts.map
package/dist/deviceType/entities.d.ts.map CHANGED
@@ -1 +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"}
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,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 CHANGED
@@ -2,12 +2,22 @@
2
2
  Object.defineProperty(exports, "__esModule", { value: true });
3
3
  exports.DeviceTypeLabelMap = exports.DeviceTypeEnum = exports.DeviceTypes = void 0;
4
4
  const zod_1 = require("zod");
5
- exports.DeviceTypes = ["battery", "charger", "inverter", "thermostat", "vehicle", "other", "unknown"];
5
+ exports.DeviceTypes = [
6
+ "battery",
7
+ "charger",
8
+ "inverter",
9
+ "meter",
10
+ "thermostat",
11
+ "vehicle",
12
+ "other",
13
+ "unknown",
14
+ ];
6
15
  exports.DeviceTypeEnum = zod_1.z.enum(exports.DeviceTypes);
7
16
  exports.DeviceTypeLabelMap = {
8
17
  battery: "Battery",
9
18
  charger: "Charger",
10
19
  inverter: "Inverter",
20
+ meter: "Meter",
11
21
  thermostat: "Thermostat",
12
22
  vehicle: "Vehicle",
13
23
  other: "Other",
package/dist/deviceType/entities.js.map CHANGED
@@ -1 +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"}
1
+ {"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/dist/manufacturer/entities.d.ts CHANGED
@@ -16,6 +16,12 @@ export declare const ManufacturerLogoSchema: z.ZodObject<{
16
16
  alt: string;
17
17
  }>;
18
18
  export declare const ManufacturerSchema: z.ZodObject<{
19
+ /**
20
+ * The database identifier for the manufacturer.
21
+ * Optional because it may not be present in all contexts (e.g., external API responses).
22
+ * @example "clxyz123abc"
23
+ */
24
+ id: z.ZodOptional<z.ZodString>;
19
25
  /**
20
26
  * The unique identifier for the manufacturer.
21
27
  * @example "bmw"
@@ -27,6 +33,11 @@ export declare const ManufacturerSchema: z.ZodObject<{
27
33
  */
28
34
  name: z.ZodString;
29
35
  supportLevel: z.ZodEnum<["planned", "development", "uat", "production", "blocked"]>;
36
+ /**
37
+ * Whether this manufacturer's devices support grid services.
38
+ * Optional because it may not be present in all contexts.
39
+ */
40
+ supportsGridServices: z.ZodOptional<z.ZodBoolean>;
30
41
  logo: z.ZodObject<{
31
42
  url: z.ZodString;
32
43
  alt: z.ZodString;
@@ -97,6 +108,8 @@ export declare const ManufacturerSchema: z.ZodObject<{
97
108
  url: string;
98
109
  alt: string;
99
110
  };
111
+ id?: string | undefined;
112
+ supportsGridServices?: boolean | undefined;
100
113
  }, {
101
114
  name: string;
102
115
  slug: string;
@@ -119,6 +132,8 @@ export declare const ManufacturerSchema: z.ZodObject<{
119
132
  url: string;
120
133
  alt: string;
121
134
  };
135
+ id?: string | undefined;
136
+ supportsGridServices?: boolean | undefined;
122
137
  }>;
123
138
  export type Manufacturer = z.infer<typeof ManufacturerSchema>;
124
139
  //# sourceMappingURL=entities.d.ts.map
package/dist/manufacturer/entities.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"entities.d.ts","sourceRoot":"","sources":["../../src/manufacturer/entities.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;EAKjC,CAAC;AAEH,eAAO,MAAM,kBAAkB;IAC7B;;;OAGG;;IAEH;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMH,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}
1
+ {"version":3,"file":"entities.d.ts","sourceRoot":"","sources":["../../src/manufacturer/entities.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;EAKjC,CAAC;AAEH,eAAO,MAAM,kBAAkB;IAC9B;;;;OAIG;;IAEH;;;OAGG;;IAEH;;;OAGG;;;IAGH;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKF,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}
package/dist/manufacturer/entities.js CHANGED
@@ -10,6 +10,12 @@ exports.ManufacturerLogoSchema = zod_1.z.object({
10
10
  height: zod_1.z.number().min(1),
11
11
  });
12
12
  exports.ManufacturerSchema = zod_1.z.object({
13
+ /**
14
+ * The database identifier for the manufacturer.
15
+ * Optional because it may not be present in all contexts (e.g., external API responses).
16
+ * @example "clxyz123abc"
17
+ */
18
+ id: zod_1.z.string().optional(),
13
19
  /**
14
20
  * The unique identifier for the manufacturer.
15
21
  * @example "bmw"
@@ -21,6 +27,11 @@ exports.ManufacturerSchema = zod_1.z.object({
21
27
  */
22
28
  name: zod_1.z.string(),
23
29
  supportLevel: supportLevel_1.SupportLevelEnum,
30
+ /**
31
+ * Whether this manufacturer's devices support grid services.
32
+ * Optional because it may not be present in all contexts.
33
+ */
34
+ supportsGridServices: zod_1.z.boolean().optional(),
24
35
  logo: exports.ManufacturerLogoSchema,
25
36
  icon: exports.ManufacturerLogoSchema,
26
37
  vectorIcon: exports.ManufacturerLogoSchema,
package/dist/manufacturer/entities.js.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"entities.js","sourceRoot":"","sources":["../../src/manufacturer/entities.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AACxB,yDAA0D;AAE7C,QAAA,sBAAsB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC7C,GAAG,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE;IACrB,GAAG,EAAE,OAAC,CAAC,MAAM,EAAE;IACf,KAAK,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACxB,MAAM,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;CAC1B,CAAC,CAAC;AAEU,QAAA,kBAAkB,GAAG,OAAC,CAAC,MAAM,CAAC;IACzC;;;OAGG;IACH,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE;IAChB;;;OAGG;IACH,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE;IAChB,YAAY,EAAE,+BAAgB;IAC9B,IAAI,EAAE,8BAAsB;IAC5B,IAAI,EAAE,8BAAsB;IAC5B,UAAU,EAAE,8BAAsB;CACnC,CAAC,CAAC"}
1
+ {"version":3,"file":"entities.js","sourceRoot":"","sources":["../../src/manufacturer/entities.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AACxB,yDAA0D;AAE7C,QAAA,sBAAsB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC9C,GAAG,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE;IACrB,GAAG,EAAE,OAAC,CAAC,MAAM,EAAE;IACf,KAAK,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACxB,MAAM,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;CACzB,CAAC,CAAC;AAEU,QAAA,kBAAkB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC1C;;;;OAIG;IACH,EAAE,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACzB;;;OAGG;IACH,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE;IAChB;;;OAGG;IACH,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE;IAChB,YAAY,EAAE,+BAAgB;IAC9B;;;OAGG;IACH,oBAAoB,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;IAC5C,IAAI,EAAE,8BAAsB;IAC5B,IAAI,EAAE,8BAAsB;IAC5B,UAAU,EAAE,8BAAsB;CAClC,CAAC,CAAC"}
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@texturehq/device",
3
- "version": "1.12.0",
3
+ "version": "1.14.0",
4
4
  "author": "Will Laeri <will@texture.energy>",
5
5
  "description": "A type-safe client for validating device data",
6
6
  "main": "dist/index.js",
@@ -42,5 +42,11 @@
42
42
  "@texturehq/logger": {
43
43
  "optional": true
44
44
  }
45
+ },
46
+ "resolutions": {
47
+ "form-data": "^4.0.4",
48
+ "axios": "^1.12.0",
49
+ "cross-spawn": "^7.0.6",
50
+ "braces": "^3.0.3"
45
51
  }
46
52
  }