@lemonadecms/client 0.0.0-stage → 0.1.0

package/bin/cli/schema.mjs

@@ -0,0 +1,397 @@
+import { generateTypes } from '../generate-types.mjs';
+import { record, uuid } from './config.mjs';
+import { fail } from './errors.mjs';
+const identifier = /^[a-z][a-z0-9_]{0,47}$/;
+const apiKey = (value) => typeof value === 'string' && identifier.test(value);
+const language = /^[a-z]{2,3}(?:-[A-Z][a-z]{3})?(?:-(?:[A-Z]{2}|[0-9]{3}))?$/;
+const own = (value, keys) =>
+  record(value) && Object.keys(value).every((key) => keys.includes(key));
+const unique = (values) => new Set(values).size === values.length;
+const segmenter = new Intl.Segmenter('und', { granularity: 'grapheme' });
+function string(value, max) {
+  if (typeof value !== 'string' || !value.trim()) return false;
+  let count = 0;
+  for (const _ of segmenter.segment(value)) if (++count > max) return false;
+  return true;
+}
+function fieldGuidance(field) {
+  if (Object.hasOwn(field, 'help_text')) {
+    if (typeof field.help_text !== 'string') invalid();
+    let count = 0;
+    for (const _ of segmenter.segment(field.help_text)) if (++count > 500) invalid();
+  }
+  if (!Object.hasOwn(field, 'validation')) return;
+  const rule = field.validation;
+  const text = ['text', 'long_text', 'markdown'].includes(field.type);
+  const allowed = field.type === 'text'
+    ? ['min_length', 'max_length', 'format']
+    : text ? ['min_length', 'max_length'] : field.type === 'number' ? ['min', 'max']
+      : field.type === 'choices' ? ['min_items', 'max_items'] : [];
+  if (!own(rule, allowed) || Object.keys(rule).length === 0) invalid();
+  if (text) {
+    const ceiling = field.type === 'text' ? 500 : 20000;
+    for (const key of ['min_length', 'max_length'])
+      if (Object.hasOwn(rule, key) &&
+          (!Number.isInteger(rule[key]) || rule[key] < 0 || rule[key] > ceiling)) invalid();
+    if (Object.hasOwn(rule, 'min_length') && Object.hasOwn(rule, 'max_length') &&
+        rule.min_length > rule.max_length) invalid();
+    if (Object.hasOwn(rule, 'format') && !['email', 'url'].includes(rule.format)) invalid();
+  } else if (field.type === 'number') {
+    for (const key of ['min', 'max'])
+      if (Object.hasOwn(rule, key) && (typeof rule[key] !== 'number' || !Number.isFinite(rule[key]))) invalid();
+    if (Object.hasOwn(rule, 'min') && Object.hasOwn(rule, 'max') && rule.min > rule.max) invalid();
+  } else if (field.type === 'choices') {
+    for (const key of ['min_items', 'max_items'])
+      if (Object.hasOwn(rule, key) &&
+          (!Number.isInteger(rule[key]) || rule[key] < 0 || rule[key] > 100)) invalid();
+    if (Object.hasOwn(rule, 'min_items') && Object.hasOwn(rule, 'max_items') &&
+        rule.min_items > rule.max_items) invalid();
+  }
+}
+const invalid = () =>
+  fail(5, 'Invalid or unsupported schema export. No output was written.');
+const leaves = [
+  'text',
+  'long_text',
+  'markdown',
+  'number',
+  'boolean',
+  'color',
+  'date',
+  'datetime',
+  'choice',
+  'choices',
+  'reference',
+  'references',
+  'image',
+  'file',
+  'rich_text',
+];
+const composed = ['component', 'components', 'blocks'];
+function bounded(value) {
+  const stack = [[value, 0]];
+  let nodes = 0;
+  while (stack.length) {
+    const [item, depth] = stack.pop();
+    if (++nodes > 150000 || depth > 16) invalid();
+    if (
+      typeof item === 'string' &&
+      /(?:pk|sk)_[A-Za-z0-9_-]{43}|lmd_(?:pk|sk|mgmt)_[0-9a-f-]{36}\.[A-Za-z0-9_-]{43}/.test(
+        item,
+      )
+    )
+      fail(5, 'Schema contains a credential-shaped value. No output was written.');
+    if (item && typeof item === 'object')
+      for (const child of Object.values(item)) stack.push([child, depth + 1]);
+  }
+}
+function fields(values, keys, component = false) {
+  if (
+    !Array.isArray(values) ||
+    values.length > 24 ||
+    !unique(values.map((field) => field?.key))
+  )
+    invalid();
+  for (const field of values) {
+    if (
+      !record(field) ||
+      !apiKey(field.key) ||
+      !string(field.label, 80) ||
+      typeof field.required !== 'boolean' ||
+      ![...leaves, ...composed].includes(field.type)
+    )
+      invalid();
+    const extra =
+      ['choice', 'choices'].includes(field.type)
+        ? ['options']
+        : ['reference', 'references'].includes(field.type)
+          ? ['target']
+          : field.type === 'rich_text'
+            ? ['images', 'targets']
+            : composed.includes(field.type)
+              ? ['components']
+              : [];
+    const defaults = [
+      'text',
+      'long_text',
+      'markdown',
+      'number',
+      'boolean',
+      'color',
+      'date',
+      'datetime',
+      'choice',
+      'choices',
+    ];
+    const seo = ['text', 'long_text', 'image'].includes(field.type) ? ['seo'] : [];
+    if (
+      !own(field, [
+        'key',
+        'label',
+        'type',
+        'required',
+        'localized',
+        'show_if',
+        'help_text',
+        'validation',
+        ...(!component ? ['group'] : []),
+        ...extra,
+        ...seo,
+        ...(field.type === 'text' && !component ? ['slug'] : []),
+        ...(defaults.includes(field.type) ? ['default'] : []),
+      ])
+    )
+      invalid();
+    if (Object.hasOwn(field, 'group') &&
+        (typeof field.group !== 'string' || !field.group ||
+          /^\p{White_Space}|\p{White_Space}$/u.test(field.group) || Buffer.byteLength(field.group) > 80 ||
+          /[\u0000-\u001f\u007f-\u009f\u2028\u2029\ud800-\udfff]/u.test(field.group)))
+      invalid();
+    fieldGuidance(field);
+    if (
+      Object.hasOwn(field, 'localized') &&
+      (typeof field.localized !== 'boolean' ||
+        (field.localized &&
+          !['text', 'long_text', 'markdown', 'rich_text'].includes(field.type)))
+    )
+      invalid();
+    if (component && (composed.includes(field.type) || field.localized === true))
+      invalid();
+    if (Object.hasOwn(field, 'default')) {
+      const value = field.default;
+      if (field.type === 'choices' && value === null) invalid();
+      if (
+        value !== null &&
+        (field.type === 'choices'
+          ? !Array.isArray(value) || value.length > 100 || !unique(value) ||
+            !value.every((option) => typeof option === 'string' && field.options?.includes(option))
+          : field.type === 'boolean'
+          ? typeof value !== 'boolean'
+          : field.type === 'number'
+            ? typeof value !== 'number' || !Number.isFinite(value)
+            : typeof value !== 'string')
+      )
+        invalid();
+      if (field.type === 'choice' && value !== null && !field.options?.includes(value))
+        invalid();
+    }
+    if (
+      ['choice', 'choices'].includes(field.type) &&
+      (!Array.isArray(field.options) ||
+        field.options.length < 1 ||
+        field.options.length > 100 ||
+        !unique(field.options) ||
+        !field.options.every((value) => string(value, 100)))
+    )
+      invalid();
+    if (['reference', 'references'].includes(field.type) && !keys.has(field.target))
+      invalid();
+    if (
+      field.type === 'rich_text' &&
+      ((Object.hasOwn(field, 'images') && typeof field.images !== 'boolean') ||
+        !Array.isArray(field.targets || []) ||
+        (field.targets || []).length > 12 ||
+        !unique(field.targets || []) ||
+        !(field.targets || []).every((target) => keys.has(target)))
+    )
+      invalid();
+    if (composed.includes(field.type)) {
+      if (
+        !Array.isArray(field.components) ||
+        field.components.length < 1 ||
+        field.components.length > 12 ||
+        (field.type !== 'blocks' && field.components.length !== 1) ||
+        !unique(field.components.map((item) => item?.key))
+      )
+        invalid();
+      for (const definition of field.components) {
+        if (
+          !own(definition, ['key', 'name', 'fields']) ||
+          !apiKey(definition.key) ||
+          !string(definition.name, 80) ||
+          !definition.fields?.length
+        )
+          invalid();
+        fields(definition.fields, keys, true);
+      }
+    }
+  }
+  const byKey = new Map(values.map((field) => [field.key, field]));
+  for (const field of values) {
+    if (Object.hasOwn(field, 'slug')) {
+      const rule = field.slug;
+      const source = byKey.get(rule?.source);
+      if (
+        !own(rule, ['source', 'unique']) ||
+        Object.keys(rule).length !== 2 ||
+        typeof rule.unique !== 'boolean' ||
+        !apiKey(rule.source) ||
+        !source ||
+        source === field ||
+        source.type !== 'text'
+      )
+        invalid();
+    }
+    if (!Object.hasOwn(field, 'show_if')) continue;
+    const rule = field.show_if;
+    const controller = byKey.get(rule?.field);
+    if (!own(rule, ['field', 'equals']) || Object.keys(rule).length !== 2 ||
+        !controller || controller === field || controller.localized === true ||
+        (controller.type === 'boolean' ? typeof rule.equals !== 'boolean' :
+         controller.type !== 'choice' || !controller.options.includes(rule.equals))) invalid();
+    const visited = new Set([field.key]);
+    let current = controller;
+    while (current) {
+      if (visited.has(current.key)) invalid();
+      visited.add(current.key);
+      current = byKey.get(current.show_if?.field);
+    }
+  }
+}
+export function validateSchema(schema) {
+  bounded(schema);
+  if (
+    !own(schema, [
+      'format_version',
+      'project_id',
+      'schema_revision',
+      'locales',
+      'default_locale',
+      'models',
+      'environment',
+    ]) ||
+    schema.format_version !== 1 ||
+    !uuid.test(schema.project_id || '') ||
+    !Number.isSafeInteger(schema.schema_revision) ||
+    schema.schema_revision < 0 ||
+    !Array.isArray(schema.locales) ||
+    schema.locales.length < 1 ||
+    schema.locales.length > 20 ||
+    !unique(schema.locales) ||
+    !schema.locales.every(
+      (locale) => typeof locale === 'string' && language.test(locale),
+    ) ||
+    !(
+      schema.default_locale === null || schema.locales.includes(schema.default_locale)
+    ) ||
+    !Array.isArray(schema.models) ||
+    schema.models.length > 256 ||
+    !unique(schema.models.map((model) => model?.key))
+  )
+    invalid();
+  if (
+    schema.environment &&
+    (!own(schema.environment, ['id', 'key']) ||
+      !uuid.test(schema.environment.id || '') ||
+      typeof schema.environment.key !== 'string' ||
+      !/^[a-z][a-z0-9_-]{0,31}$/.test(schema.environment.key) ||
+      schema.environment.id === schema.project_id)
+  )
+    invalid();
+  if (Object.hasOwn(schema, 'environment') && !schema.environment) invalid();
+  const keys = new Set(schema.models.map((model) => model?.key));
+  for (const model of schema.models) {
+    if (
+      !own(model, ['key', 'name', 'fields', 'remote', 'singleton']) ||
+      (Object.hasOwn(model, 'singleton') && typeof model.singleton !== 'boolean') ||
+      !apiKey(model.key) ||
+      !string(model.name, 80)
+    )
+      invalid();
+    fields(model.fields, keys);
+    if (Object.hasOwn(model, 'remote')) {
+      if (
+        !own(model.remote, ['version', 'fields']) ||
+        !Number.isSafeInteger(model.remote.version) ||
+        model.remote.version < 1 ||
+        !Array.isArray(model.remote.fields) ||
+        model.remote.fields.length < 1 ||
+        model.remote.fields.length > 8 ||
+        !unique(model.remote.fields.map((field) => field?.key)) ||
+        !model.remote.fields.every(
+          (field) =>
+            own(field, ['key', 'type']) &&
+            apiKey(field.key) &&
+            ['text', 'number', 'boolean'].includes(field.type),
+        )
+      )
+        invalid();
+    }
+  }
+  // One type generator remains authoritative for delivery types, references and SEO roles.
+  try {
+    generateTypes(schema);
+  } catch {
+    invalid();
+  }
+  return schema;
+}
+export function canonical(value) {
+  if (Array.isArray(value)) return value.map(canonical);
+  if (record(value))
+    return Object.fromEntries(
+      Object.keys(value)
+        .sort()
+        .map((key) => [key, canonical(value[key])]),
+    );
+  return value;
+}
+export function serialize(schema) {
+  return (
+    JSON.stringify(
+      canonical({
+        ...schema,
+        models: [...schema.models].sort((a, b) =>
+          a.key < b.key ? -1 : a.key > b.key ? 1 : 0,
+        ),
+      }),
+      null,
+      2,
+    ) + '\n'
+  );
+}
+export function schemaIdentity(schema) {
+  return {
+    workspace: schema.project_id,
+    environment: schema.environment?.key || 'production',
+    environmentId: schema.environment?.id || schema.project_id,
+    revision: schema.schema_revision,
+    models: schema.models.length,
+    fields: schema.models.reduce((total, model) => total + model.fields.length, 0),
+  };
+}
+export function compareSchemas(baseline, current) {
+  const changes = [];
+  const equal = (a, b) => JSON.stringify(canonical(a)) === JSON.stringify(canonical(b));
+  function compare(left, right, path) {
+    if (equal(left, right)) return;
+    if (record(left) && record(right)) {
+      for (const key of [
+        ...new Set([...Object.keys(left), ...Object.keys(right)]),
+      ].sort())
+        compare(left[key], right[key], `${path}.${key}`);
+    } else
+      changes.push({
+        path,
+        change:
+          left === undefined ? 'added' : right === undefined ? 'removed' : 'changed',
+      });
+  }
+  compare(baseline.locales, current.locales, 'locales');
+  compare(baseline.default_locale, current.default_locale, 'default_locale');
+  const byKey = (rows) => Object.fromEntries(rows.map((row) => [row.key, row]));
+  // Workspace/environment IDs and revision counters intentionally differ between targets.
+  const modelMap = (schema) =>
+    Object.fromEntries(
+      schema.models.map((model) => [
+        model.key,
+        {
+          ...model,
+          fields: byKey(model.fields),
+          field_order: model.fields.map((field) => field.key),
+        },
+      ]),
+    );
+  compare(modelMap(baseline), modelMap(current), 'models');
+  return changes;
+}

