@themeparks/typelib 1.0.5 → 1.1.0

package/README.md

@@ -6,6 +6,10 @@ TypeScript definition system for ThemeParks.wiki
 
 `@themeparks/typelib` is a TypeScript types package that generates types from JSON schemas and provides runtime type validation. It is designed for the internal ThemeParks.wiki systems and generating client libraries. You likely do not want to interact with this library directly.
 
+## Requirements
+
+- Node.js >= 24.0.0
+
 ## Installation
 
 ```bash
@@ -17,30 +21,32 @@ npm install @themeparks/typelib
 ### Using pre-built types
 
 ```typescript
-import { V1RootResponse, registerTypeSchema, getTypeSchema } from '@themeparks/typelib';
+import { Entity, LiveData, EntitySchedule } from '@themeparks/typelib';
 
 // Use generated types
-const response: V1RootResponse = {
-    success: true,
-    message: "API is running", 
-    version: "1.0.0"
+const entity: Entity = {
+    id: 'park-123',
+    name: 'Example Park',
+    entityType: 'PARK',
+    timezone: 'America/New_York',
 };
 
-// Access runtime schemas
-const schema = getTypeSchema('V1RootResponse');
-console.log(schema); // Returns the JSON schema for validation
+const liveData: LiveData = {
+    id: 'attraction-456',
+    status: 'OPERATING',
+};
 ```
 
-### Generating types from custom schemas
+### Enums and conversion functions
 
 ```typescript
-import { generateTypes } from '@themeparks/typelib/generate';
-import { resolve } from 'path';
+import { EntityTypeEnum, StringToEntityType } from '@themeparks/typelib';
 
-await generateTypes({
-    schemaDirs: [resolve('./typesrc')],
-    outputDir: './src/types'
-});
+// Native TypeScript enums
+const type = EntityTypeEnum.ATTRACTION;
+
+// Convert strings to enum values
+const parsed = StringToEntityType('attraction');
 ```
 
 ### Runtime Schema Registry
@@ -55,38 +61,69 @@ Retrieve a registered schema.
 import { registerTypeSchema, getTypeSchema } from '@themeparks/typelib';
 
 // Schemas are automatically registered when importing types
-import { V1RootResponse } from '@themeparks/typelib';
+import { Entity } from '@themeparks/typelib';
 
 // Access the schema at runtime
-const schema = getTypeSchema('V1RootResponse');
+const schema = getTypeSchema('Entity');
+```
+
+### Deterministic Object Hashing
+
+```typescript
+import { hashObject } from '@themeparks/typelib/hash';
+
+// Returns a 64-character hex SHA-256 hash
+const hash = hashObject({ name: 'Example', id: 123 });
+
+// Deterministic — key order doesn't matter
+hashObject({ b: 2, a: 1 }) === hashObject({ a: 1, b: 2 }); // true
+```
+
+### Generating types from schemas
+
+```typescript
+import { generateTypes } from '@themeparks/typelib/generate';
+import { resolve } from 'path';
+
+await generateTypes({
+    schemaDirs: [resolve('./typesrc')],
+    outputDir: './src/types'
+});
 ```
 
 ## Schema Format
 
-Schemas follow JSON Schema Draft 7 specification:
+Schemas follow JSON Schema Draft 7 specification. Each file defines top-level types as properties:
 
 ```json
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
-  "title": "MyTypes",
+  "title": "Entities",
   "type": "object",
   "properties": {
-    "MyType": {
+    "LanguageCode": {
+      "type": "string",
+      "enum": ["en", "en-gb", "de", "fr", "es", "ja", "ko", "zh"],
+      "description": "Supported language codes for ThemeParks.wiki"
+    },
+    "Entity": {
       "type": "object",
-      "required": ["id", "name"],
+      "required": ["id", "name", "entityType", "timezone"],
       "properties": {
         "id": {
           "type": "string",
-          "description": "Unique identifier"
+          "description": "Unique identifier for this entity"
         },
         "name": {
-          "type": "string", 
-          "description": "Display name"
+          "description": "Entity name",
+          "$ref": "#/properties/LocalisedString"
         },
-        "status": {
+        "entityType": {
+          "$ref": "#/properties/EntityType"
+        },
+        "timezone": {
           "type": "string",
-          "enum": ["active", "inactive", "pending"],
-          "description": "Status of the item"
+          "description": "Timezone of this entity (IANA)"
         }
       }
     }
@@ -94,38 +131,29 @@ Schemas follow JSON Schema Draft 7 specification:
 }
 ```
 
+Types can reference each other within the same file using `$ref`, and the generator resolves cross-file references automatically.
+
 ## Generated Output
 
 The generator creates:
-- **Type definitions** - TypeScript interfaces and types
-- **Enum types** - Native TypeScript enums with conversion functions
-- **Runtime registration** - Automatic schema registration
-- **Re-export index** - Convenient imports from a single file
+- **Type definitions** — TypeScript interfaces and types
+- **Enum types** — Native TypeScript enums with `StringTo*` conversion functions
+- **Runtime registration** — Automatic schema registration via `registerTypeSchema`
+- **Re-export index** — Convenient imports from a single file
 
-Example generated output:
-```typescript
-// Generated: my-types.types.ts
-
-export interface MyType {
-    /** Unique identifier */
-    id: string;
-    /** Display name */
-    name: string;
-    /** Status of the item */
-    status?: 'active' | 'inactive' | 'pending';
-}
+## Package Exports
 
-export enum StatusEnum {
-    "active" = 'active',
-    "inactive" = 'inactive', 
-    "pending" = 'pending'
-}
+- `@themeparks/typelib` — Types, enums, and schema registry functions
+- `@themeparks/typelib/generate` — Type generation from JSON schemas
+- `@themeparks/typelib/hash` — Deterministic SHA-256 object hashing
 
-// Runtime schema registration
-registerTypeSchema("MyType", { /* schema */ });
-```
+## Publishing
 
-## Package Exports
+Builds and publishes to npm automatically via `prepublishOnly`:
+
+```bash
+# Bump version in package.json, then:
+npm publish --access public
+```
 
-- `@themeparks/typelib` - Main package with types and registry functions
-- `@themeparks/typelib/generate` - Type generation functionality
+This runs `npm run build` (which regenerates types from schemas, then compiles TypeScript) before publishing. The published package includes `dist/`, `typesrc/`, and `src/`.

package/dist/__tests__/hash.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=hash.test.d.ts.map

package/dist/__tests__/hash.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/hash.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/hash.test.js

@@ -0,0 +1,207 @@
+import { describe, it, expect } from 'vitest';
+import { hashObject } from '../hash.js';
+// ── Helper ─────────────────────────────────────────────────────────────────
+/** Assert that two values hash the same */
+function same(a, b) {
+    expect(hashObject(a)).toBe(hashObject(b));
+}
+/** Assert that two values hash differently */
+function different(a, b) {
+    expect(hashObject(a)).not.toBe(hashObject(b));
+}
+/** Assert that hashObject throws a TypeError with a message matching the pattern */
+function throwsTypeError(value, pattern) {
+    expect(() => hashObject(value)).toThrow(TypeError);
+    expect(() => hashObject(value)).toThrow(pattern);
+}
+// ── Output format ──────────────────────────────────────────────────────────
+describe('output format', () => {
+    it('returns a 64-character lowercase hex string', () => {
+        expect(hashObject({ x: 1 })).toMatch(/^[0-9a-f]{64}$/);
+    });
+    it('is deterministic — same input always produces same output', () => {
+        const obj = { a: 1, b: [2, 3], c: { d: 'hello' } };
+        expect(hashObject(obj)).toBe(hashObject(obj));
+        expect(hashObject(obj)).toBe(hashObject({ a: 1, b: [2, 3], c: { d: 'hello' } }));
+    });
+});
+// ── Supported types ────────────────────────────────────────────────────────
+describe('supported scalar types', () => {
+    it('hashes null', () => {
+        const h = hashObject(null);
+        expect(h).toMatch(/^[0-9a-f]{64}$/);
+    });
+    it('hashes strings', () => {
+        different('hello', 'world');
+        same('hello', 'hello');
+    });
+    it('hashes numbers', () => {
+        different(1, 2);
+        same(42, 42);
+    });
+    it('hashes booleans', () => {
+        different(true, false);
+        same(true, true);
+    });
+    it('differentiates between types with similar string forms', () => {
+        different(null, 'null');
+        different(0, false);
+        different(0, '0');
+        different(false, 'false');
+        different(1, '1');
+        different(null, ''); // null is fine; just checking null != ''
+    });
+    it('differentiates NaN from null — NaN throws', () => {
+        expect(() => hashObject(NaN)).toThrow(TypeError);
+        // null should still work fine
+        expect(() => hashObject(null)).not.toThrow();
+    });
+});
+describe('supported object types', () => {
+    it('hashes empty object', () => {
+        const h = hashObject({});
+        expect(h).toMatch(/^[0-9a-f]{64}$/);
+    });
+    it('hashes empty array', () => {
+        different([], {});
+        expect(hashObject([])).toMatch(/^[0-9a-f]{64}$/);
+    });
+    it('hashes plain objects', () => {
+        same({ a: 1 }, { a: 1 });
+        different({ a: 1 }, { a: 2 });
+        different({ a: 1 }, { b: 1 });
+    });
+    it('hashes arrays (order is preserved)', () => {
+        same([1, 2, 3], [1, 2, 3]);
+        different([1, 2, 3], [3, 2, 1]);
+    });
+    it('hashes nested objects', () => {
+        same({ a: { b: { c: 42 } } }, { a: { b: { c: 42 } } });
+        different({ a: { b: 1 } }, { a: { b: 2 } });
+    });
+    it('hashes mixed nested structures', () => {
+        same({ a: [1, { b: 2 }] }, { a: [1, { b: 2 }] });
+        different({ a: [1, { b: 2 }] }, { a: [1, { b: 3 }] });
+    });
+    it('allows the same object reference in sibling array positions', () => {
+        const shared = { x: 1 };
+        expect(() => hashObject([shared, shared])).not.toThrow();
+        same([shared, shared], [{ x: 1 }, { x: 1 }]);
+    });
+});
+// ── Key ordering ───────────────────────────────────────────────────────────
+describe('key ordering', () => {
+    it('produces the same hash regardless of key insertion order (top level)', () => {
+        same({ a: 1, b: 2 }, { b: 2, a: 1 });
+    });
+    it('produces the same hash for deeply nested objects with different key order', () => {
+        same({ x: { c: 3, a: 1, b: 2 } }, { x: { a: 1, b: 2, c: 3 } });
+    });
+    it('produces the same hash for objects inside arrays with different key order', () => {
+        same([{ z: 26, a: 1 }, { m: 13, b: 2 }], [{ a: 1, z: 26 }, { b: 2, m: 13 }]);
+    });
+    it('distinguishes objects with the same keys but different values', () => {
+        different({ a: 1, b: 2 }, { a: 2, b: 1 });
+    });
+});
+// ── Unsupported types — must throw TypeError ───────────────────────────────
+describe('unsupported types throw TypeError', () => {
+    it('throws on undefined (top-level)', () => {
+        throwsTypeError(undefined, /undefined/);
+    });
+    it('throws on undefined inside an object value', () => {
+        throwsTypeError({ a: undefined }, /undefined/);
+    });
+    it('throws on undefined inside a nested object', () => {
+        throwsTypeError({ a: { b: undefined } }, /undefined/);
+    });
+    it('throws on undefined inside an array', () => {
+        throwsTypeError([1, undefined, 3], /undefined/);
+    });
+    it('throws on Date', () => {
+        throwsTypeError(new Date(), /Date/);
+    });
+    it('throws on Date inside an object', () => {
+        throwsTypeError({ created: new Date() }, /Date/);
+    });
+    it('throws on Map', () => {
+        throwsTypeError(new Map([['a', 1]]), /Map/);
+    });
+    it('throws on Map inside an object', () => {
+        throwsTypeError({ data: new Map() }, /Map/);
+    });
+    it('throws on Set', () => {
+        throwsTypeError(new Set([1, 2, 3]), /Set/);
+    });
+    it('throws on Set inside an object', () => {
+        throwsTypeError({ tags: new Set(['a', 'b']) }, /Set/);
+    });
+    it('throws on Buffer', () => {
+        throwsTypeError(Buffer.from('hello'), /TypedArray|Buffer/);
+    });
+    it('throws on Uint8Array', () => {
+        throwsTypeError(new Uint8Array([1, 2, 3]), /TypedArray|Buffer/);
+    });
+    it('throws on Int32Array', () => {
+        throwsTypeError(new Int32Array([1, 2, 3]), /TypedArray|Buffer/);
+    });
+    it('throws on Float64Array', () => {
+        throwsTypeError(new Float64Array([1.0, 2.0]), /TypedArray|Buffer/);
+    });
+    it('throws on function', () => {
+        throwsTypeError(() => 42, /function/);
+    });
+    it('throws on function inside an object', () => {
+        throwsTypeError({ fn: () => { } }, /function/);
+    });
+    it('throws on BigInt', () => {
+        throwsTypeError(BigInt(9007199254740993), /BigInt/);
+    });
+    it('throws on BigInt inside an object', () => {
+        throwsTypeError({ id: BigInt(1) }, /BigInt/);
+    });
+    it('throws on Symbol', () => {
+        throwsTypeError(Symbol('test'), /Symbol/);
+    });
+    it('throws on circular reference (object)', () => {
+        const obj = { a: 1 };
+        obj.self = obj;
+        throwsTypeError(obj, /circular/);
+    });
+    it('throws on circular reference (array)', () => {
+        const arr = [1, 2];
+        arr.push(arr);
+        throwsTypeError(arr, /circular/);
+    });
+    it('throws on circular reference (nested)', () => {
+        const inner = { x: 1 };
+        const outer = { a: inner, b: inner }; // shared ref is fine (not circular)
+        outer.a.parent = outer; // this makes it circular
+        throwsTypeError(outer, /circular/);
+    });
+    it('does NOT throw for shared (non-circular) references', () => {
+        // The same object appearing in two sibling branches is fine — it is not circular
+        const shared = { x: 1 };
+        expect(() => hashObject({ a: shared, b: shared })).not.toThrow();
+        // And both branches must hash the same
+        same({ a: shared, b: shared }, { a: { x: 1 }, b: { x: 1 } });
+    });
+    it('throws on NaN', () => {
+        throwsTypeError(NaN, /non-finite/);
+    });
+    it('throws on Infinity', () => {
+        throwsTypeError(Infinity, /non-finite/);
+    });
+    it('throws on -Infinity', () => {
+        throwsTypeError(-Infinity, /non-finite/);
+    });
+    it('throws on NaN inside an object', () => {
+        throwsTypeError({ value: NaN }, /non-finite/);
+    });
+    it('throws on Symbol inside an object', () => {
+        throwsTypeError({ s: Symbol('test') }, /Symbol/);
+    });
+    it('throws on Buffer inside an object', () => {
+        throwsTypeError({ data: Buffer.from('hello') }, /TypedArray|Buffer/);
+    });
+});

package/dist/generate_types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate_types.d.ts","sourceRoot":"","sources":["../src/generate_types.ts"],"names":[],"mappings":"AA2XA;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,EAChC,UAAgC,EAChC,SAA8B,EAC9B,kBAA0C,EAC7C;;;;CAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CA4CrB"}
+{"version":3,"file":"generate_types.d.ts","sourceRoot":"","sources":["../src/generate_types.ts"],"names":[],"mappings":"AA8XA;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,EAChC,UAAgC,EAChC,SAA8B,EAC9B,kBAA0C,EAC7C;;;;CAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CA4CrB"}

package/dist/generate_types.js

@@ -66,7 +66,10 @@ function resolveReference(ref, schema, registry, tracker) {
                 // If still not found, check registry
                 const registryType = registry[segment];
                 if (registryType) {
-                    tracker.imports.set(registryType.sourceFile, segment);
+                    if (!tracker.imports.has(registryType.sourceFile)) {
+                        tracker.imports.set(registryType.sourceFile, new Set());
+                    }
+                    tracker.imports.get(registryType.sourceFile).add(segment);
                     tracker.referencePath.pop();
                     return { typeName: segment, sourceFile: registryType.sourceFile };
                 }
@@ -291,7 +294,7 @@ async function generateTypeFile(schemaPath, registry, outputDir, typeRegistryImp
     const currentFile = schemaPath.split(/[\/\\]/).pop().replace('.json', '');
     const imports = Array.from(tracker.imports.entries())
         .filter(([file]) => file !== currentFile)
-        .map(([file, typeName]) => `import { ${typeName} } from './${file}.types.js';`);
+        .map(([file, typeNames]) => `import { ${Array.from(typeNames).join(', ')} } from './${file}.types.js';`);
     if (imports.length > 0) {
         // Replace header with imports and re-add header once
         output = output.replace(FILE_HEADER, FILE_HEADER + imports.join('\n') + '\n\n');
@@ -364,6 +367,6 @@ export async function generateTypes({ schemaDirs = DEFAULT_SCHEMA_DIRS, outputDi
     }
     catch (err) {
         error('Error generating types:', err);
-        process.exit(1);
+        throw err;
     }
 }

package/dist/hash.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Deterministic object hashing using node:crypto SHA-256.
+ *
+ * ## Supported types
+ * Plain objects, arrays, strings, numbers, booleans, null.
+ *
+ * ## Unsupported types (throws TypeError)
+ * undefined, Date, Map, Set, TypedArrays (Buffer, Uint8Array, etc.),
+ * Function, BigInt, Symbol, and circular references.
+ *
+ * Unsupported types throw rather than silently producing a hash that
+ * diverges from the previous object-hash implementation.
+ *
+ * ## Key ordering
+ * Object keys are sorted recursively before serialisation, so
+ * `{ b: 2, a: 1 }` and `{ a: 1, b: 2 }` produce the same hash.
+ *
+ * ## Array ordering
+ * Array element order is preserved — `[1, 2]` and `[2, 1]` hash differently.
+ */
+/**
+ * Return a deterministic 64-char hex SHA-256 hash of the given value.
+ *
+ * Throws TypeError if the value contains any unsupported type.
+ */
+export declare function hashObject(value: unknown): string;
+//# sourceMappingURL=hash.d.ts.map

package/dist/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../src/hash.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAoGH;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAKjD"}

package/dist/hash.js

@@ -0,0 +1,104 @@
+/**
+ * Deterministic object hashing using node:crypto SHA-256.
+ *
+ * ## Supported types
+ * Plain objects, arrays, strings, numbers, booleans, null.
+ *
+ * ## Unsupported types (throws TypeError)
+ * undefined, Date, Map, Set, TypedArrays (Buffer, Uint8Array, etc.),
+ * Function, BigInt, Symbol, and circular references.
+ *
+ * Unsupported types throw rather than silently producing a hash that
+ * diverges from the previous object-hash implementation.
+ *
+ * ## Key ordering
+ * Object keys are sorted recursively before serialisation, so
+ * `{ b: 2, a: 1 }` and `{ a: 1, b: 2 }` produce the same hash.
+ *
+ * ## Array ordering
+ * Array element order is preserved — `[1, 2]` and `[2, 1]` hash differently.
+ */
+import { createHash } from 'node:crypto';
+/**
+ * Recursively normalise a value for hashing:
+ * - Sort object keys alphabetically
+ * - Throw TypeError on any unsupported type
+ * - Track seen objects to detect circular references
+ */
+function normalise(value, seen) {
+    // null is fine
+    if (value === null)
+        return null;
+    // Primitives
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value)) {
+            throw new TypeError(`hashObject: non-finite number is not supported (got: ${value})`);
+        }
+        return value;
+    }
+    if (typeof value === 'boolean')
+        return value;
+    // Explicitly unsupported primitives
+    if (value === undefined) {
+        throw new TypeError('hashObject: undefined is not supported — use null or omit the key instead');
+    }
+    if (typeof value === 'bigint') {
+        throw new TypeError(`hashObject: BigInt is not supported — convert to string or number first (got: ${value}n)`);
+    }
+    if (typeof value === 'symbol') {
+        throw new TypeError(`hashObject: Symbol is not supported (got: ${String(value)})`);
+    }
+    if (typeof value === 'function') {
+        throw new TypeError(`hashObject: function is not supported (got: ${value.name || 'anonymous'})`);
+    }
+    // Object types
+    if (typeof value === 'object') {
+        // Circular reference detection
+        if (seen.has(value)) {
+            throw new TypeError('hashObject: circular reference detected');
+        }
+        // Explicitly unsupported object types — check before Array/plain-object
+        if (value instanceof Date) {
+            throw new TypeError(`hashObject: Date is not supported — convert to ISO string first (got: ${value.toISOString()})`);
+        }
+        if (value instanceof Map) {
+            throw new TypeError('hashObject: Map is not supported — convert to a plain object first');
+        }
+        if (value instanceof Set) {
+            throw new TypeError('hashObject: Set is not supported — convert to an Array first');
+        }
+        if (ArrayBuffer.isView(value)) {
+            throw new TypeError(`hashObject: TypedArray/Buffer is not supported — convert to a plain array or base64 string first (got: ${value.constructor.name})`);
+        }
+        seen.add(value);
+        let result;
+        if (Array.isArray(value)) {
+            result = value.map((item) => normalise(item, seen));
+        }
+        else {
+            // Plain object — sort keys for determinism
+            const sorted = {};
+            for (const key of Object.keys(value).sort()) {
+                sorted[key] = normalise(value[key], seen);
+            }
+            result = sorted;
+        }
+        seen.delete(value); // allow the same object to appear in sibling branches
+        return result;
+    }
+    // Should be unreachable, but TypeScript needs the exhaustive case
+    throw new TypeError(`hashObject: unsupported type: ${typeof value}`);
+}
+/**
+ * Return a deterministic 64-char hex SHA-256 hash of the given value.
+ *
+ * Throws TypeError if the value contains any unsupported type.
+ */
+export function hashObject(value) {
+    const normalised = normalise(value, new Set());
+    return createHash('sha256')
+        .update(JSON.stringify(normalised))
+        .digest('hex');
+}

package/dist/index.d.ts

@@ -1,4 +1,3 @@
 export { registerTypeSchema, getTypeSchema } from './type_register.js';
 export * from './types/index.js';
-export { generateTypes } from './generate_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":"AAEA,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACvE,cAAc,kBAAkB,CAAC;AAGjC,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACvE,cAAc,kBAAkB,CAAC"}

package/dist/index.js

@@ -1,5 +1,3 @@
 // Main stub. Expose type register functions and all generated types.
 export { registerTypeSchema, getTypeSchema } from './type_register.js';
 export * from './types/index.js';
-// export the generate types function, for use in build scripts or other projects
-export { generateTypes } from './generate_types.js';

package/dist/type_register.d.ts

@@ -1,13 +1,13 @@
 /**
- * Register an OpenAPI schema for runtime type checking
- * @param name The type name (e.g. "DestinationsResponse")
- * @param schema The OpenAPI schema definition
+ * Register a JSON schema for runtime type checking
+ * @param name The type name (e.g. "Entity")
+ * @param schema The JSON schema definition
  */
 export declare function registerTypeSchema(name: string, schema: any): void;
 /**
- * Retrieve the OpenAPI schema for a registered type
+ * Retrieve the JSON schema for a registered type
  * @param name The type name
- * @returns The OpenAPI schema or undefined if not found
+ * @returns The JSON schema or undefined if not found
  */
 export declare function getTypeSchema(name: string): any | undefined;
 //# sourceMappingURL=type_register.d.ts.map

package/dist/type_register.js

@@ -1,17 +1,17 @@
-// Store OpenAPI schemas for runtime type information
+// Store JSON schemas for runtime type information
 const typeMetadataRegistry = new Map();
 /**
- * Register an OpenAPI schema for runtime type checking
- * @param name The type name (e.g. "DestinationsResponse")
- * @param schema The OpenAPI schema definition
+ * Register a JSON schema for runtime type checking
+ * @param name The type name (e.g. "Entity")
+ * @param schema The JSON schema definition
  */
 export function registerTypeSchema(name, schema) {
     typeMetadataRegistry.set(name, schema);
 }
 /**
- * Retrieve the OpenAPI schema for a registered type
+ * Retrieve the JSON schema for a registered type
  * @param name The type name
- * @returns The OpenAPI schema or undefined if not found
+ * @returns The JSON schema or undefined if not found
  */
 export function getTypeSchema(name) {
     return typeMetadataRegistry.get(name);