unacy 0.6.0 → 0.8.0

package/README.md

@@ -11,6 +11,8 @@ Type-safe unit and format conversion library with automatic multi-hop compositio
 - 🛡️ **Cycle detection** - Prevents infinite conversion loops
 - 📦 **Tree-shakeable** - Only bundle converters you use
 - ✨ **Fluent API** - Clean, readable conversion syntax
+- 🎯 **Typed Metadata** - Native support for `number`, `string`, `boolean`, and `bigint` units
+- 🧩 **Non-Primitive Types** - First-class support for enums, classes, records, and tuples
 
 ## Installation
 
@@ -21,15 +23,27 @@ pnpm add @unacy/core
 ## Quick Start
 
 ```typescript
-import { createRegistry, type WithUnits } from '@unacy/core';
+import { createRegistry } from '@unacy/core';
+import type { WithTypedUnits } from '@unacy/core';
 
-// Define your unit types
-type Celsius = WithUnits<number, 'Celsius'>;
-type Fahrenheit = WithUnits<number, 'Fahrenheit'>;
+// Define metadata for your units (name + type)
+const CelsiusMetadata = {
+  name: 'Celsius' as const,
+  type: 'number' as const
+};
+
+const FahrenheitMetadata = {
+  name: 'Fahrenheit' as const,
+  type: 'number' as const
+};
 
-// Create a registry
+// Define your unit types with metadata
+type Celsius = WithTypedUnits<typeof CelsiusMetadata>;
+type Fahrenheit = WithTypedUnits<typeof FahrenheitMetadata>;
+
+// Create a registry and register converters
 const tempRegistry = createRegistry()
-  .register('Celsius', 'Fahrenheit', (c) => ((c * 9/5) + 32) as Fahrenheit);
+  .register(CelsiusMetadata, FahrenheitMetadata, (c) => ((c * 9/5) + 32));
 
 // Create branded values using callable accessors (NEW!)
 const temp = tempRegistry.Celsius(25); // Returns Celsius type
@@ -44,9 +58,6 @@ const fahrenheit2 = tempRegistry.Celsius.to.Fahrenheit(tempRegistry.Celsius(30))
 
 console.log(fahrenheit1); // 77
 console.log(fahrenheit2); // 86
-
-// Old way still works (manual casting)
-const tempOld: Celsius = 25 as Celsius;
 ```
 
 ## Usage Examples
@@ -57,15 +68,12 @@ Unit accessors are now callable functions that create branded values:
 
 ```typescript
 // Create branded values without manual type casting
-const temp = registry.Celsius(25);        // Returns WithUnits<number, 'Celsius'>
-const distance = registry.meters(100);    // Returns WithUnits<number, 'meters'>
+const temp = registry.Celsius(25);        // Returns WithTypedUnits<typeof CelsiusMetadata>
+const distance = registry.meters(100);    // Returns WithTypedUnits<typeof MetersMetadata>
 
 // Fluent workflow
 const fahrenheit = registry.Celsius.to.Fahrenheit(registry.Celsius(20));
 
-// Compare with old way (still works)
-const tempOld: Celsius = 25 as Celsius;
-
 // Benefits:
 // - Cleaner syntax
 // - Less verbose than manual casting
@@ -73,11 +81,32 @@ const tempOld: Celsius = 25 as Celsius;
 // - Works seamlessly with conversions
 ```
 
+### Typed Metadata
+
+Define metadata with minimal required fields (name + type):
+
+```typescript
+const CelsiusMetadata = {
+  name: 'Celsius' as const,
+  type: 'number' as const
+};
+
+const EtherMetadata = {
+  name: 'ether' as const,
+  type: 'bigint' as const
+};
+
+const FlagMetadata = {
+  name: 'enabled' as const,
+  type: 'boolean' as const
+};
+```
+
 ### Basic Unit Conversions
 
 ```typescript
 // Same registry as above
-const distance: Meters = 10 as Meters;
+const distance = distanceRegistry.meters(10);
 
 // Access units directly via property syntax
 const feet = distanceRegistry.meters.to.feet(distance);
@@ -87,28 +116,38 @@ console.log(feet); // 32.8084
 const feet2 = distanceRegistry.meters.to.feet(distanceRegistry.meters(10));
 
 // Works in both directions
-const meters = distanceRegistry.feet.to.meters(32.8084 as Feet) satisfies Meters;
+const meters = distanceRegistry.feet.to.meters(distanceRegistry.feet(32.8084));
 console.log(meters); // 10
 ```
 
 ### Bidirectional Converters
 
 ```typescript
-import { createRegistry, type WithUnits } from '@unacy/core';
+import { createRegistry } from '@unacy/core';
+import type { WithTypedUnits } from '@unacy/core';
 
-type Meters = WithUnits<number, 'meters'>;
-type Kilometers = WithUnits<number, 'kilometers'>;
+const MetersMetadata = {
+  name: 'meters' as const,
+  type: 'number' as const
+};
 
-const registry = createRegistry<'meters' | 'kilometers'>()
-  .registerBidirectional('meters', 'kilometers', {
-    to: (m) => (m / 1000) as Kilometers,
-    from: (km) => (km * 1000) as Meters
-  });
+const KilometersMetadata = {
+  name: 'kilometers' as const,
+  type: 'number' as const
+};
+
+type Meters = WithTypedUnits<typeof MetersMetadata>;
+type Kilometers = WithTypedUnits<typeof KilometersMetadata>;
+
+const registry = createRegistry()
+  .register(MetersMetadata, KilometersMetadata, {
+    to: (m: number) => (m / 1000),
+    from: (km: number) => (km * 1000)
   });
 
 // Both directions work automatically
-const km = registry.convert(5000 as Meters, 'meters').to('kilometers'); // 5
-const m = registry.convert(5 as Kilometers, 'kilometers').to('meters'); // 5000
+const km = registry.convert(registry.meters(5000), 'meters').to('kilometers'); // 5
+const m = registry.convert(registry.kilometers(5), 'kilometers').to('meters'); // 5000
 ```
 
 ### Multi-Hop Auto-Composition
