@eide/uniformgen 0.1.0

package/dist/generators/resolve/platform.js

@@ -0,0 +1,479 @@
+/**
+ * Platform Resolution Generator
+ *
+ * Generates typed hooks/functions for platform-level entity resolution:
+ * - useResolve{Model} - Resolve by natural key with variant selection
+ * - Returns resolved content WITHOUT CMS features (no templates/zones/layouts)
+ *
+ * Use CMS generators (cms/route.ts) for template/zone resolution.
+ *
+ * @generated by UniformGen
+ */
+import { toPascalCase, toCamelCase, sanitizeFieldName } from '../../utils/field-mapping.js';
+/**
+ * Check if model is inline-only (no records mode)
+ */
+function isInlineOnlyModel(model) {
+    return model.modes.inline && !model.modes.records;
+}
+/**
+ * Map metadata field type to TypeScript type
+ */
+function getMetadataValueType(fieldType) {
+    switch (fieldType) {
+        case 'string':
+            return 'string';
+        case 'number':
+            return 'number';
+        case 'boolean':
+            return 'boolean';
+        case 'date':
+            return 'string';
+        case 'array':
+            return 'unknown[]';
+        case 'object':
+            return 'Record<string, unknown>';
+        default:
+            return 'unknown';
+    }
+}
+/**
+ * Build nested metadata type
+ */
+function buildNestedMetadataType(fields, depth = 0) {
+    const groups = new Map();
+    const directFields = [];
+    for (const field of fields) {
+        const parts = field.key.split('.');
+        if (parts.length === 1) {
+            directFields.push(field);
+        }
+        else {
+            const firstPart = parts[0];
+            const remaining = { ...field, key: parts.slice(1).join('.') };
+            if (!groups.has(firstPart)) {
+                groups.set(firstPart, []);
+            }
+            groups.get(firstPart).push(remaining);
+        }
+    }
+    const indent = '  '.repeat(depth + 1);
+    const lines = [];
+    for (const field of directFields) {
+        const valueType = getMetadataValueType(field.type);
+        const fieldName = sanitizeFieldName(field.key);
+        const optional = field.required ? '' : '?';
+        lines.push(`${indent}${fieldName}${optional}: ${valueType};`);
+    }
+    for (const [groupName, groupFields] of groups) {
+        const nestedType = buildNestedMetadataType(groupFields, depth + 1);
+        if (nestedType !== '{}') {
+            const fieldName = sanitizeFieldName(groupName);
+            lines.push(`${indent}${fieldName}?: ${nestedType}`);
+        }
+    }
+    if (lines.length === 0) {
+        return '{}';
+    }
+    const closeIndent = '  '.repeat(depth);
+    return `{\n${lines.join('\n')}\n${closeIndent}}`;
+}
+/**
+ * Generate metadata type for a model
+ */
+function generateMetadataType(model) {
+    const metadataFields = model.metadataSchema?.fields;
+    if (!metadataFields || metadataFields.length === 0) {
+        return null;
+    }
+    return buildNestedMetadataType(metadataFields, 0);
+}
+/**
+ * Generate React platform resolve hook for a model
+ */
+export function generatePlatformResolveReact(model, _allModels) {
+    if (isInlineOnlyModel(model)) {
+        return '';
+    }
+    const typeName = toPascalCase(model.key);
+    const dataTypeName = `${typeName}Data`;
+    const camelName = toCamelCase(model.key);
+    const lines = [];
+    // File header
+    lines.push(`/**`);
+    lines.push(` * ${model.name} - Platform Resolution Hook`);
+    lines.push(` *`);
+    lines.push(` * Resolves ${model.name} content with variant selection.`);
+    lines.push(` * Returns platform-level data (NO templates/zones/layouts).`);
+    lines.push(` *`);
+    lines.push(` * For CMS rendering with templates, use useResolveRoute from ../cms/`);
+    lines.push(` *`);
+    lines.push(` * @generated by UniformGen - DO NOT EDIT MANUALLY`);
+    lines.push(` */`);
+    lines.push('');
+    // Imports
+    lines.push(`import { useQuery, type QueryHookOptions } from '@apollo/client';`);
+    lines.push(`import { gql } from '@apollo/client';`);
+    lines.push(`import type { ${dataTypeName} } from '../../types/models/${model.key}.js';`);
+    lines.push(`import type { VariantContext } from '../../types/field-types.js';`);
+    lines.push('');
+    // Re-export types
+    lines.push(`// Re-export types for convenience`);
+    lines.push(`export type { VariantContext } from '../../types/field-types.js';`);
+    lines.push('');
+    // Generate metadata type if model has metadataSchema
+    const metadataType = generateMetadataType(model);
+    const metadataTypeName = `${typeName}Metadata`;
+    if (metadataType) {
+        lines.push(`/** Typed metadata for ${model.name} */`);
+        lines.push(`export interface ${metadataTypeName} ${metadataType}`);
+        lines.push('');
+    }
+    // Resolved types (platform level - no templates/zones)
+    lines.push(`/** Resolved ${model.name} record (platform level) */`);
+    lines.push(`export interface Resolved${typeName}Record {`);
+    lines.push(`  id: string;`);
+    lines.push(`  modelKey: '${model.key}';`);
+    lines.push(`  naturalKey: string | null;`);
+    if (metadataType) {
+        lines.push(`  metadata?: ${metadataTypeName};`);
+    }
+    else {
+        lines.push(`  metadata?: Record<string, unknown>;`);
+    }
+    lines.push(`}`);
+    lines.push('');
+    lines.push(`/** Resolved ${model.name} variant info */`);
+    lines.push(`export interface Resolved${typeName}Variant {`);
+    lines.push(`  id: string;`);
+    lines.push(`  variantKey: string;`);
+    lines.push(`  catalogKey: string | null;`);
+    lines.push(`  matchedContexts: Array<{ key: string; value: string }>;`);
+    lines.push(`}`);
+    lines.push('');
+    lines.push(`/** Experiment assignment (if applicable) */`);
+    lines.push(`export interface ${typeName}Experiment {`);
+    lines.push(`  experimentId: string;`);
+    lines.push(`  experimentKey: string;`);
+    lines.push(`  variantId: string;`);
+    lines.push(`  variantKey: string;`);
+    lines.push(`  isControl: boolean;`);
+    lines.push(`}`);
+    lines.push('');
+    lines.push(`/** Resolution context (what was used to resolve) */`);
+    lines.push(`export interface ${typeName}ResolutionContext {`);
+    lines.push(`  locale: string;`);
+    lines.push(`  contexts: Record<string, string>;`);
+    lines.push(`}`);
+    lines.push('');
+    lines.push(`/**`);
+    lines.push(` * Resolved ${model.name} (platform level)`);
+    lines.push(` *`);
+    lines.push(` * Contains resolved content WITHOUT CMS features.`);
+    lines.push(` * Use for mobile apps, APIs, or non-CMS frontends.`);
+    lines.push(` */`);
+    lines.push(`export interface Resolved${typeName} {`);
+    lines.push(`  record: Resolved${typeName}Record;`);
+    lines.push(`  variant: Resolved${typeName}Variant;`);
+    lines.push(`  content: ${dataTypeName};`);
+    lines.push(`  experiment: ${typeName}Experiment | null;`);
+    lines.push(`  resolvedWith: ${typeName}ResolutionContext;`);
+    lines.push(`}`);
+    lines.push('');
+    // GraphQL query (platform level - no templates)
+    lines.push(`// GraphQL query for platform resolution (no templates/zones)`);
+    lines.push(`const RESOLVE_${typeName.toUpperCase()}_QUERY = gql\``);
+    lines.push(`  query Resolve${typeName}($naturalKey: String!, $locale: String, $contexts: JSON) {`);
+    lines.push(`    resolveEntity(modelKey: "${model.key}", naturalKey: $naturalKey, locale: $locale, contexts: $contexts) {`);
+    lines.push(`      record {`);
+    lines.push(`        id`);
+    lines.push(`        modelKey`);
+    lines.push(`        naturalKey`);
+    lines.push(`        metadata`);
+    lines.push(`      }`);
+    lines.push(`      variant {`);
+    lines.push(`        id`);
+    lines.push(`        variantKey`);
+    lines.push(`        catalogKey`);
+    lines.push(`        matchedContexts {`);
+    lines.push(`          key`);
+    lines.push(`          value`);
+    lines.push(`        }`);
+    lines.push(`      }`);
+    lines.push(`      content`);
+    lines.push(`      experiment {`);
+    lines.push(`        experimentId`);
+    lines.push(`        experimentKey`);
+    lines.push(`        variantId`);
+    lines.push(`        variantKey`);
+    lines.push(`        isControl`);
+    lines.push(`      }`);
+    lines.push(`      resolvedWith {`);
+    lines.push(`        locale`);
+    lines.push(`        contexts`);
+    lines.push(`      }`);
+    lines.push(`    }`);
+    lines.push(`  }`);
+    lines.push(`\`;`);
+    lines.push('');
+    // Parse helper
+    lines.push(`/** Parse raw response to typed result */`);
+    lines.push(`function parse${typeName}(data: any): Resolved${typeName} {`);
+    lines.push(`  return {`);
+    lines.push(`    record: {`);
+    lines.push(`      ...data.record,`);
+    lines.push(`      modelKey: '${model.key}',`);
+    if (metadataType) {
+        lines.push(`      metadata: data.record.metadata as ${metadataTypeName},`);
+    }
+    lines.push(`    },`);
+    lines.push(`    variant: {`);
+    lines.push(`      id: data.variant.id,`);
+    lines.push(`      variantKey: data.variant.variantKey,`);
+    lines.push(`      catalogKey: data.variant.catalogKey,`);
+    lines.push(`      matchedContexts: data.variant.matchedContexts ?? [],`);
+    lines.push(`    },`);
+    lines.push(`    content: data.content as ${dataTypeName},`);
+    lines.push(`    experiment: data.experiment,`);
+    lines.push(`    resolvedWith: data.resolvedWith,`);
+    lines.push(`  };`);
+    lines.push(`}`);
+    lines.push('');
+    // Hook
+    lines.push(`/**`);
+    lines.push(` * Resolve ${model.name} by natural key with variant selection`);
+    lines.push(` *`);
+    lines.push(` * Returns platform-level data WITHOUT CMS features.`);
+    lines.push(` * For CMS rendering with templates, use useResolveRoute from ../cms/`);
+    lines.push(` *`);
+    lines.push(` * @example`);
+    lines.push(` * const { ${camelName}, loading, error } = useResolve${typeName}('my-slug', {`);
+    lines.push(` *   locale: 'en-US',`);
+    lines.push(` *   contexts: { market: 'us' },`);
+    lines.push(` * });`);
+    lines.push(` *`);
+    lines.push(` * // Access resolved content`);
+    lines.push(` * console.log(${camelName}?.content.title);`);
+    lines.push(` * console.log(${camelName}?.experiment?.variantKey);`);
+    lines.push(` */`);
+    lines.push(`export function useResolve${typeName}(`);
+    lines.push(`  naturalKey: string,`);
+    lines.push(`  context?: VariantContext,`);
+    lines.push(`  options?: Omit<QueryHookOptions, 'variables'>`);
+    lines.push(`) {`);
+    lines.push(`  const result = useQuery(RESOLVE_${typeName.toUpperCase()}_QUERY, {`);
+    lines.push(`    ...options,`);
+    lines.push(`    variables: {`);
+    lines.push(`      naturalKey,`);
+    lines.push(`      locale: context?.locale,`);
+    lines.push(`      contexts: context?.contexts,`);
+    lines.push(`    },`);
+    lines.push(`    skip: !naturalKey,`);
+    lines.push(`  });`);
+    lines.push('');
+    lines.push(`  return {`);
+    lines.push(`    ...result,`);
+    lines.push(`    ${camelName}: result.data?.resolveEntity ? parse${typeName}(result.data.resolveEntity) : undefined,`);
+    lines.push(`  };`);
+    lines.push(`}`);
+    return lines.join('\n') + '\n';
+}
+/**
+ * Generate Remix/Hydrogen platform resolve function for a model
+ */
+export function generatePlatformResolveRemix(model, _allModels) {
+    if (isInlineOnlyModel(model)) {
+        return '';
+    }
+    const typeName = toPascalCase(model.key);
+    const dataTypeName = `${typeName}Data`;
+    const lines = [];
+    // File header
+    lines.push(`/**`);
+    lines.push(` * ${model.name} - Platform Resolution Function`);
+    lines.push(` *`);
+    lines.push(` * Server-side function for resolving ${model.name} content.`);
+    lines.push(` * Returns platform-level data (NO templates/zones/layouts).`);
+    lines.push(` *`);
+    lines.push(` * For CMS rendering with templates, use resolveRoute from ../cms/`);
+    lines.push(` *`);
+    lines.push(` * @generated by UniformGen - DO NOT EDIT MANUALLY`);
+    lines.push(` */`);
+    lines.push('');
+    // Imports
+    lines.push(`import type { ${dataTypeName} } from '../../types/models/${model.key}.js';`);
+    lines.push(`import type { VariantContext } from '../../types/field-types.js';`);
+    lines.push('');
+    // Re-export types
+    lines.push(`export type { VariantContext } from '../../types/field-types.js';`);
+    lines.push('');
+    // GraphQL client interface
+    lines.push(`/** GraphQL client interface */`);
+    lines.push(`export interface GraphQLClient {`);
+    lines.push(`  request<T>(query: string, variables?: Record<string, unknown>): Promise<T>;`);
+    lines.push(`}`);
+    lines.push('');
+    // Generate metadata type if model has metadataSchema
+    const metadataType = generateMetadataType(model);
+    const metadataTypeName = `${typeName}Metadata`;
+    if (metadataType) {
+        lines.push(`/** Typed metadata for ${model.name} */`);
+        lines.push(`export interface ${metadataTypeName} ${metadataType}`);
+        lines.push('');
+    }
+    // Resolved types
+    lines.push(`/** Resolved ${model.name} record (platform level) */`);
+    lines.push(`export interface Resolved${typeName}Record {`);
+    lines.push(`  id: string;`);
+    lines.push(`  modelKey: '${model.key}';`);
+    lines.push(`  naturalKey: string | null;`);
+    if (metadataType) {
+        lines.push(`  metadata?: ${metadataTypeName};`);
+    }
+    else {
+        lines.push(`  metadata?: Record<string, unknown>;`);
+    }
+    lines.push(`}`);
+    lines.push('');
+    lines.push(`export interface Resolved${typeName}Variant {`);
+    lines.push(`  id: string;`);
+    lines.push(`  variantKey: string;`);
+    lines.push(`  catalogKey: string | null;`);
+    lines.push(`  matchedContexts: Array<{ key: string; value: string }>;`);
+    lines.push(`}`);
+    lines.push('');
+    lines.push(`export interface ${typeName}Experiment {`);
+    lines.push(`  experimentId: string;`);
+    lines.push(`  experimentKey: string;`);
+    lines.push(`  variantId: string;`);
+    lines.push(`  variantKey: string;`);
+    lines.push(`  isControl: boolean;`);
+    lines.push(`}`);
+    lines.push('');
+    lines.push(`export interface ${typeName}ResolutionContext {`);
+    lines.push(`  locale: string;`);
+    lines.push(`  contexts: Record<string, string>;`);
+    lines.push(`}`);
+    lines.push('');
+    lines.push(`export interface Resolved${typeName} {`);
+    lines.push(`  record: Resolved${typeName}Record;`);
+    lines.push(`  variant: Resolved${typeName}Variant;`);
+    lines.push(`  content: ${dataTypeName};`);
+    lines.push(`  experiment: ${typeName}Experiment | null;`);
+    lines.push(`  resolvedWith: ${typeName}ResolutionContext;`);
+    lines.push(`}`);
+    lines.push('');
+    // GraphQL query
+    lines.push(`const RESOLVE_${typeName.toUpperCase()}_QUERY = \``);
+    lines.push(`  query Resolve${typeName}($naturalKey: String!, $locale: String, $contexts: JSON) {`);
+    lines.push(`    resolveEntity(modelKey: "${model.key}", naturalKey: $naturalKey, locale: $locale, contexts: $contexts) {`);
+    lines.push(`      record { id modelKey naturalKey metadata }`);
+    lines.push(`      variant { id variantKey catalogKey matchedContexts { key value } }`);
+    lines.push(`      content`);
+    lines.push(`      experiment { experimentId experimentKey variantId variantKey isControl }`);
+    lines.push(`      resolvedWith { locale contexts }`);
+    lines.push(`    }`);
+    lines.push(`  }`);
+    lines.push(`\`;`);
+    lines.push('');
+    // Function
+    lines.push(`/**`);
+    lines.push(` * Resolve ${model.name} by natural key with variant selection`);
+    lines.push(` * Use in Remix loaders or Hydrogen server functions.`);
+    lines.push(` */`);
+    lines.push(`export async function resolve${typeName}(`);
+    lines.push(`  client: GraphQLClient,`);
+    lines.push(`  naturalKey: string,`);
+    lines.push(`  context?: VariantContext`);
+    lines.push(`): Promise<Resolved${typeName} | null> {`);
+    lines.push(`  const result = await client.request<{ resolveEntity: any }>(RESOLVE_${typeName.toUpperCase()}_QUERY, {`);
+    lines.push(`    naturalKey,`);
+    lines.push(`    locale: context?.locale,`);
+    lines.push(`    contexts: context?.contexts,`);
+    lines.push(`  });`);
+    lines.push(`  if (!result.resolveEntity) return null;`);
+    lines.push(`  const data = result.resolveEntity;`);
+    lines.push(`  return {`);
+    lines.push(`    record: { ...data.record, modelKey: '${model.key}' },`);
+    lines.push(`    variant: { ...data.variant, matchedContexts: data.variant.matchedContexts ?? [] },`);
+    lines.push(`    content: data.content as ${dataTypeName},`);
+    lines.push(`    experiment: data.experiment,`);
+    lines.push(`    resolvedWith: data.resolvedWith,`);
+    lines.push(`  };`);
+    lines.push(`}`);
+    return lines.join('\n') + '\n';
+}
+/**
+ * Generate index file for platform resolve hooks (React)
+ */
+export function generatePlatformResolveIndexReact(models) {
+    const recordModels = models.filter((m) => m.modes.records && m.modes.publicApi);
+    let indexCode = `/**
+ * Platform Resolution Hooks
+ *
+ * React hooks for platform-level entity resolution.
+ * Returns resolved content WITHOUT CMS features.
+ *
+ * For CMS rendering with templates, use ../cms/ exports.
+ *
+ * @generated by UniformGen - DO NOT EDIT MANUALLY
+ */\n\n`;
+    // Re-export base types
+    indexCode += `// Re-export base types\n`;
+    indexCode += `export type { VariantContext } from '../types/field-types.js';\n\n`;
+    for (const model of recordModels) {
+        const typeName = toPascalCase(model.key);
+        const hasMetadata = model.metadataSchema?.fields && model.metadataSchema.fields.length > 0;
+        indexCode += `export {\n`;
+        indexCode += `  useResolve${typeName},\n`;
+        indexCode += `  type Resolved${typeName},\n`;
+        indexCode += `  type Resolved${typeName}Record,\n`;
+        indexCode += `  type Resolved${typeName}Variant,\n`;
+        indexCode += `  type ${typeName}Experiment,\n`;
+        indexCode += `  type ${typeName}ResolutionContext,\n`;
+        if (hasMetadata) {
+            indexCode += `  type ${typeName}Metadata,\n`;
+        }
+        indexCode += `} from './${model.key}.js';\n`;
+    }
+    return indexCode;
+}
+/**
+ * Generate index file for platform resolve functions (Remix)
+ */
+export function generatePlatformResolveIndexRemix(models) {
+    const recordModels = models.filter((m) => m.modes.records && m.modes.publicApi);
+    let indexCode = `/**
+ * Platform Resolution Functions
+ *
+ * Server-side functions for platform-level entity resolution.
+ * Returns resolved content WITHOUT CMS features.
+ *
+ * For CMS rendering with templates, use ../cms/ exports.
+ *
+ * @generated by UniformGen - DO NOT EDIT MANUALLY
+ */\n\n`;
+    // Re-export base types
+    indexCode += `export type { VariantContext } from '../types/field-types.js';\n\n`;
+    // Export GraphQL client type from first model
+    const firstModel = recordModels[0];
+    if (firstModel) {
+        indexCode += `export type { GraphQLClient } from './${firstModel.key}.js';\n\n`;
+    }
+    for (const model of recordModels) {
+        const typeName = toPascalCase(model.key);
+        const hasMetadata = model.metadataSchema?.fields && model.metadataSchema.fields.length > 0;
+        indexCode += `export {\n`;
+        indexCode += `  resolve${typeName},\n`;
+        indexCode += `  type Resolved${typeName},\n`;
+        indexCode += `  type Resolved${typeName}Record,\n`;
+        indexCode += `  type Resolved${typeName}Variant,\n`;
+        indexCode += `  type ${typeName}Experiment,\n`;
+        indexCode += `  type ${typeName}ResolutionContext,\n`;
+        if (hasMetadata) {
+            indexCode += `  type ${typeName}Metadata,\n`;
+        }
+        indexCode += `} from './${model.key}.js';\n`;
+    }
+    return indexCode;
+}