package/bin/codegen/csharp.mjs

@@ -0,0 +1,180 @@
+import { definitions } from './definitions.mjs';
+const quote = (value) =>
+  JSON.stringify(value).replace(
+    /[\u0085\u2028\u2029]/g,
+    (character) => `\\u${character.charCodeAt(0).toString(16).padStart(4, '0')}`,
+  );
+const property = (wire, type, name, initial = '') =>
+  `    [JsonPropertyName(${quote(wire)})]\n    public ${type} ${name} { get; init; }${initial}\n`;
+
+export function generateCSharp(schema) {
+  const { records, choices, names } = definitions(schema);
+  function type(field) {
+    switch (field.type) {
+      case 'number':
+        return 'double';
+      case 'boolean':
+        return 'bool';
+      case 'choice':
+        return field.name;
+      case 'choices':
+        return `List<${field.name}>`;
+      case 'reference':
+        return `ContentReference<${names.get(field.target)}>`;
+      case 'references':
+        return `List<ContentReference<${names.get(field.target)}>>`;
+      case 'image':
+      case 'file':
+        return 'ContentAsset';
+      case 'rich_text':
+        return 'ContentRichText';
+      case 'component':
+        return field.variants[0].name;
+      case 'components':
+        return `List<${field.variants[0].name}>`;
+      case 'blocks':
+        return `List<${field.name}>`;
+      default:
+        return 'string';
+    }
+  }
+  const blockFields = records.flatMap((record) =>
+    record.fields.filter((field) => field.type === 'blocks'),
+  );
+  const blockNames = new Set(blockFields.map((field) => field.name));
+  const blocks = blockFields
+    .map((field) => {
+      const cases = field.variants
+        .map(
+          (v) =>
+            `            ${quote(v.key)} => JsonSerializer.Deserialize<${v.name}>(root.GetRawText(), options)!,`,
+        )
+        .join('\n');
+      const writes = field.variants
+        .map(
+          (v) =>
+            `            case ${v.name} item: JsonSerializer.Serialize(writer, item, options); break;`,
+        )
+        .join('\n');
+      // The wire discriminator can occur anywhere in a JSON object. Built-in .NET8
+      // metadata polymorphism requires it first; this converter does not reorder
+      // or change the delivery contract and rejects unknown variants explicitly.
+      return `[JsonConverter(typeof(Converter_${field.name}))]
+public abstract record ${field.name};
+public sealed class Converter_${field.name} : JsonConverter<${field.name}>
+{
+    public override ${field.name} Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        using var document = JsonDocument.ParseValue(ref reader);
+        var root = document.RootElement;
+        if (root.ValueKind != JsonValueKind.Object || !root.TryGetProperty("type", out var kind) || kind.ValueKind != JsonValueKind.String) throw new JsonException("Missing component discriminator.");
+        return kind.GetString() switch
+        {
+${cases}
+            _ => throw new JsonException("Unknown component discriminator.")
+        };
+    }
+    public override void Write(Utf8JsonWriter writer, ${field.name} value, JsonSerializerOptions options)
+    {
+        switch (value)
+        {
+${writes}
+            default: throw new JsonException("Unknown component variant.");
+        }
+    }
+}
+`;
+    })
+    .join('\n');
+  const choiceTypes = choices
+    .map(
+      (field) => `[JsonConverter(typeof(Converter_${field.name}))]
+public enum ${field.name} { ${field.options.map((_, i) => `Value${i}`).join(', ')} }
+public sealed class Converter_${field.name} : StringChoiceConverter<${field.name}>
+{
+    private static readonly string[] Items = { ${field.options.map(quote).join(', ')} };
+    protected override string[] Values => Items;
+}
+`,
+    )
+    .join('\n');
+  const objects = records
+    .map((record) => {
+      const props = record.fields
+        .map((field) => property(field.key, `${type(field)}?`, `Field_${field.key}`))
+        .join('');
+      if (!record.component)
+        return `public sealed record ${record.name}\n{\n${props}}\n`;
+      const isBlock = blockNames.has(record.parent);
+      return `public sealed record ${record.name}${isBlock ? ` : ${record.parent}` : ''}
+{
+${property('id', 'string', 'Id', ' = "";')}    [JsonPropertyName("type")]
+    public string Type => ${quote(record.key)};
+${property('fields', `${record.name}Fields`, 'Fields', ' = new();')}}
+public sealed record ${record.name}Fields
+{
+${props}}
+`;
+    })
+    .join('\n');
+  return `// Generated by Lemonade CMS. Do not edit. .NET8+; System.Text.Json only.
+// Every model field allows historical absence/null; previews may be incomplete.
+// DTOs are transport contracts, not full content/schema validation.
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Lemonade.Content;
+
+public sealed record ContentReference<TFields>
+{
+${property('id', 'string', 'Id', ' = "";')}${property('fields', 'TFields?', 'Fields')}${property('published_at', 'string?', 'PublishedAt')}}
+public sealed record ContentRendition
+{
+${property('key', 'string', 'Key', ' = "";')}${property('preset', 'string', 'Preset', ' = "";')}${property('width', 'int', 'Width')}${property('height', 'int', 'Height')}${property('content_type', 'string', 'ContentType', ' = "";')}${property('url', 'string', 'Url', ' = "";')}}
+public sealed record FocalPoint
+{
+${property('x', 'double', 'X')}${property('y', 'double', 'Y')}}
+public sealed record AssetMetadata
+{
+${property('title', 'string?', 'Title')}${property('alt', 'string?', 'Alt')}${property('description', 'string?', 'Description')}${property('focal_point', 'FocalPoint?', 'FocalPoint')}}
+public sealed record ContentAsset
+{
+${property('id', 'string', 'Id', ' = "";')}${property('url', 'string', 'Url', ' = "";')}${property('content_type', 'string', 'ContentType', ' = "";')}${property('byte_size', 'long', 'ByteSize')}${property('metadata', 'AssetMetadata', 'Metadata', ' = new();')}${property('renditions', 'List<ContentRendition>?', 'Renditions')}}
+// Preserve versioned rich-text JSON. CMS node/target validation stays authoritative.
+public sealed record ContentRichText
+{
+${property('version', 'int', 'Version')}${property('document', 'JsonElement', 'Document')}}
+public sealed record ContentEntry<TFields>
+{
+${property('id', 'string', 'Id', ' = "";')}${property('fields', 'TFields?', 'Fields')}${property('published_at', 'string?', 'PublishedAt')}${property('remote', 'JsonElement?', 'Remote')}}
+public sealed record PageMeta
+{
+${property('next_cursor', 'string?', 'NextCursor')}${property('limit', 'int', 'Limit')}${property('page', 'int?', 'Page')}${property('page_size', 'int?', 'PageSize')}${property('previous_cursor', 'string?', 'PreviousCursor')}${property('has_next_page', 'bool?', 'HasNextPage')}${property('has_previous_page', 'bool?', 'HasPreviousPage')}}
+public sealed record ContentPage<TFields>
+{
+${property('data', 'List<ContentEntry<TFields>>', 'Data', ' = new();')}${property('meta', 'PageMeta?', 'Meta')}}
+public abstract class StringChoiceConverter<T> : JsonConverter<T> where T : struct, Enum
+{
+    protected abstract string[] Values { get; }
+    public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType != JsonTokenType.String) throw new JsonException("Expected string choice.");
+        var index = Array.IndexOf(Values, reader.GetString());
+        if (index < 0) throw new JsonException("Unknown choice.");
+        return (T)Enum.ToObject(typeof(T), index);
+    }
+    public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options)
+    {
+        var index = Convert.ToInt32(value);
+        if (index < 0 || index >= Values.Length) throw new JsonException("Unknown choice.");
+        writer.WriteStringValue(Values[index]);
+    }
+}
+
+${choiceTypes}
+${blocks}
+${objects}`;
+}