@@ -116,24 +155,27 @@ const m = registry.convert(5 as Kilometers, 'kilometers').to('meters'); // 5000
 The registry automatically composes converters via shortest path:
 
 ```typescript
-type Meters = WithUnits<number, 'meters'>;
-type Kilometers = WithUnits<number, 'kilometers'>;
-type Miles = WithUnits<number, 'miles'>;
-
-const registry = createRegistry<'meters' | 'kilometers' | 'miles'>()
-  .registerBidirectional('meters', 'kilometers', {
-    to: (m) => (m / 1000) as Kilometers,
-    from: (km) => (km * 1000) as Meters
+const MetersMetadata = { name: 'meters' as const, type: 'number' as const };
+const KilometersMetadata = { name: 'kilometers' as const, type: 'number' as const };
+const MilesMetadata = { name: 'miles' as const, type: 'number' as const };
+
+type Meters = WithTypedUnits<typeof MetersMetadata>;
+type Kilometers = WithTypedUnits<typeof KilometersMetadata>;
+type Miles = WithTypedUnits<typeof MilesMetadata>;
+
+const registry = createRegistry()
+  .register(MetersMetadata, KilometersMetadata, {
+    to: (m: number) => (m / 1000),
+    from: (km: number) => (km * 1000)
   })
-  .registerBidirectional('kilometers', 'miles', {
-    to: (km) => (km * 0.621371) as Miles,
-    from: (mi) => (mi / 0.621371) as Kilometers
+  .register(KilometersMetadata, MilesMetadata, {
+    to: (km: number) => (km * 0.621371),
+    from: (mi: number) => (mi / 0.621371)
   });
 
 // No direct meters→miles converter registered!
 // Registry auto-composes: meters → kilometers → miles
-const meters: Meters = 5000 as Meters;
-const miles = registry.convert(meters, 'meters').to('miles');
+const miles = registry.convert(registry.meters(5000), 'meters').to('miles');
 console.log(miles); // 3.106855
 ```
 
@@ -165,18 +207,121 @@ const str = iso8601.format(now); // "2026-01-06T12:00:00.000Z"
 const date = iso8601.parse('2026-01-06T12:00:00.000Z');
 ```
 
+### Non-Primitive Types
+
+Beyond primitives, the registry supports enums, classes, records, and tuples
+as unit types. The `type` field in metadata IS the runtime value itself.
+
+#### Enum Units
+
+```typescript
+import { createRegistry } from '@unacy/core';
+import type { WithTypedUnits, TypedMetadata } from '@unacy/core';
+
+enum LogLevel { DEBUG = 0, INFO = 1, WARN = 2, ERROR = 3 }
+
+const LogLevelMeta = { name: 'LogLevel', type: LogLevel } as const;
+type LogLevelUnit = WithTypedUnits<typeof LogLevelMeta>;
+
+const registry = createRegistry()
+  .register(LogLevelMeta, /* ... */);
+```
+
+#### Class Units
+
+```typescript
+class Temperature {
+  constructor(public value: number, public scale: string) {}
+}
+
+const TempMeta = { name: 'Temperature', type: Temperature } as const;
+type TempUnit = WithTypedUnits<typeof TempMeta>;
+```
+
+#### Record Units
+
+```typescript
+const PointSchema = { x: 'number', y: 'number' } as const;
+const PointMeta = { name: 'Point', type: PointSchema } as const;
+type PointUnit = WithTypedUnits<typeof PointMeta>;
+
+// Nested schemas
+const LineMeta = {
+  name: 'Line',
+  type: { start: { x: 'number', y: 'number' }, end: { x: 'number', y: 'number' } }
+} as const;
+```
+
+#### Tuple Units
+
+```typescript
+const RGBSchema = ['number', 'number', 'number'] as const;
+const RGBMeta = { name: 'RGB', type: RGBSchema } as const;
+type RGBUnit = WithTypedUnits<typeof RGBMeta>;
+
+// Optional and rest elements
+const HeaderSchema = ['string', 'number?', '...string'] as const;
+```
+
+#### Runtime Type Guards
+
+```typescript
+import {
+  isEnumMetadata, isClassMetadata,
+  isRecordMetadata, isTupleMetadata,
+  detectMetadataKind
+} from '@unacy/core';
+
+detectMetadataKind(LogLevelMeta);  // 'enum'
+detectMetadataKind(TempMeta);      // 'class'
+detectMetadataKind(PointMeta);     // 'record'
+detectMetadataKind(RGBMeta);       // 'tuple'
+
+if (isEnumMetadata(meta)) {
+  // meta.type is narrowed to EnumType
+}
+```
+
 ## API Reference
 
 ### Types
 
+#### `WithTypedUnits<M extends TypedMetadata<T>>`
+Brand a value with strongly-typed metadata for compile-time unit safety.
+
+```typescript
+const CelsiusMetadata = { name: 'Celsius' as const, type: 'number' as const };
+type Celsius = WithTypedUnits<typeof CelsiusMetadata>;
+const temp: Celsius = tempRegistry.Celsius(25);
+```
+
 #### `WithUnits<T, U>`
-Brand a value with a unit identifier for compile-time safety.
+Legacy: Brand a value with a unit identifier for compile-time safety.
 
 ```typescript
 type Celsius = WithUnits<number, 'Celsius'>;
 const temp: Celsius = 25 as Celsius;
 ```
 
+#### `TypedMetadata<T>`
+Minimal metadata type with name and type information.
+
+```typescript
+type NumericMetadata = TypedMetadata<number>;
+// { name: string; type: 'number' }
+
+type StringMetadata = TypedMetadata<string>;
+// { name: string; type: 'string' }
+
+// Non-primitive: type IS the value itself
+type EnumMetadata = TypedMetadata<typeof LogLevel>;
+// { name: string; type: typeof LogLevel }
+```
+
+#### `SupportedType`
+Union of all types that can be used as a unit base:
+`number | string | boolean | bigint | EnumType | ClassType | RecordSchema | TupleSchema`
+
 #### `WithFormat<T, F>`
 Brand a value with a format identifier for serialization safety.
 
@@ -198,8 +343,8 @@ Pair of converters for two-way transformations.
 
 ```typescript
 const meterKm: BidirectionalConverter<Meters, Kilometers> = {
-  to: (m) => (m / 1000) as Kilometers,
-  from: (km) => (km * 1000) as Meters
+  to: (m: number) => (m / 1000),
+  from: (km: number) => (km * 1000)
 };
 ```
 
@@ -216,14 +361,14 @@ const registry = createRegistry<'A' | 'B' | 'C'>();
 Register a unidirectional converter.
 
 ```typescript