package/dist/generators/types/config.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Generates the config.ts file with EntityModelConfig type
+ *
+ * @generated by UniformGen
+ */
+export declare function generateConfigFile(): string;
+//# sourceMappingURL=config.d.ts.map

package/dist/generators/types/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/generators/types/config.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,wBAAgB,kBAAkB,IAAI,MAAM,CA2G3C"}

package/dist/generators/types/config.js

@@ -0,0 +1,113 @@
+/**
+ * Generates the config.ts file with EntityModelConfig type
+ *
+ * @generated by UniformGen
+ */
+export function generateConfigFile() {
+    return `/**
+ * Entity Model Configuration Type
+ *
+ * This is the main type for defining entity model configurations.
+ * Use this to create strongly-typed entity model definitions.
+ *
+ * @generated by UniformGen - DO NOT EDIT MANUALLY
+ */
+
+import type { FieldDef } from './field-types.js';
+import type { EntityHooks } from './hooks.js';
+
+/**
+ * Routing configuration for entity models
+ */
+export interface RoutingConfig {
+  /** Whether this entity type can be used in routes */
+  enabled: boolean;
+  /** Sitemap configuration */
+  sitemap?: {
+    /** Change frequency hint for search engines */
+    changefreq?: 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never';
+    /** Base priority (0.0 to 1.0) */
+    priority?: number;
+  };
+}
+
+/**
+ * Entity model configuration
+ *
+ * This defines the complete configuration for an entity model including
+ * its schema, behavior, and lifecycle hooks.
+ *
+ * @example
+ * export const blogPostConfig = {
+ *   key: 'blog-post',
+ *   name: 'Blog Post',
+ *   versions: true,
+ *   variants: false,
+ *   customFields: true,
+ *   mode: 'records',
+ *   publicApi: true,
+ *   editorMode: 'flat',
+ *   fieldDefs: [
+ *     { key: 'title', type: 'text', label: 'Title', required: true },
+ *     { key: 'content', type: 'richtext', label: 'Content' },
+ *   ],
+ * } as const satisfies EntityModelConfig;
+ */
+export interface EntityModelConfig {
+  /** Unique identifier (kebab-case) */
+  key: string;
+  /** Display name */
+  name: string;
+  /** Description of the entity model */
+  description?: string;
+
+  // Feature flags
+  /** Enable version history (tier >= 2) */
+  versions: boolean;
+  /** Enable market/device/locale variants (tier >= 3) */
+  variants: boolean;
+  /** Allow users to add custom fields to instances */
+  customFields: boolean;
+
+  // Usage mode
+  /**
+   * How this model can be used:
+   * - 'inline': Only as a field type in other models
+   * - 'records': Can create standalone records
+   * - 'both': Both inline and records
+   */
+  mode: 'inline' | 'records' | 'both';
+  /** Whether to expose via public GraphQL API */
+  publicApi: boolean;
+  /**
+   * Editor mode:
+   * - 'flat': Standard form fields
+   * - 'tree': Hierarchical nested editor
+   */
+  editorMode: 'flat' | 'tree';
+
+  // Associations
+  /** Default template reference (natural key) */
+  defaultTemplate?: string | null;
+
+  // Routing
+  /** Routing configuration */
+  routing?: RoutingConfig;
+
+  // Lifecycle hooks
+  /** Lifecycle hooks configuration */
+  hooks?: EntityHooks;
+
+  // Schema
+  /** Field definitions */
+  fieldDefs: readonly FieldDef[];
+}
+
+/**
+ * Helper to create a type-safe entity model config
+ */
+export function defineEntityModel<T extends EntityModelConfig>(config: T): T {
+  return config;
+}
+`;
+}

package/dist/generators/types/data-models.d.ts

@@ -0,0 +1,10 @@
+import type { DataModelSchema } from '../../fetcher/fetch-schemas.js';
+/**
+ * Generate TypeScript types for a data model
+ */
+export declare function generateDataModelTypes(model: DataModelSchema, _useUnknownForJSON: boolean): string;
+/**
+ * Generate index file for data models
+ */
+export declare function generateDataModelsIndex(models: DataModelSchema[]): string;
+//# sourceMappingURL=data-models.d.ts.map

package/dist/generators/types/data-models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-models.d.ts","sourceRoot":"","sources":["../../../src/generators/types/data-models.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAQtE;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,eAAe,EACtB,kBAAkB,EAAE,OAAO,GAC1B,MAAM,CA6FR;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,eAAe,EAAE,GAAG,MAAM,CAqBzE"}