@themeparks/typelib 1.0.0

package/README.md

@@ -0,0 +1,131 @@
+# @themeparks/typelib
+
+TypeScript definition system for ThemeParks.wiki
+
+## Overview
+
+`@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.
+
+## Installation
+
+```bash
+npm install @themeparks/typelib
+```
+
+## Basic Usage
+
+### Using pre-built types
+
+```typescript
+import { V1RootResponse, registerTypeSchema, getTypeSchema } from '@themeparks/typelib';
+
+// Use generated types
+const response: V1RootResponse = {
+    success: true,
+    message: "API is running", 
+    version: "1.0.0"
+};
+
+// Access runtime schemas
+const schema = getTypeSchema('V1RootResponse');
+console.log(schema); // Returns the JSON schema for validation
+```
+
+### Generating types from custom schemas
+
+```typescript
+import { generateTypes } from '@themeparks/typelib/generate';
+import { resolve } from 'path';
+
+await generateTypes({
+    schemaDirs: [resolve('./typesrc')],
+    outputDir: './src/types'
+});
+```
+
+### Runtime Schema Registry
+
+**`registerTypeSchema(name: string, schema: any)`**
+Register a schema for runtime use.
+
+**`getTypeSchema(name: string): any`**
+Retrieve a registered schema.
+
+```typescript
+import { registerTypeSchema, getTypeSchema } from '@themeparks/typelib';
+
+// Schemas are automatically registered when importing types
+import { V1RootResponse } from '@themeparks/typelib';
+
+// Access the schema at runtime
+const schema = getTypeSchema('V1RootResponse');
+```
+
+## Schema Format
+
+Schemas follow JSON Schema Draft 7 specification:
+
+```json
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "MyTypes",
+  "type": "object",
+  "properties": {
+    "MyType": {
+      "type": "object",
+      "required": ["id", "name"],
+      "properties": {
+        "id": {
+          "type": "string",
+          "description": "Unique identifier"
+        },
+        "name": {
+          "type": "string", 
+          "description": "Display name"
+        },
+        "status": {
+          "type": "string",
+          "enum": ["active", "inactive", "pending"],
+          "description": "Status of the item"
+        }
+      }
+    }
+  }
+}
+```
+
+## 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
+
+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';
+}
+
+export enum StatusEnum {
+    "active" = 'active',
+    "inactive" = 'inactive', 
+    "pending" = 'pending'
+}
+
+// Runtime schema registration
+registerTypeSchema("MyType", { /* schema */ });
+```
+
+## Package Exports
+
+- `@themeparks/typelib` - Main package with types and registry functions
+- `@themeparks/typelib/generate` - Type generation functionality

package/dist/generate_types.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Generate TypeScript types from JSON schemas
+ * @param schemaDirs Array of directories containing JSON schema files (default: ['./typesrc'])
+ * @param outputDir Directory to output generated TypeScript files (default: './src/types')
+ * @param typeRegistryImport Import path for the type registry (default: '@themeparks/typelib')
+ */
+export declare function generateTypes({ schemaDirs, outputDir, typeRegistryImport }?: {
+    schemaDirs?: string[] | undefined;
+    outputDir?: string | undefined;
+    typeRegistryImport?: string | undefined;
+}): Promise<void>;
+//# sourceMappingURL=generate_types.d.ts.map

package/dist/generate_types.d.ts.map

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

package/dist/generate_types.js