-registry.register('Celsius', 'Fahrenheit', celsiusToFahrenheit);
+registry.register(CelsiusMetadata, FahrenheitMetadata, celsiusToFahrenheit);
 ```
 
-#### `registerBidirectional(from, to, converter)`
+#### `register(from, to, converter)` (bidirectional)
 Register both directions at once.
 
 ```typescript
-registry.registerBidirectional('meters', 'kilometers', meterKm);
+registry.register(MetersMetadata, KilometersMetadata, meterKm);
 ```
 
 #### `convert(value, fromUnit).to(toUnit)`
@@ -243,11 +388,12 @@ const result = registry.convert(value, 'Celsius').to('Fahrenheit');
 
 ## Best Practices
 
-1. **Define unit types at module boundaries** for consistency
+1. **Define metadata as const at module boundaries** for consistency
 2. **Use bidirectional converters** when both directions are needed
 3. **Document precision loss** in converters
 4. **Cache registries** for performance
-5. **Validate with Zod** in parsers
+5. **Use `WithTypedUnits`** for brand-new code; leverage type inference
+6. **Validate with Zod** in parsers
 
 ## Performance
 

package/dist/converters.d.ts

@@ -2,7 +2,7 @@
  * Type-safe converter function signatures
  * @packageDocumentation
  */
-import type { PrimitiveType, Relax as BaseRelax } from './types.js';
+import type { PrimitiveType, Relax as BaseRelax, Unwrap } from './types.js';
 /**
  * Unidirectional converter from one unit to another.
  *
@@ -25,7 +25,7 @@ import type { PrimitiveType, Relax as BaseRelax } from './types.js';
  */
 export type Converter<TInput, TOutput> = (input: TInput) => TOutput;
 export type RelaxConverter<ConverterType> = ConverterType extends Converter<infer A extends PrimitiveType, infer B extends PrimitiveType> ? (input: BaseRelax<A>) => BaseRelax<B> : (input: PrimitiveType) => PrimitiveType;
-export type Relax<T extends PrimitiveType | Converter<any, any> | BidirectionalConverter<any, any>> = T extends PrimitiveType ? BaseRelax<T> : T extends Converter<infer A extends PrimitiveType, infer B extends PrimitiveType> ? RelaxConverter<T> : RelaxBidirectionalConverter<T>;
+export type Relax<T extends PrimitiveType | Converter<any, any> | BidirectionalConverter<any, any>> = T extends PrimitiveType ? BaseRelax<T> : T extends Converter<unknown, unknown> ? RelaxConverter<T> : RelaxBidirectionalConverter<T>;
 /**
  * Bidirectional converter with forward and reverse transformations.
  *
@@ -53,10 +53,34 @@ export type BidirectionalConverter<TInput, TOutput> = {
     from: Converter<TOutput, TInput>;
 };
 export type RelaxBidirectionalConverter<ConverterType> = ConverterType extends BidirectionalConverter<infer A extends PrimitiveType, infer B extends PrimitiveType> ? {
-    to: (input: BaseRelax<A>) => BaseRelax<B>;
-    from: (input: BaseRelax<B>) => BaseRelax<A>;
+    to: (input: BaseRelax<A>) => B;
+    from: (input: BaseRelax<B>) => A;
 } : {
     to: (input: PrimitiveType) => PrimitiveType;
     from: (input: PrimitiveType) => PrimitiveType;
 };
+/**
+ * A converter that accepts the branded input type but returns
+ * unwrapped output. This eliminates the need to cast return values
+ * to branded types inside converter functions, while preserving
+ * full autocompletion on the input parameter.
+ *
+ * Since `Tagged<T, ...> extends T`, strict converters returning branded
+ * types are also assignable to this type.
+ *
+ * @template TInput - Source unit-tagged type
+ * @template TOutput - Destination unit-tagged type
+ */
+export type RelaxedConverter<TInput, TOutput> = (input: TInput) => Unwrap<TOutput>;
+/**
+ * A bidirectional converter with relaxed (unwrapped) output types.
+ * Input remains branded for full autocompletion.
+ *
+ * @template TInput - First unit-tagged type
+ * @template TOutput - Second unit-tagged type
+ */
+export type RelaxedBidirectionalConverter<TInput, TOutput> = {
+    to: RelaxedConverter<TInput, TOutput>;
+    from: RelaxedConverter<TOutput, TInput>;
+};
 //# sourceMappingURL=converters.d.ts.map

package/dist/converters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"converters.d.ts","sourceRoot":"","sources":["../src/converters.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAqB,KAAK,IAAI,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,SAAS,CACnB,MAAM,EACN,OAAO,IACL,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;AAE/B,MAAM,MAAM,cAAc,CAAC,aAAa,IACtC,aAAa,SAAS,SAAS,CAAC,MAAM,CAAC,SAAS,aAAa,EAAE,MAAM,CAAC,SAAS,aAAa,CAAC,GACzF,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,GACrC,CAAC,KAAK,EAAE,aAAa,KAAK,aAAa,CAAC;AAE9C,MAAM,MAAM,KAAK,CACf,CAAC,SAAS,aAAa,GAAG,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,sBAAsB,CAAC,GAAG,EAAE,GAAG,CAAC,IAC9E,CAAC,SAAS,aAAa,GACvB,SAAS,CAAC,CAAC,CAAC,GACZ,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,SAAS,aAAa,EAAE,MAAM,CAAC,SAAS,aAAa,CAAC,GAC/E,cAAc,CAAC,CAAC,CAAC,GACjB,2BAA2B,CAAC,CAAC,CAAC,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,MAAM,sBAAsB,CAChC,MAAM,EACN,OAAO,IACL;IACF,EAAE,EAAE,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,IAAI,EAAE,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,2BAA2B,CAAC,aAAa,IACnD,aAAa,SAAS,sBAAsB,CAAC,MAAM,CAAC,SAAS,aAAa,EAAE,MAAM,CAAC,SAAS,aAAa,CAAC,GACtG;IACE,EAAE,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC;IAC1C,IAAI,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC;CAC7C,GACD;IACE,EAAE,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,aAAa,CAAC;IAC5C,IAAI,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,aAAa,CAAC;CAC/C,CAAC"}
+{"version":3,"file":"converters.d.ts","sourceRoot":"","sources":["../src/converters.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,KAAK,IAAI,SAAS,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAE5E;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,SAAS,CAAC,MAAM,EAAE,OAAO,IAAI,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;AAEpE,MAAM,MAAM,cAAc,CAAC,aAAa,IACtC,aAAa,SAAS,SAAS,CAAC,MAAM,CAAC,SAAS,aAAa,EAAE,MAAM,CAAC,SAAS,aAAa,CAAC,GACzF,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,GACrC,CAAC,KAAK,EAAE,aAAa,KAAK,aAAa,CAAC;AAE9C,MAAM,MAAM,KAAK,CACf,CAAC,SAAS,aAAa,GAAG,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,sBAAsB,CAAC,GAAG,EAAE,GAAG,CAAC,IAC9E,CAAC,SAAS,aAAa,GACvB,SAAS,CAAC,CAAC,CAAC,GACZ,CAAC,SAAS,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,GACnC,cAAc,CAAC,CAAC,CAAC,GACjB,2BAA2B,CAAC,CAAC,CAAC,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,MAAM,sBAAsB,CAAC,MAAM,EAAE,OAAO,IAAI;IACpD,EAAE,EAAE,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,IAAI,EAAE,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,2BAA2B,CAAC,aAAa,IACnD,aAAa,SAAS,sBAAsB,CAC1C,MAAM,CAAC,SAAS,aAAa,EAC7B,MAAM,CAAC,SAAS,aAAa,CAC9B,GACG;IACE,EAAE,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IAC/B,IAAI,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;CAClC,GACD;IACE,EAAE,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,aAAa,CAAC;IAC5C,IAAI,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,aAAa,CAAC;CAC/C,CAAC;AAER;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,gBAAgB,CAAC,MAAM,EAAE,OAAO,IAAI,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,OAAO,CAAC,CAAC;AAEnF;;;;;;GAMG;AACH,MAAM,MAAM,6BAA6B,CAAC,MAAM,EAAE,OAAO,IAAI;IAC3D,EAAE,EAAE,gBAAgB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtC,IAAI,EAAE,gBAAgB,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;CACzC,CAAC"}

package/dist/errors.js.map

@@ -1 +1 @@
-{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,OAAO,UAAW,SAAQ,KAAK;IACnC,YAAY,OAAe,EAAE;QAC3B,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC;QAEzB,wDAAwD;QACxD,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,IAAI,MAAM,CAAC,SAAS,CAAC,CAAC;IAAA,CACnD;CACF;AAED;;GAEG;AACH,MAAM,OAAO,UAAW,SAAQ,UAAU;IACxB,IAAI,CAAgB;IAEpC,YAAY,IAAmB,EAAE;QAC/B,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,OAAK,CAAC,CAAC;QAC7C,KAAK,CAAC,sCAAsC,OAAO,EAAE,CAAC,CAAC;QACvD,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC;QACzB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IAAA,CAClB;CACF;AAED;;GAEG;AACH,MAAM,OAAO,aAAc,SAAQ,UAAU;IAC3B,IAAI,CAAc;IAClB,EAAE,CAAc;IAChB,QAAQ,CAAS;IAEjC,YAAY,IAAiB,EAAE,EAAe,EAAE,QAAgB,EAAE;QAChE,KAAK,CACH,+BAA+B,QAAQ,kCAAkC,MAAM,CAAC,IAAI,CAAC,OAAO,MAAM,CAAC,EAAE,CAAC,EAAE,CACzG,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC;QAC5B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;QACb,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAAA,CAC1B;CACF;AAED;;GAEG;AACH,MAAM,OAAO,eAAgB,SAAQ,UAAU;IAC7B,IAAI,CAAc;IAClB,EAAE,CAAc;IAEhC,YAAY,IAAiB,EAAE,EAAe,EAAE,MAAe,EAAE;QAC/D,MAAM,SAAS,GAAG,MAAM,CAAC,CAAC,CAAC,KAAK,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC9C,KAAK,CAAC,uBAAuB,MAAM,CAAC,IAAI,CAAC,OAAO,MAAM,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,CAAC;QAC1E,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;QAC9B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;IAAA,CACd;CACF;AAED;;GAEG;AACH,MAAM,OAAO,UAAW,SAAQ,UAAU;IACxB,MAAM,CAAS;IACf,KAAK,CAAS;IACd,MAAM,CAAS;IAE/B,YAAY,MAAc,EAAE,KAAa,EAAE,MAAc,EAAE;QACzD,MAAM,cAAc,GAAG,KAAK,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC;QAC9E,MAAM,YAAY,GAAG,KAAK,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,cAAc,CAAC;QAE1D,KAAK,CAAC,iBAAiB,YAAY,QAAQ,MAAM,KAAK,MAAM,EAAE,CAAC,CAAC;QAChE,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC;QACzB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IAAA,CACtB;CACF"}
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,OAAO,UAAW,SAAQ,KAAK;IACnC,YAAY,OAAe,EAAE;QAC3B,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC;QAEzB,wDAAwD;QACxD,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,IAAI,MAAM,CAAC,SAAS,CAAC,CAAC;IAAA,CACnD;CACF;AAED;;GAEG;AACH,MAAM,OAAO,UAAW,SAAQ,UAAU;IACxB,IAAI,CAAgB;IAEpC,YAAY,IAAmB,EAAE;QAC/B,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC7C,KAAK,CAAC,sCAAsC,OAAO,EAAE,CAAC,CAAC;QACvD,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC;QACzB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IAAA,CAClB;CACF;AAED;;GAEG;AACH,MAAM,OAAO,aAAc,SAAQ,UAAU;IAC3B,IAAI,CAAc;IAClB,EAAE,CAAc;IAChB,QAAQ,CAAS;IAEjC,YAAY,IAAiB,EAAE,EAAe,EAAE,QAAgB,EAAE;QAChE,KAAK,CACH,+BAA+B,QAAQ,kCAAkC,MAAM,CAAC,IAAI,CAAC,OAAO,MAAM,CAAC,EAAE,CAAC,EAAE,CACzG,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC;QAC5B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;QACb,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAAA,CAC1B;CACF;AAED;;GAEG;AACH,MAAM,OAAO,eAAgB,SAAQ,UAAU;IAC7B,IAAI,CAAc;IAClB,EAAE,CAAc;IAEhC,YAAY,IAAiB,EAAE,EAAe,EAAE,MAAe,EAAE;QAC/D,MAAM,SAAS,GAAG,MAAM,CAAC,CAAC,CAAC,KAAK,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC9C,KAAK,CAAC,uBAAuB,MAAM,CAAC,IAAI,CAAC,OAAO,MAAM,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,CAAC;QAC1E,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;QAC9B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;IAAA,CACd;CACF;AAED;;GAEG;AACH,MAAM,OAAO,UAAW,SAAQ,UAAU;IACxB,MAAM,CAAS;IACf,KAAK,CAAS;IACd,MAAM,CAAS;IAE/B,YAAY,MAAc,EAAE,KAAa,EAAE,MAAc,EAAE;QACzD,MAAM,cAAc,GAAG,KAAK,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC;QAC9E,MAAM,YAAY,GAAG,KAAK,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,cAAc,CAAC;QAE1D,KAAK,CAAC,iBAAiB,YAAY,QAAQ,MAAM,KAAK,MAAM,EAAE,CAAC,CAAC;QAChE,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC;QACzB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IAAA,CACtB;CACF"}

package/dist/index.d.ts

@@ -2,11 +2,12 @@
  * Unacy Core - Type-safe unit and format conversion library
  * @packageDocumentation
  */
-export type { WithUnits, WithFormat, UnitMetadata, Relax, PrimitiveType, ToPrimitiveType, ToPrimitiveTypeName } from './types.js';
-export type { Converter, BidirectionalConverter } from './converters.js';
+export type { WithUnits, WithTypedUnits, WithFormat, BaseMetadata, TypedMetadata, UnitMetadata, Relax, PrimitiveType, SupportedType, EnumType, ClassType, RecordSchema, TupleSchema, ToPrimitiveTypeName } from './types.js';
+export type { Converter, BidirectionalConverter, RelaxedConverter, RelaxedBidirectionalConverter } from './converters.js';
 export type { Formatter, Parser, FormatterParser } from './formatters.js';
-export type { ConverterRegistry, ConverterMap, UnitAccessor } from './registry.js';
+export type { UnitRegistry, UnitMap, UnitAccessor } from './registry.js';
 export { createRegistry } from './registry.js';
 export { UnacyError, CycleError, MaxDepthError, ConversionError, ParseError } from './errors.js';
-export { createParserWithSchema } from './utils/validation.js';
+export { createParserWithSchema, validateEnum, validateClass, validateRecordSchema, validateTupleSchema, isEnumMetadata, isClassMetadata, isRecordMetadata, isTupleMetadata, detectMetadataKind } from './utils/validation.js';
+export type { PrimitiveTypeFromName, InferFromRecordSchema, InferFromTupleSchema } from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,YAAY,EAAE,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAGlI,YAAY,EAAE,SAAS,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAGzE,YAAY,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAG1E,YAAY,EAAE,iBAAiB,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACnF,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAG/C,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,aAAa,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAGjG,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,YAAY,EACV,SAAS,EACT,cAAc,EACd,UAAU,EACV,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,KAAK,EACL,aAAa,EACb,aAAa,EACb,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,WAAW,EACX,mBAAmB,EACpB,MAAM,YAAY,CAAC;AAGpB,YAAY,EACV,SAAS,EACT,sBAAsB,EACtB,gBAAgB,EAChB,6BAA6B,EAC9B,MAAM,iBAAiB,CAAC;AAGzB,YAAY,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAG1E,YAAY,EAAE,YAAY,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACzE,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAG/C,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,aAAa,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAGjG,OAAO,EACL,sBAAsB,EACtB,YAAY,EACZ,aAAa,EACb,oBAAoB,EACpB,mBAAmB,EACnB,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,eAAe,EACf,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAG/B,YAAY,EACV,qBAAqB,EACrB,qBAAqB,EACrB,oBAAoB,EACrB,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -6,5 +6,5 @@ export { createRegistry } from './registry.js';
 // Errors
 export { UnacyError, CycleError, MaxDepthError, ConversionError, ParseError } from './errors.js';
 // Utilities
-export { createParserWithSchema } from './utils/validation.js';
+export { createParserWithSchema, validateEnum, validateClass, validateRecordSchema, validateTupleSchema, isEnumMetadata, isClassMetadata, isRecordMetadata, isTupleMetadata, detectMetadataKind } from './utils/validation.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAaH,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAE/C,SAAS;AACT,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,aAAa,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEjG,YAAY;AACZ,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAiCH,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAE/C,SAAS;AACT,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,aAAa,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEjG,YAAY;AACZ,OAAO,EACL,sBAAsB,EACtB,YAAY,EACZ,aAAa,EACb,oBAAoB,EACpB,mBAAmB,EACnB,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,eAAe,EACf,kBAAkB,EACnB,MAAM,uBAAuB,CAAC"}

package/dist/registry.d.ts

@@ -2,14 +2,14 @@
  * Converter registry with auto-composition via BFS
  * @packageDocumentation
  */
-import type { Converter, BidirectionalConverter, Relax } from './converters.js';
-import type { UnitsFor, WithUnits, UnitMetadata, PrimitiveType, Relax as RelaxUnits } from './types.js';
+import type { Converter, RelaxedConverter, RelaxedBidirectionalConverter } from './converters.js';
+import type { UnitsFor, WithUnits, TypedMetadata, NameFor, WithTypedUnits, UnitsOf, BaseMetadata, SupportedType, InferCallableArgs, Relax as RelaxUnits } from './types.js';
 /**
  * Represents a conversion edge from one unit to another
  * Edges store the unit names as strings, but the type system ensures
  * they correspond to valid WithUnits types
  */
-type Edge<From extends WithUnits = WithUnits<PrimitiveType, string>, To extends WithUnits = WithUnits<PrimitiveType, string>> = readonly [From, To];
+type Edge<From extends WithTypedUnits<any> = WithTypedUnits<TypedMetadata<SupportedType>>, To extends WithTypedUnits<any> = WithTypedUnits<TypedMetadata<SupportedType>>> = readonly [From, To];
 /**
  * Extract all unique 'from' units from a list of edges
  */
@@ -17,79 +17,77 @@ type FromUnits<Edges extends readonly Edge[]> = Edges[number][0];
 /**
  * Extract all 'to' units for a specific 'from' unit string
  */
-type ToUnitsFor<Edges extends readonly Edge[], FromUnit extends WithUnits> = Extract<Edges[number], readonly [FromUnit, any]>[1];
+type ToUnitsFor<Edges extends readonly Edge[], FromUnit extends WithTypedUnits<any>> = Extract<Edges[number], readonly [FromUnit, any]>[1];
+/**
+ * Extract metadata type from a WithUnits type
+ */
 /**
  * Type for unit accessor with metadata and conversion methods
  * Can be called as a function to create branded unit values
  */
-export type UnitAccessor<From extends WithUnits<PrimitiveType, FromUnits>, Edges extends readonly Edge[], FromUnits extends string> = {
+export type UnitAccessor<From extends WithTypedUnits<TypedMetadata<SupportedType>>, Edges extends readonly Edge[]> = {
     /**
-     * Create a branded value with this unit
-     * @param value - The numeric value to brand
+     * Create a branded value with this unit.
+     * For tuples, pass members as individual arguments.
+     * For classes, pass constructor parameters directly.
+     * @param args - The value(s) to brand
      * @returns The value branded with this unit type
      */
-    (value: number): From;
+    (...args: InferCallableArgs<From>): From;
     to: {
-        [To in ToUnitsFor<Edges, From> as UnitsFor<To>]: (value: RelaxUnits<From>) => WithUnits<PrimitiveType, To>;
+        [To in ToUnitsFor<Edges, From> as UnitsFor<To>]: (value: RelaxUnits<From>) => To;
     };
     /**
      * Add metadata to this unit
      */
-    addMetadata(metadata: UnitMetadata): ConverterRegistry<Edges extends readonly (infer E)[] ? E[] : never> & ConverterMap<Edges>;
+    addMetadata<NewM extends Record<string, unknown>>(metadata: NewM): UnitRegistry<Edges extends readonly (infer E)[] ? E[] : never> & UnitMap<Edges>;
     /**
      * Register a converter from this unit to another unit
      */
-    register<To extends WithUnits<PrimitiveType, ToUnits>, ToUnits extends string>(to: ToUnits, converter: Relax<Converter<From, To>>): ConverterRegistry<[...Edges, Edge<From, To>]> & ConverterMap<[...Edges, Edge<From, To>]>;
-    register<To extends WithUnits<PrimitiveType, ToUnits>, ToUnits extends string>(to: ToUnits, converter: Relax<BidirectionalConverter<From, To>>): ConverterRegistry<[...Edges, Edge<From, To>, Edge<To, From>]> & ConverterMap<[...Edges, Edge<From, To>, Edge<To, From>]>;
-} & {
-    [K: string]: unknown;
-};
+    register<To extends WithTypedUnits<ToMeta>, ToMeta extends TypedMetadata<SupportedType>>(to: UnitsFor<To> | ToMeta, converter: RelaxedConverter<From, To>): UnitRegistry<[...Edges, Edge<From, To>]> & UnitMap<[...Edges, Edge<From, To>]>;
+    register<To extends WithTypedUnits<ToMeta>, ToMeta extends TypedMetadata<SupportedType>>(to: UnitsFor<To> | ToMeta, converter: RelaxedBidirectionalConverter<From, To>): UnitRegistry<[...Edges, Edge<From, To>, Edge<To, From>]> & UnitMap<[...Edges, Edge<From, To>, Edge<To, From>]>;
+} & UnitsOf<From>;
 /**
  * Type for unit-based conversion accessors
  * Provides the shape: registry.Celsius.to.Fahrenheit(value)
  * Only allows conversions that have been registered
  */
-export type ConverterMap<Edges extends readonly Edge[]> = {
-    [FU in FromUnits<Edges> as UnitsFor<FU>]: UnitAccessor<WithUnits<PrimitiveType, UnitsFor<FU>>, Edges, UnitsFor<FromUnits<Edges>>>;
+export type UnitMap<Edges extends readonly Edge[]> = {
+    [FU in FromUnits<Edges> as UnitsFor<FU>]: UnitAccessor<FU, Edges>;
 };
 /**
  * Registry for managing and composing unit converters
  */
-export interface ConverterRegistry<Edges extends Edge[] = []> {
+export interface UnitRegistry<Edges extends Edge[] = []> {
+    register<From extends WithTypedUnits<FromMeta>, FromMeta extends TypedMetadata<SupportedType>>(unit: FromMeta): this & {
+        [K in NameFor<From>]: UnitAccessor<From, Edges>;
+    };
     /**
      * Register a unidirectional converter
      *
-     * @param from - Source unit
-     * @param to - Destination unit
-     * @param converter - Converter function
+     * @param from - Source unit (string name or metadata object)
+     * @param to - Destination unit (string name or metadata object)
+     * @param converter - Converter function (input is branded, output can be plain or branded)
      * @returns New registry instance with the converter registered
      */
-    register<From extends WithUnits<PrimitiveType, UF>, To extends WithUnits<PrimitiveType, UY>, UF extends string, UY extends string>(from: UF, to: UY, converter: Converter<From, RelaxUnits<To>>): ConverterRegistry<[...Edges, Edge<From, To>]> & ConverterMap<[...Edges, Edge<From, To>]>;
+    register<From extends WithTypedUnits<FromMeta>, To extends WithTypedUnits<ToMeta>, FromMeta extends TypedMetadata<SupportedType>, ToMeta extends TypedMetadata<SupportedType>>(from: UnitsFor<From> | FromMeta, to: UnitsFor<To> | ToMeta, converter: RelaxedConverter<From, To>): UnitRegistry<[...Edges, Edge<From, To>]> & UnitMap<[...Edges, Edge<From, To>]>;
     /**
      * Register a bidirectional converter (both directions)
      *
-     * @param from - First unit
-     * @param to - Second unit
-     * @param converter - Bidirectional converter object
+     * @param from - First unit (string name or metadata object)
+     * @param to - Second unit (string name or metadata object)
+     * @param converter - Bidirectional converter object (input branded, output can be plain or branded)
      * @returns New registry instance with both converters registered
      */
-    register<From extends WithUnits<PrimitiveType, UF>, To extends WithUnits<PrimitiveType, UY>, UF extends string, UY extends string>(from: UF, to: UY, converter: BidirectionalConverter<RelaxUnits<From>, RelaxUnits<To>>): ConverterRegistry<[
-        ...Edges,
-        Edge<From, To>,
-        Edge<To, From>
-    ]> & ConverterMap<[
-        ...Edges,
-        Edge<From, To>,
-        Edge<To, From>
-    ]>;
+    register<From extends WithTypedUnits<FromMeta>, To extends WithTypedUnits<ToMeta>, FromMeta extends TypedMetadata<SupportedType>, ToMeta extends TypedMetadata<SupportedType>>(from: UnitsFor<From> | FromMeta, to: UnitsFor<To> | ToMeta, converter: RelaxedBidirectionalConverter<From, To>): UnitRegistry<[...Edges, Edge<From, To>, Edge<To, From>]> & UnitMap<[...Edges, Edge<From, To>, Edge<To, From>]>;
     /**
      * Explicitly allow a conversion path in the type system (for multi-hop conversions)
      *
      * This method verifies that a conversion path exists at runtime (via BFS) and adds it
      * to the type system so it can be used with type-safe accessor syntax.
      *
-     * @param from - Source unit string
-     * @param to - Destination unit string
+     * @param from - Source unit (string name or metadata object)
+     * @param to - Destination unit (string name or metadata object)
      * @returns New registry instance with the conversion path enabled in types
      * @throws ConversionError if no path exists between the units
      *
@@ -104,7 +102,7 @@ export interface ConverterRegistry<Edges extends Edge[] = []> {
      * const f = registry.Celsius.to.Fahrenheit(temp);
      * ```
      */