package/bin/codegen/definitions.mjs

@@ -0,0 +1,52 @@
+export const languages = Object.freeze(['typescript', 'csharp', 'python']);
+
+export function definitions(schema) {
+  const used = new Set();
+  function symbol(base) {
+    let name = base;
+    for (let suffix = 2; used.has(name); suffix++) name = `${base}_${suffix}`;
+    used.add(name);
+    return name;
+  }
+  const models = [...schema.models].sort((a, b) =>
+    a.key < b.key ? -1 : a.key > b.key ? 1 : 0,
+  );
+  const names = new Map(
+    models.map((model) => [model.key, symbol(`Model_${model.key}`)]),
+  );
+  const records = [];
+  const choices = [];
+  function fields(values, owner) {
+    return values.map((field) => {
+      const result = { ...field };
+      if (['choice', 'choices'].includes(field.type)) {
+        result.name = symbol(`Choice_${owner}_${field.key}`);
+        choices.push(result);
+      }
+      if (['component', 'components', 'blocks'].includes(field.type)) {
+        result.name = symbol(`Block_${owner}_${field.key}`);
+        result.variants = field.components.map((component) => {
+          const name = symbol(`Component_${owner}_${field.key}_${component.key}`);
+          const record = {
+            name,
+            key: component.key,
+            fields: fields(component.fields, name),
+            component: true,
+            parent: result.name,
+          };
+          records.push(record);
+          return record;
+        });
+      }
+      return result;
+    });
+  }
+  for (const model of models)
+    records.push({
+      name: names.get(model.key),
+      key: model.key,
+      fields: fields(model.fields, model.key),
+      component: false,
+    });
+  return { records, choices, names };
+}

package/bin/codegen/languages.mjs

@@ -0,0 +1,16 @@
+import { validateSchema } from '../cli/schema.mjs';
+import { generateTypes } from '../generate-types.mjs';
+import { generatePython } from './python.mjs';
+import { generateCSharp } from './csharp.mjs';
+import { languages } from './definitions.mjs';
+
+export { languages } from './definitions.mjs';
+
+// All new targets consume the same bounded, validated export. The legacy
+// TypeScript generator and its byte-for-byte output remain compatible.
+export function generateLanguage(schema, language = 'typescript') {
+  if (!languages.includes(language)) throw new Error('Unsupported output language.');
+  validateSchema(schema);
+  if (language === 'typescript') return generateTypes(schema);
+  return language === 'python' ? generatePython(schema) : generateCSharp(schema);
+}