@camstack/types 1.2.445 → 1.2.447

package/dist/remote/remote-config.d.ts

@@ -15,6 +15,7 @@ export declare const RemoteBindingActionSchema: z.ZodObject<{
     cap: z.ZodString;
     method: z.ZodString;
     args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    argUnits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     deviceId: z.ZodNumber;
 }, z.core.$strip>;
 export type RemoteBindingAction = z.infer<typeof RemoteBindingActionSchema>;
@@ -24,6 +25,7 @@ export declare const RemoteBindingSchema: z.ZodObject<{
         cap: z.ZodString;
         method: z.ZodString;
         args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        argUnits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         deviceId: z.ZodNumber;
     }, z.core.$strip>;
 }, z.core.$strip>;
@@ -50,6 +52,7 @@ export declare const RemoteConfigSchema: z.ZodObject<{
             cap: z.ZodString;
             method: z.ZodString;
             args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            argUnits: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
             deviceId: z.ZodNumber;
         }, z.core.$strip>;
     }, z.core.$strip>>;

package/dist/units/index.d.ts

@@ -8,6 +8,9 @@ export { UnitConversionError, unitDimension, convertUnit, tryConvertUnit, tryCon
 export type { UnitConversionReason } from './convert.js';
 export { DEFAULT_DISPLAY_PREFERENCE, DISPLAY_PREFERENCES, QUANTITY_BASE, ReadingQuantitySchema, baseUnitOf, displayUnitFor, historyUnitFor, isReadingQuantity, readingMeta, } from './quantity.js';
 export type { DisplayPreference, ReadingMeta, ReadingQuantity } from './quantity.js';
+export { baseUnitForQuantity, unitsForQuantity } from './quantity-units.js';
+export { QuantityUnitError, QuantityValueSchema, convertQuantityInput, isQuantityValue, paramMeta, paramMetaOf, } from './quantity-input.js';
+export type { ConvertQuantityInput, ParamMeta, QuantityUnitErrorCode, QuantityValue, } from './quantity-input.js';
 export { thresholdToBase, thresholdToDisplay } from './threshold.js';
 export { formatReading } from './format-reading.js';
 export type { FormatReadingInput, FormattedReading } from './format-reading.js';

package/dist/units/quantity-input.d.ts

@@ -0,0 +1,58 @@
+/**
+ * A number a person types for a physical quantity — the input side of the
+ * value + unit contract (D972).
+ *
+ * Readings are stored in the base unit of their quantity (D944); a cap method
+ * param is stored in the unit its input schema DECLARES (`paramMeta`). The
+ * wire pair {@link QuantityValue} says "this number is expressed in this
+ * unit"; {@link convertQuantityInput} brings it to the stored unit and refuses,
+ * with a typed {@link QuantityUnitError}, a unit that cannot be that quantity.
+ */
+import { z } from 'zod';
+import { type ReadingQuantity } from './quantity.js';
+export type QuantityUnitErrorCode = 'non-finite' | 'unknown-unit' | 'cross-dimension'
+/** A unit was given for a field or param that is not a quantity. */
+ | 'no-quantity';
+/** A unit that cannot be applied to the number it was given with. */
+export declare class QuantityUnitError extends Error {
+    readonly code: QuantityUnitErrorCode;
+    constructor(code: QuantityUnitErrorCode, message: string);
+}
+/** The wire pair: `value` is expressed in `unit`. */
+export declare const QuantityValueSchema: z.ZodObject<{
+    value: z.ZodNumber;
+    unit: z.ZodString;
+}, z.core.$strip>;
+export type QuantityValue = z.infer<typeof QuantityValueSchema>;
+export declare function isQuantityValue(candidate: unknown): candidate is QuantityValue;
+export interface ConvertQuantityInput {
+    readonly value: number;
+    /** The unit `value` is expressed in, as the person picked it. */
+    readonly unit: string;
+    /** The unit to store: the quantity base, or a param's declared unit. */
+    readonly target: string;
+}
+/**
+ * `value` expressed in `unit`, brought to `target`. Throws
+ * {@link QuantityUnitError} for a non-finite value, an unknown unit or a unit
+ * of another dimension — never guesses.
+ */
+export declare function convertQuantityInput(input: ConvertQuantityInput): number;
+/** What a method input field declares: the quantity and the unit its value is in. */
+export interface ParamMeta {
+    readonly [key: string]: unknown;
+    readonly quantity: ReadingQuantity;
+    readonly unit: string;
+}
+/**
+ * Zod `.meta()` bag for a cap METHOD param that is a physical quantity — the
+ * input-side twin of `readingMeta`. The value is carried in `unit` (a gram
+ * portion stays in grams); the unit must belong to the quantity, checked once
+ * when the cap is declared.
+ */
+export declare function paramMeta(declared: {
+    readonly quantity: ReadingQuantity;
+    readonly unit: string;
+}): ParamMeta;
+/** The `paramMeta` on a method input field (or its unwrapped leaf), if any. */
+export declare function paramMetaOf(field: z.ZodType): ParamMeta | undefined;

package/dist/units/quantity-units.d.ts

@@ -0,0 +1,8 @@
+import { type ReadingQuantity } from './quantity.js';
+/** The unit a reading of `quantity` is stored in, or `undefined` when it has none. */
+export declare function baseUnitForQuantity(quantity: ReadingQuantity): string | undefined;
+/**
+ * The units a person can enter a number of `quantity` in — base unit first.
+ * Empty when the quantity carries no unit.
+ */
+export declare function unitsForQuantity(quantity: ReadingQuantity): readonly string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/types",
-  "version": "1.2.445",
+  "version": "1.2.447",
   "description": "Shared types, interfaces, and model catalogs for the CamStack detection ecosystem",
   "keywords": [
     "camstack",