-    allow<From extends WithUnits<PrimitiveType, UF>, To extends WithUnits<PrimitiveType, UY>, UF extends string, UY extends string>(from: UF, to: UY): ConverterRegistry<[...Edges, Edge<From, To>]> & ConverterMap<[...Edges, Edge<From, To>]>;
+    allow<From extends WithTypedUnits<FromMeta>, To extends WithTypedUnits<ToMeta>, FromMeta extends TypedMetadata<SupportedType>, ToMeta extends TypedMetadata<SupportedType>>(from: UnitsFor<From> | FromMeta, to: UnitsFor<To> | ToMeta): UnitRegistry<[...Edges, Edge<From, To>]> & UnitMap<[...Edges, Edge<From, To>]>;
     /**
      * Get a converter (direct or composed via BFS)
      *
@@ -112,7 +110,7 @@ export interface ConverterRegistry<Edges extends Edge[] = []> {
      * @param to - Destination unit
      * @returns Converter function, or undefined if no path exists
      */
-    getConverter<From extends WithUnits<PrimitiveType, string>, To extends WithUnits<PrimitiveType, string>>(from: UnitsFor<From>, to: UnitsFor<To>): Converter<From, To> | undefined;
+    getConverter<From extends WithUnits<SupportedType, BaseMetadata>, To extends WithUnits<SupportedType, BaseMetadata>>(from: UnitsFor<From>, to: UnitsFor<To>): Converter<From, To> | undefined;
     /**
      * Convert a value using fluent API
      *
@@ -120,8 +118,8 @@ export interface ConverterRegistry<Edges extends Edge[] = []> {
      * @param fromUnit - Source unit
      * @returns Object with to() method for conversion
      */
-    convert<From extends WithUnits<PrimitiveType, string>>(value: From, fromUnit: UnitsFor<From>): {
-        to<To extends WithUnits<PrimitiveType, string>>(unit: UnitsFor<To>): To;
+    convert<From extends WithUnits<SupportedType, BaseMetadata>>(value: From, fromUnit: UnitsFor<From>): {
+        to<To extends WithUnits<SupportedType, BaseMetadata>>(unit: UnitsFor<To>): To;
     };
 }
 /**
@@ -150,6 +148,6 @@ export interface ConverterRegistry<Edges extends Edge[] = []> {
  * console.log(fahrenheit); // 77
  * ```
  */
-export declare function createRegistry<Edges extends readonly Edge[] = []>(): ConverterRegistry<Edges extends readonly (infer E)[] ? E[] : never> & ConverterMap<Edges>;
+export declare function createRegistry<Edges extends readonly Edge[] = []>(): UnitRegistry<Edges extends readonly (infer E)[] ? E[] : never> & UnitMap<Edges>;
 export {};
 //# sourceMappingURL=registry.d.ts.map