Inferencing unknown Type Improvement

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codelytv/primitives-type",
-  "version": "1.0.6",
+  "version": "1.1.0",
   "description": "Type entity primitives from value objects",
   "keywords": [
     "typescript",

src/Primitives.ts

@@ -17,8 +17,10 @@ type ValueObjectValue<T> = T extends PrimitiveTypes
   ? U[]
   : T extends Array<infer U>
   ? Array<ValueObjectValue<U>>
-  : T extends { [K in keyof Properties<T>]: infer U }
+  : T extends { [K in keyof Properties<T>]: unknown }
   ? { [K in keyof Properties<T>]: ValueObjectValue<Properties<T>[K]> }
+  : T extends unknown
+  ? T
   : never;
 
 export type Primitives<T> = {

tests/Metadata.ts

@@ -0,0 +1,11 @@
+import { Primitives } from "../src";
+
+export class Metadata {
+  constructor(public readonly data: Record<string, unknown>) {}
+
+  toPrimitives(): Primitives<Metadata> {
+    return {
+      data: this.data,
+    };
+  }
+}

tests/Primitives.test.ts

@@ -4,6 +4,7 @@ import { Primitives } from "../src";
 import { Course } from "./Course";
 import { DeliveryInfo } from "./DeliveryInfo";
 import { Learner } from "./Learner";
+import { Metadata } from "./Metadata";
 import { Product } from "./Product";
 import { User } from "./User";
 import { Video } from "./Video";
@@ -79,4 +80,14 @@ describe("Primitives", () => {
 
     expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
   });
+
+  it("should infer properties with unknown type", () => {
+    type actualPrimitives = Primitives<Metadata>;
+
+    type expectedPrimitives = {
+      readonly data: Record<string, unknown>;
+    };
+
+    expectTypeOf<actualPrimitives>().toEqualTypeOf<expectedPrimitives>();
+  });
 });