@@ -0,0 +1,342 @@
+// Script to generate TypeScript interface files from JSON schemas
+import { promises as fs } from 'fs';
+import { join } from 'path';
+// Default directories - can be overridden in generateTypes()
+const DEFAULT_SCHEMA_DIRS = ['./typesrc'];
+const DEFAULT_OUTPUT_DIR = './src/types';
+const FILE_HEADER = '// THIS FILE IS GENERATED - DO NOT EDIT DIRECTLY\n\n';
+// Simple logger implementation to replace missing './logger.js'
+const log = (...args) => console.log('[TypeGenerator 📜]', ...args);
+const error = (...args) => console.error('[TypeGenerator 📜]', ...args);
+async function buildTypeRegistry(schemaDirs) {
+    const registry = {};
+    // Process all schema directories
+    for (const schemaDir of schemaDirs) {
+        try {
+            const files = await fs.readdir(schemaDir);
+            const jsonFiles = files.filter(f => f.endsWith('.json'));
+            for (const file of jsonFiles) {
+                const schemaPath = join(schemaDir, file);
+                const schemaContent = await fs.readFile(schemaPath, 'utf-8');
+                const schema = JSON.parse(schemaContent);
+                // Register all top-level types from this file
+                for (const [name, typeSchema] of Object.entries(schema.properties || {})) {
+                    // If type already exists, log a warning but allow override (later directories take precedence)
+                    if (registry[name]) {
+                        log(`Warning: Type "${name}" already exists, overriding with version from ${schemaPath}`);
+                    }
+                    registry[name] = {
+                        sourceFile: file.replace('.json', ''),
+                        schema: typeSchema
+                    };
+                }
+            }
+        }
+        catch (err) {
+            // Skip directories that don't exist or can't be read
+            log(`Skipping schema directory ${schemaDir}: ${err.message}`);
+        }
+    }
+    return registry;
+}
+function resolveReference(ref, schema, registry, tracker) {
+    const refPath = ref.split('/').slice(1);
+    // Check if we're in a circular reference
+    if (tracker.referencePath.includes(ref)) {
+        throw new Error(`Circular reference detected: ${tracker.referencePath.join(' -> ')} -> ${ref}`);
+    }
+    tracker.referencePath.push(ref);
+    try {
+        // First try to resolve in current schema
+        let referenced = schema;
+        for (const segment of refPath) {
+            if (segment === 'properties' && referenced.properties) {
+                referenced = referenced.properties;
+            }
+            else if (!referenced[segment]) {
+                // If segment not found, try alternate paths
+                if (segment === 'definitions' && ref.startsWith('#/definitions/')) {
+                    // Handle #/definitions/* by looking in properties instead
+                    const typeName = refPath[refPath.length - 1];
+                    if (schema.properties?.[typeName]) {
+                        tracker.referencePath.pop();
+                        return { typeName };
+                    }
+                }
+                // If still not found, check registry
+                const registryType = registry[segment];
+                if (registryType) {
+                    tracker.imports.set(registryType.sourceFile, segment);
+                    tracker.referencePath.pop();
+                    return { typeName: segment, sourceFile: registryType.sourceFile };
+                }
+                throw new Error(`Invalid reference path: ${ref}`);
+            }
+            else {
+                referenced = referenced[segment];
+            }
+        }
+        // If we're referencing a property definition, get its type
+        const typeName = refPath[refPath.length - 1];
+        tracker.referencePath.pop();
+        return { typeName };
+    }
+    catch (err) {
+        tracker.referencePath.pop();
+        throw err;
+    }
+}
+function getTypeFromSchema(schema, rootSchema, registry, tracker, typeName) {
+    if (schema.enum && Array.isArray(schema.enum)) {
+        // Handle enums specially - create union type of string literals
+        return schema.enum.map(value => `'${value}'`).join(' | ');
+    }
+    if (schema.$ref) {
+        try {
+            const resolved = resolveReference(schema.$ref, rootSchema, registry, tracker);
+            return resolved.typeName;
+        }
+        catch (err) {
+            error(`Error resolving reference: ${schema.$ref}`, err);
+            return 'any';
+        }
+    }
+    if (Array.isArray(schema.type)) {
+        // Handle union types like ["string", "null"]
+        return schema.type.map((t) => t === 'null' ? 'null' : t).join(' | ');
+    }
+    switch (schema.type) {
+        case 'string':
+            return schema.nullable ? 'string | null' : 'string';
+        case 'number':
+            return schema.nullable ? 'number | null' : 'number';
+        case 'integer':
+            return schema.nullable ? 'number | null' : 'number';
+        case 'boolean':
+            return schema.nullable ? 'boolean | null' : 'boolean';
+        case 'array': {
+            let arrayType = schema.items
+                ? `${getTypeFromSchema(schema.items, rootSchema, registry, tracker)}[]`
+                : 'any[]';
+            // Handle nullable arrays
+            if (schema.nullable) {
+                arrayType += ' | null';
+            }
+            return arrayType;
+        }
+        case 'object': {
+            if (!schema.properties) {
+                const recordType = `Record<string, any>`;
+                if (typeName) {
+                    return `extends ${recordType} {}`;
+                }
+                return schema.nullable ? `${recordType} | null` : recordType;
+            }
+            const props = [];
+            for (const [propName, propSchema] of Object.entries(schema.properties || {})) {
+                const isRequired = schema.required?.includes(propName);
+                const propType = getTypeFromSchema(propSchema, rootSchema, registry, tracker);
+                const description = propSchema.description
+                    ? `\n    /** ${propSchema.description} */\n    `
+                    : '';
+                props.push(`${description}${propName}${isRequired ? '' : '?'}: ${propType};`);
+            }
+            const objType = `{\n    ${props.join('\n    ')}\n}`;
+            return schema.nullable ? `(${objType}) | null` : objType;
+        }
+        default:
+            return 'any';
+    }
+}
+function generateRuntimeSchemaExport(schema, typeRegistryImport) {
+    // Generate the runtime schema registration code
+    let output = '\n// Runtime Schema Registration\n';
+    output += `import { registerTypeSchema } from "${typeRegistryImport}";\n\n`;
+    // For each top-level type, register its schema
+    for (const [name, typeSchema] of Object.entries(schema.properties || {})) {
+        // remove any properties that have "__private" set to true. Recusively.
+        const cleanSchema = JSON.parse(JSON.stringify(typeSchema, (key, value) => {
+            // if any value is an object with "__private" set to true, remove it
+            if (value && typeof value === 'object' && value.__private) {
+                return undefined; // Remove this property
+            }
+            return value;
+        }));
+        output += `registerTypeSchema("${name}", ${JSON.stringify(cleanSchema, null, 2)});\n\n`;
+    }
+    return output;
+}
+async function generateTypeFile(schemaPath, registry, outputDir, typeRegistryImport) {
+    log(`Generating types for schema: ${schemaPath}`);
+    const schemaContent = await fs.readFile(schemaPath, 'utf-8');
+    const schema = JSON.parse(schemaContent);
+    let output = FILE_HEADER;
+    // Track imports needed for this file
+    const tracker = {
+        imports: new Map(),
+        referencePath: []
+    };
+    // Generate interfaces and types for top-level properties
+    for (const [name, typeSchema] of Object.entries(schema.properties || {})) {
+        const description = typeSchema.description
+            ? `/** ${typeSchema.description} */\n`
+            : '';
+        if (typeSchema.type === 'object' && typeSchema.properties) {
+            // Handle objects with const values (like HttpStatusCode)
+            const hasConstValues = Object.entries(typeSchema.properties).some(([_, prop]) => prop.const !== undefined);
+            if (hasConstValues) {
+                output += `export enum ${name}Enum {\n`;
+                Object.entries(typeSchema.properties).forEach(([key, prop]) => {
+                    output += `    ${key} = ${prop.const},\n`;
+                });
+                output += `}\n\n`;
+                output += `${description}export type ${name} = keyof typeof ${name}Enum;\n\n`;
+                continue;
+            }
+        }
+        if (typeSchema.enum && Array.isArray(typeSchema.enum)) {
+            // generate a native enum for enum types
+            output += `export enum ${name}Enum {\n`;
+            typeSchema.enum.forEach((value) => {
+                output += `    "${value}" = '${value}',\n`;
+            });
+            output += `}\n\n`;
+            // Also generate enum type
+            output += `${description}export type ${name} = keyof typeof ${name}Enum;\n\n`;
+            // Also generate a StringTo${name} function
+            output += `// Function to convert string to ${name}Enum\n`;
+            output += `export function StringTo${name}(value: string): ${name}Enum {\n`;
+            output += `    const lowerValue = value.toLowerCase();\n`;
+            output += `    switch (lowerValue) {\n`;
+            typeSchema.enum.forEach((value) => {
+                if (value) {
+                    output += `        case '${value.toLowerCase()}':\n`;
+                    if (value.includes(' ')) {
+                        // Handle spaces in enum values
+                        output += `            return ${name}Enum["${value}"];\n`;
+                    }
+                    else {
+                        output += `            return ${name}Enum.${value};\n`;
+                    }
+                }
+            });
+            output += `    }\n`;
+            output += `    throw new Error('Unknown ${name} value: ' + value);\n`;
+            output += `}\n\n`;
+        }
+        else if (typeSchema.type === 'object' || typeSchema.allOf) {
+            // Handle inheritance with allOf
+            if (typeSchema.allOf) {
+                const baseType = typeSchema.allOf.find((t) => t.$ref)?.$ref?.split('/').pop();
+                const interfaceContent = typeSchema.properties?.data
+                    ? getTypeFromSchema(typeSchema.properties.data, schema, registry, tracker)
+                    : '{}';
+                if (baseType === 'AdminResponse') {
+                    // For types extending AdminResponse, use the data type as generic parameter
+                    output += `${description}export interface ${name} extends ${baseType}<${interfaceContent}> {}\n\n`;
+                }
+                else if (baseType) {
+                    output += `${description}export interface ${name} extends ${baseType} ${getTypeFromSchema(typeSchema, schema, registry, tracker)}\n\n`;
+                }
+                else {
+                    output += `${description}export interface ${name} ${getTypeFromSchema(typeSchema, schema, registry, tracker, name)}\n\n`;
+                }
+            }
+            else {
+                // Generate regular interface type
+                if (name === 'AdminResponse') {
+                    // Make AdminResponse generic with data type as parameter
+                    output += `${description}export interface ${name}<T = any> {\n    success: boolean;\n    data: T;\n}\n\n`;
+                }
+                else {
+                    const typeStr = getTypeFromSchema(typeSchema, schema, registry, tracker, name);
+                    if (typeStr.startsWith('extends')) {
+                        output += `${description}export interface ${name} ${typeStr}\n\n`;
+                    }
+                    else {
+                        output += `${description}export type ${name} = ${typeStr}\n\n`;
+                    }
+                }
+            }
+        }
+    }
+    // Add imports
+    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';`);
+    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');
+    }
+    output += generateRuntimeSchemaExport(schema, typeRegistryImport);
+    // Write to output file
+    // Get just the filename without path and convert to .types.ts
+    const baseFileName = schemaPath.split(/[\/\\]/).pop().replace('.json', '.types.ts');
+    const fileName = join(outputDir, baseFileName);
+    await fs.writeFile(fileName, output);
+    log(`Generated ${fileName}`);
+}
+async function generateIndexFile(files, outputDir) {
+    let output = FILE_HEADER;
+    // Add imports to trigger schema registration
+    output += '// Import all type files to trigger schema registration\n';
+    files.forEach(file => {
+        const baseFileName = file.replace('.json', '.types.js');
+        output += `import './${baseFileName}';\n`;
+    });
+    output += '\n';
+    // Add re-exports
+    output += '// Re-export types\n';
+    files.forEach(file => {
+        const baseFileName = file.replace('.json', '.types.js');
+        output += `export * from './${baseFileName}';\n`;
+    });
+    await fs.writeFile(join(outputDir, 'index.ts'), output);
+    log('Generated index.ts');
+}
+/**
+ * Generate TypeScript types from JSON schemas
+ * @param schemaDirs Array of directories containing JSON schema files (default: ['./typesrc'])
+ * @param outputDir Directory to output generated TypeScript files (default: './src/types')
+ * @param typeRegistryImport Import path for the type registry (default: '@themeparks/typelib')
+ */
+export async function generateTypes({ schemaDirs = DEFAULT_SCHEMA_DIRS, outputDir = DEFAULT_OUTPUT_DIR, typeRegistryImport = "@themeparks/typelib" } = {}) {
+    try {
+        log(`Generating types from schema directories: ${schemaDirs.join(', ')}`);
+        log(`Output directory: ${outputDir}`);
+        // First build the type registry from all schema directories
+        const registry = await buildTypeRegistry(schemaDirs);
+        // make sure output directory exists
+        await fs.mkdir(outputDir, { recursive: true });
+        // Collect all JSON files from all schema directories
+        const allJsonFiles = [];
+        const processedFiles = new Set(); // Track processed filenames to avoid duplicates
+        for (const schemaDir of schemaDirs) {
+            try {
+                const files = await fs.readdir(schemaDir);
+                const jsonFiles = files.filter(f => f.endsWith('.json'));
+                // Generate type files with cross-file reference support
+                for (const file of jsonFiles) {
+                    const schemaPath = join(schemaDir, file);
+                    await generateTypeFile(schemaPath, registry, outputDir, typeRegistryImport);
+                    // Track this filename for the index file (avoid duplicates)
+                    if (!processedFiles.has(file)) {
+                        allJsonFiles.push(file);
+                        processedFiles.add(file);
+                    }
+                }
+            }
+            catch (err) {
+                log(`Skipping schema directory ${schemaDir}: ${err.message}`);
+            }
+        }
+        // Generate index.ts with all processed files
+        await generateIndexFile(allJsonFiles, outputDir);
+        log('Type generation complete!');
+    }
+    catch (err) {
+        error('Error generating types:', err);
+        process.exit(1);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+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

@@ -0,0 +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"}

package/dist/index.js

@@ -0,0 +1,5 @@
+// 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/run_generate_types.d.ts

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

package/dist/run_generate_types.d.ts.map

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

package/dist/run_generate_types.js

@@ -0,0 +1,7 @@
+import { generateTypes } from './generate_types.js';
+import { resolve } from 'path';
+await generateTypes({
+    schemaDirs: [resolve('./typesrc')],
+    outputDir: './src/types',
+    typeRegistryImport: '../type_register.js',
+});

package/dist/type_register.d.ts

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

package/dist/type_register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type_register.d.ts","sourceRoot":"","sources":["../src/type_register.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,IAAI,CAElE;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS,CAE3D"}

package/dist/type_register.js

@@ -0,0 +1,18 @@
+// Store OpenAPI 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
+ */
+export function registerTypeSchema(name, schema) {
+    typeMetadataRegistry.set(name, schema);
+}
+/**
+ * Retrieve the OpenAPI schema for a registered type
+ * @param name The type name
+ * @returns The OpenAPI schema or undefined if not found
+ */
+export function getTypeSchema(name) {
+    return typeMetadataRegistry.get(name);
+}

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+import './v1.types.js';
+export * from './v1.types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAGA,OAAO,eAAe,CAAC;AAGvB,cAAc,eAAe,CAAC"}

package/dist/types/index.js

@@ -0,0 +1,5 @@
+// THIS FILE IS GENERATED - DO NOT EDIT DIRECTLY
+// Import all type files to trigger schema registration
+import './v1.types.js';
+// Re-export types
+export * from './v1.types.js';

package/dist/types/v1.types.d.ts

@@ -0,0 +1,9 @@
+export type V1RootResponse = {
+    /** Whether the request was successful */
+    success: boolean;
+    /** Welcome message for the API */
+    message: string;
+    /** API version number */
+    version: string;
+};
+//# sourceMappingURL=v1.types.d.ts.map

package/dist/types/v1.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v1.types.d.ts","sourceRoot":"","sources":["../../src/types/v1.types.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,cAAc,GAAG;IAEzB,yCAAyC;IACzC,OAAO,EAAE,OAAO,CAAC;IAEjB,kCAAkC;IAClC,OAAO,EAAE,MAAM,CAAC;IAEhB,yBAAyB;IACzB,OAAO,EAAE,MAAM,CAAC;CACnB,CAAA"}

package/dist/types/v1.types.js

@@ -0,0 +1,25 @@
+// THIS FILE IS GENERATED - DO NOT EDIT DIRECTLY
+// Runtime Schema Registration
+import { registerTypeSchema } from "../type_register.js";
+registerTypeSchema("V1RootResponse", {
+    "type": "object",
+    "required": [
+        "success",
+        "message",
+        "version"
+    ],
+    "properties": {
+        "success": {
+            "type": "boolean",
+            "description": "Whether the request was successful"
+        },
+        "message": {
+            "type": "string",
+            "description": "Welcome message for the API"
+        },
+        "version": {
+            "type": "string",
+            "description": "API version number"
+        }
+    }
+});

package/package.json

@@ -0,0 +1,42 @@
+{
+    "name": "@themeparks/typelib",
+    "version": "1.0.0",
+    "main": "./dist/index.js",
+    "module": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "type": "module",
+    "description": "TypeScript definitions for ThemeParks.wiki API",
+    "keywords": ["typescript", "types", "api", "schema", "generation"],
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js",
+            "require": "./dist/index.js"
+        },
+        "./generate": {
+            "types": "./dist/generate_types.d.ts",
+            "import": "./dist/generate_types.js",
+            "require": "./dist/generate_types.js"
+        }
+    },
+    "files": [
+        "dist/**/*",
+        "typesrc/**/*",
+        "README.md"
+    ],
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1",
+        "generate:types": "npx tsx ./src/run_generate_types.ts",
+        "build": "npm run generate:types && tsc",
+        "prepublishOnly": "npm run build",
+        "publish": "npm publish --access public"
+    },
+    "devDependencies": {
+        "@types/node": "^24.5.2",
+        "tsx": "^4.7.1",
+        "typescript": "^5.0.0"
+    },
+    "engines": {
+        "node": ">=24.0.0"
+    }
+}

package/typesrc/v1.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "V1Root",
+  "type": "object",
+  "properties": {
+    "V1RootResponse": {
+      "type": "object",
+      "required": ["success", "message", "version"],
+      "properties": {
+        "success": {
+          "type": "boolean",
+          "description": "Whether the request was successful"
+        },
+        "message": {
+          "type": "string",
+          "description": "Welcome message for the API"
+        },
+        "version": {
+          "type": "string",
+          "description": "API version number"
+        }
+      }
+    }
+  }
+}