@palantir/pack.document-schema.type-gen 0.8.0 → 0.9.0

package/build/esm/utils/schema/generateVersionedTypesFromSchema.js

@@ -0,0 +1,281 @@
+/*
+ * Copyright 2026 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { formatVariantName } from "../formatVariantName.js";
+import { GENERATED_FILE_HEADER } from "../generatedFileHeader.js";
+import { resolveSchemaChain } from "./resolveSchemaChain.js";
+import { findRecordExportName, isRecordSchema, isUnionSchema, TypeKind, typesFilePath, versionedTypeName, versionedWriteTypeName } from "./runtimeSchema.js";
+function detectUsedRefTypes(schema) {
+  const refTypes = new Set();
+  function scanField(field) {
+    switch (field.type) {
+      case TypeKind.ARRAY:
+        if (field.items) scanField(field.items);
+        break;
+      case TypeKind.DOC_REF:
+        refTypes.add("DocumentRef");
+        break;
+      case TypeKind.MEDIA_REF:
+        refTypes.add("MediaRef");
+        break;
+      case TypeKind.OBJECT_REF:
+        refTypes.add("ObjectRef");
+        break;
+      case TypeKind.OPTIONAL:
+        if (field.item) scanField(field.item);
+        break;
+      case TypeKind.USER_REF:
+        refTypes.add("UserRef");
+        break;
+    }
+  }
+  for (const item of Object.values(schema)) {
+    if (isRecordSchema(item)) {
+      for (const f of Object.values(item.fields)) {
+        scanField(f);
+      }
+    } else if (isUnionSchema(item)) {
+      for (const v of Object.values(item.variants)) {
+        scanField(v);
+      }
+    }
+  }
+  return refTypes;
+}
+function collectReferencedTypes(fieldType, schema, version, out) {
+  switch (fieldType.type) {
+    case TypeKind.ARRAY:
+      if (fieldType.items) collectReferencedTypes(fieldType.items, schema, version, out);
+      break;
+    case TypeKind.OPTIONAL:
+      if (fieldType.item) collectReferencedTypes(fieldType.item, schema, version, out);
+      break;
+    case TypeKind.REF:
+      {
+        const name = fieldType.refType === "record" ? findRecordExportName(fieldType.name, schema) ?? fieldType.name : fieldType.name;
+        if (name == null) {
+          throw new Error(`Could not find name for ref: ${fieldType.type}:${fieldType.refType}`);
+        }
+        out.add(versionedTypeName(name, version));
+        break;
+      }
+  }
+}
+function convertTypeToTypeScript(fieldType, schema, version) {
+  switch (fieldType.type) {
+    case TypeKind.ANY:
+      return "any";
+    case TypeKind.ARRAY:
+      if (fieldType.items == null) {
+        throw new Error("Array field is missing items type");
+      }
+      return `readonly ${convertTypeToTypeScript(fieldType.items, schema, version)}[]`;
+    case TypeKind.BOOLEAN:
+      return "boolean";
+    case TypeKind.DOC_REF:
+      return "DocumentRef";
+    case TypeKind.DOUBLE:
+      return "number";
+    case TypeKind.MEDIA_REF:
+      return "MediaRef";
+    case TypeKind.OBJECT_REF:
+      return "ObjectRef";
+    case TypeKind.OPTIONAL:
+      if (fieldType.item == null) {
+        throw new Error("Optional field is missing inner type");
+      }
+      return convertTypeToTypeScript(fieldType.item, schema, version);
+    case TypeKind.REF:
+      {
+        const name = fieldType.refType === "record" && schema != null ? findRecordExportName(fieldType.name, schema) ?? fieldType.name : fieldType.name;
+        if (name == null) {
+          throw new Error(`Could not find name for ref: ${fieldType.type}:${fieldType.refType}`);
+        }
+        return version != null ? versionedTypeName(name, version) : name;
+      }
+    case TypeKind.STRING:
+      return "string";
+    case TypeKind.USER_REF:
+      return "UserRef";
+    default:
+      throw new Error(`Unknown schema field type: ${fieldType.type}`);
+  }
+}
+
+/**
+ * Generate read types for a specific schema version.
+ */
+function generateReadTypesForVersion(version, schema) {
+  const usedRefTypes = detectUsedRefTypes(schema);
+  let output = GENERATED_FILE_HEADER;
+  if (usedRefTypes.size > 0) {
+    const refTypesList = Array.from(usedRefTypes).sort().join(", ");
+    output += `import type { ${refTypesList} } from "@palantir/pack.document-schema.model-types";\n`;
+  }
+  output += "\n";
+
+  // Generate record interfaces
+  for (const [exportName, item] of Object.entries(schema)) {
+    if (!isRecordSchema(item)) continue;
+    const typeName = versionedTypeName(exportName, version);
+    if (item.docs) {
+      output += `/**\n * ${item.docs}\n */\n`;
+    }
+    output += `export interface ${typeName} {\n`;
+    for (const [fieldName, fieldType] of Object.entries(item.fields)) {
+      const tsType = convertTypeToTypeScript(fieldType, schema, version);
+      const optional = fieldType.type === TypeKind.OPTIONAL ? "?" : "";
+      output += `  readonly ${fieldName}${optional}: ${tsType};\n`;
+    }
+    output += "}\n\n";
+  }
+
+  // Generate union types
+  const unionEntries = Object.entries(schema).filter(([_, item]) => isUnionSchema(item));
+  for (const [exportName, item] of unionEntries) {
+    if (!isUnionSchema(item)) continue;
+    const typeName = versionedTypeName(exportName, version);
+    const discriminantField = item.discriminant;
+    const variantInterfaces = [];
+    for (const [variantName, variantType] of Object.entries(item.variants)) {
+      const interfaceName = `${typeName}${formatVariantName(variantName)}`;
+      variantInterfaces.push({
+        name: interfaceName,
+        discriminatorValue: variantName
+      });
+      if (variantType.type === TypeKind.REF && variantType.refType === "record") {
+        const recordExport = findRecordExportName(variantType.name, schema);
+        const recordTypeName = recordExport ? versionedTypeName(recordExport, version) : variantType.name;
+        output += `export interface ${interfaceName} extends ${recordTypeName} {\n`;
+        output += `  readonly ${discriminantField}: "${variantName}";\n`;
+        output += "}\n\n";
+      } else {
+        const tsType = convertTypeToTypeScript(variantType, schema, version);
+        output += `export interface ${interfaceName} {\n`;
+        output += `  readonly ${discriminantField}: "${variantName}";\n`;
+        output += `  readonly value: ${tsType};\n`;
+        output += "}\n\n";
+      }
+    }
+    output += `export type ${typeName} = ${variantInterfaces.map(v => v.name).join(" | ")};\n\n`;
+    for (const variant of variantInterfaces) {
+      output += `export function is${variant.name}(value: ${typeName}): value is ${variant.name} {\n`;
+      output += `  return value.${discriminantField} === "${variant.discriminatorValue}";\n`;
+      output += "}\n\n";
+    }
+  }
+  return output;
+}
+
+/**
+ * Generate write types for a specific schema version.
+ * All fields are optional in write types.
+ */
+function generateWriteTypesForVersion(version, schema) {
+  const usedRefTypes = detectUsedRefTypes(schema);
+
+  // Collect referenced schema-local types (refs to other records/unions)
+  const referencedLocalTypes = new Set();
+  for (const item of Object.values(schema)) {
+    if (!isRecordSchema(item)) continue;
+    for (const fieldType of Object.values(item.fields)) {
+      collectReferencedTypes(fieldType, schema, version, referencedLocalTypes);
+    }
+  }
+  let output = GENERATED_FILE_HEADER;
+  if (usedRefTypes.size > 0) {
+    const refTypesList = Array.from(usedRefTypes).sort().join(", ");
+    output += `import type { ${refTypesList} } from "@palantir/pack.document-schema.model-types";\n`;
+  }
+  if (referencedLocalTypes.size > 0) {
+    const localTypesList = Array.from(referencedLocalTypes).sort().join(", ");
+    output += `import type { ${localTypesList} } from "${typesFilePath(version)}";\n`;
+  }
+  output += "\n";
+
+  // Generate record write types
+  for (const [exportName, item] of Object.entries(schema)) {
+    if (!isRecordSchema(item)) continue;
+    const typeName = versionedWriteTypeName(exportName, version);
+    output += `export type ${typeName} = {\n`;
+    for (const [fieldName, fieldType] of Object.entries(item.fields)) {
+      // All fields are optional in write types
+      const tsType = convertTypeToTypeScript(fieldType, schema, version);
+      output += `  readonly ${fieldName}?: ${tsType};\n`;
+    }
+    output += "};\n\n";
+  }
+  return output;
+}
+
+/**
+ * Generate the types.ts re-export file that maps unversioned names to the latest version.
+ */
+function generateTypesReExport({
+  schema,
+  version
+}) {
+  const reExports = [];
+  for (const [exportName, item] of Object.entries(schema)) {
+    if (isRecordSchema(item)) {
+      const versioned = versionedTypeName(exportName, version);
+      reExports.push(`export type { ${versioned} as ${exportName} } from "${typesFilePath(version)}";`);
+    } else if (isUnionSchema(item)) {
+      const versioned = versionedTypeName(exportName, version);
+      reExports.push(`export type { ${versioned} as ${exportName} } from "${typesFilePath(version)}";`);
+
+      // Also re-export union variant types
+      for (const variantName of Object.keys(item.variants)) {
+        const formattedVariant = formatVariantName(variantName);
+        const versionedVariant = `${versionedTypeName(exportName, version)}${formattedVariant}`;
+        reExports.push(`export type { ${versionedVariant} as ${`${exportName}${formattedVariant}`} } from "${typesFilePath(version)}";`);
+      }
+    }
+  }
+  return GENERATED_FILE_HEADER + reExports.join("\n") + "\n";
+}
+
+/**
+ * Generate per-version public types and write types from a schema with version chain.
+ *
+ * @param schema - The schema, initial or versioned
+ * @param minSupportedVersion - Minimum version to generate types for (defaults to latest)
+ * @returns Object containing generated code for each output file
+ */
+export function generateVersionedTypesFromSchema(schema, minSupportedVersion) {
+  const {
+    chain,
+    latestVersion,
+    minVersion
+  } = resolveSchemaChain(schema, minSupportedVersion);
+  const readTypes = new Map();
+  const writeTypes = new Map();
+  for (const {
+    version,
+    schema: versionSchema
+  } of chain) {
+    if (version < minVersion) continue;
+    readTypes.set(version, generateReadTypesForVersion(version, versionSchema));
+    writeTypes.set(version, generateWriteTypesForVersion(version, versionSchema));
+  }
+  const typesReExport = generateTypesReExport(chain[chain.length - 1]);
+  return {
+    readTypes,
+    writeTypes,
+    typesReExport
+  };
+}
+//# sourceMappingURL=generateVersionedTypesFromSchema.js.map

package/build/esm/utils/schema/generateVersionedTypesFromSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateVersionedTypesFromSchema.js","names":["formatVariantName","GENERATED_FILE_HEADER","resolveSchemaChain","findRecordExportName","isRecordSchema","isUnionSchema","TypeKind","typesFilePath","versionedTypeName","versionedWriteTypeName","detectUsedRefTypes","schema","refTypes","Set","scanField","field","type","ARRAY","items","DOC_REF","add","MEDIA_REF","OBJECT_REF","OPTIONAL","item","USER_REF","Object","values","f","fields","v","variants","collectReferencedTypes","fieldType","version","out","REF","name","refType","Error","convertTypeToTypeScript","ANY","BOOLEAN","DOUBLE","STRING","generateReadTypesForVersion","usedRefTypes","output","size","refTypesList","Array","from","sort","join","exportName","entries","typeName","docs","fieldName","tsType","optional","unionEntries","filter","_","discriminantField","discriminant","variantInterfaces","variantName","variantType","interfaceName","push","discriminatorValue","recordExport","recordTypeName","map","variant","generateWriteTypesForVersion","referencedLocalTypes","localTypesList","generateTypesReExport","reExports","versioned","keys","formattedVariant","versionedVariant","generateVersionedTypesFromSchema","minSupportedVersion","chain","latestVersion","minVersion","readTypes","Map","writeTypes","versionSchema","set","typesReExport","length"],"sources":["generateVersionedTypesFromSchema.ts"],"sourcesContent":["/*\n * Copyright 2026 Palantir Technologies, Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { SchemaDefinition } from \"@palantir/pack.schema\";\nimport { formatVariantName } from \"../formatVariantName.js\";\nimport { GENERATED_FILE_HEADER } from \"../generatedFileHeader.js\";\nimport type { VersionedSchemaEntry } from \"./resolveSchemaChain.js\";\nimport { resolveSchemaChain } from \"./resolveSchemaChain.js\";\nimport type { RuntimeSchema, SchemaField } from \"./runtimeSchema.js\";\nimport {\n  findRecordExportName,\n  isRecordSchema,\n  isUnionSchema,\n  TypeKind,\n  typesFilePath,\n  versionedTypeName,\n  versionedWriteTypeName,\n} from \"./runtimeSchema.js\";\n\nexport interface VersionedTypesOutput {\n  /** types_vN.ts files keyed by version number */\n  readTypes: Map<number, string>;\n  /** writeTypes_vN.ts files keyed by version number */\n  writeTypes: Map<number, string>;\n  /** types.ts re-export of latest version types under unversioned names */\n  typesReExport: string;\n}\n\nfunction detectUsedRefTypes(schema: RuntimeSchema): Set<string> {\n  const refTypes = new Set<string>();\n\n  function scanField(field: SchemaField): void {\n    switch (field.type) {\n      case TypeKind.ARRAY:\n        if (field.items) scanField(field.items);\n        break;\n      case TypeKind.DOC_REF:\n        refTypes.add(\"DocumentRef\");\n        break;\n      case TypeKind.MEDIA_REF:\n        refTypes.add(\"MediaRef\");\n        break;\n      case TypeKind.OBJECT_REF:\n        refTypes.add(\"ObjectRef\");\n        break;\n      case TypeKind.OPTIONAL:\n        if (field.item) scanField(field.item);\n        break;\n      case TypeKind.USER_REF:\n        refTypes.add(\"UserRef\");\n        break;\n    }\n  }\n\n  for (const item of Object.values(schema)) {\n    if (isRecordSchema(item)) {\n      for (const f of Object.values(item.fields)) {\n        scanField(f);\n      }\n    } else if (isUnionSchema(item)) {\n      for (const v of Object.values(item.variants)) {\n        scanField(v);\n      }\n    }\n  }\n\n  return refTypes;\n}\n\nfunction collectReferencedTypes(\n  fieldType: SchemaField,\n  schema: RuntimeSchema,\n  version: number,\n  out: Set<string>,\n): void {\n  switch (fieldType.type) {\n    case TypeKind.ARRAY:\n      if (fieldType.items) collectReferencedTypes(fieldType.items, schema, version, out);\n      break;\n    case TypeKind.OPTIONAL:\n      if (fieldType.item) collectReferencedTypes(fieldType.item, schema, version, out);\n      break;\n    case TypeKind.REF: {\n      const name = fieldType.refType === \"record\"\n        ? findRecordExportName(fieldType.name!, schema) ?? fieldType.name\n        : fieldType.name;\n      if (name == null) {\n        throw new Error(`Could not find name for ref: ${fieldType.type}:${fieldType.refType}`);\n      }\n      out.add(versionedTypeName(name, version));\n      break;\n    }\n  }\n}\n\nfunction convertTypeToTypeScript(\n  fieldType: SchemaField,\n  schema?: RuntimeSchema,\n  version?: number,\n): string {\n  switch (fieldType.type) {\n    case TypeKind.ANY:\n      return \"any\";\n    case TypeKind.ARRAY:\n      if (fieldType.items == null) {\n        throw new Error(\"Array field is missing items type\");\n      }\n      return `readonly ${convertTypeToTypeScript(fieldType.items, schema, version)}[]`;\n    case TypeKind.BOOLEAN:\n      return \"boolean\";\n    case TypeKind.DOC_REF:\n      return \"DocumentRef\";\n    case TypeKind.DOUBLE:\n      return \"number\";\n    case TypeKind.MEDIA_REF:\n      return \"MediaRef\";\n    case TypeKind.OBJECT_REF:\n      return \"ObjectRef\";\n    case TypeKind.OPTIONAL:\n      if (fieldType.item == null) {\n        throw new Error(\"Optional field is missing inner type\");\n      }\n      return convertTypeToTypeScript(fieldType.item, schema, version);\n    case TypeKind.REF: {\n      const name = fieldType.refType === \"record\" && schema != null\n        ? findRecordExportName(fieldType.name!, schema) ?? fieldType.name\n        : fieldType.name;\n      if (name == null) {\n        throw new Error(`Could not find name for ref: ${fieldType.type}:${fieldType.refType}`);\n      }\n      return version != null ? versionedTypeName(name, version) : name;\n    }\n    case TypeKind.STRING:\n      return \"string\";\n    case TypeKind.USER_REF:\n      return \"UserRef\";\n    default:\n      throw new Error(`Unknown schema field type: ${fieldType.type}`);\n  }\n}\n\n/**\n * Generate read types for a specific schema version.\n */\nfunction generateReadTypesForVersion(\n  version: number,\n  schema: RuntimeSchema,\n): string {\n  const usedRefTypes = detectUsedRefTypes(schema);\n\n  let output = GENERATED_FILE_HEADER;\n\n  if (usedRefTypes.size > 0) {\n    const refTypesList = Array.from(usedRefTypes).sort().join(\", \");\n    output +=\n      `import type { ${refTypesList} } from \"@palantir/pack.document-schema.model-types\";\\n`;\n  }\n\n  output += \"\\n\";\n\n  // Generate record interfaces\n  for (const [exportName, item] of Object.entries(schema)) {\n    if (!isRecordSchema(item)) continue;\n\n    const typeName = versionedTypeName(exportName, version);\n\n    if (item.docs) {\n      output += `/**\\n * ${item.docs}\\n */\\n`;\n    }\n\n    output += `export interface ${typeName} {\\n`;\n\n    for (const [fieldName, fieldType] of Object.entries(item.fields)) {\n      const tsType = convertTypeToTypeScript(fieldType, schema, version);\n      const optional = fieldType.type === TypeKind.OPTIONAL ? \"?\" : \"\";\n      output += `  readonly ${fieldName}${optional}: ${tsType};\\n`;\n    }\n\n    output += \"}\\n\\n\";\n  }\n\n  // Generate union types\n  const unionEntries = Object.entries(schema).filter(\n    ([_, item]) => isUnionSchema(item),\n  );\n\n  for (const [exportName, item] of unionEntries) {\n    if (!isUnionSchema(item)) continue;\n\n    const typeName = versionedTypeName(exportName, version);\n    const discriminantField = item.discriminant;\n    const variantInterfaces: Array<{ name: string; discriminatorValue: string }> = [];\n\n    for (const [variantName, variantType] of Object.entries(item.variants)) {\n      const interfaceName = `${typeName}${formatVariantName(variantName)}`;\n      variantInterfaces.push({ name: interfaceName, discriminatorValue: variantName });\n\n      if (variantType.type === TypeKind.REF && variantType.refType === \"record\") {\n        const recordExport = findRecordExportName(variantType.name!, schema);\n        const recordTypeName = recordExport\n          ? versionedTypeName(recordExport, version)\n          : variantType.name!;\n        output += `export interface ${interfaceName} extends ${recordTypeName} {\\n`;\n        output += `  readonly ${discriminantField}: \"${variantName}\";\\n`;\n        output += \"}\\n\\n\";\n      } else {\n        const tsType = convertTypeToTypeScript(variantType, schema, version);\n        output += `export interface ${interfaceName} {\\n`;\n        output += `  readonly ${discriminantField}: \"${variantName}\";\\n`;\n        output += `  readonly value: ${tsType};\\n`;\n        output += \"}\\n\\n\";\n      }\n    }\n\n    output += `export type ${typeName} = ${variantInterfaces.map(v => v.name).join(\" | \")};\\n\\n`;\n\n    for (const variant of variantInterfaces) {\n      output +=\n        `export function is${variant.name}(value: ${typeName}): value is ${variant.name} {\\n`;\n      output += `  return value.${discriminantField} === \"${variant.discriminatorValue}\";\\n`;\n      output += \"}\\n\\n\";\n    }\n  }\n\n  return output;\n}\n\n/**\n * Generate write types for a specific schema version.\n * All fields are optional in write types.\n */\nfunction generateWriteTypesForVersion(\n  version: number,\n  schema: RuntimeSchema,\n): string {\n  const usedRefTypes = detectUsedRefTypes(schema);\n\n  // Collect referenced schema-local types (refs to other records/unions)\n  const referencedLocalTypes = new Set<string>();\n  for (const item of Object.values(schema)) {\n    if (!isRecordSchema(item)) continue;\n    for (const fieldType of Object.values(item.fields)) {\n      collectReferencedTypes(fieldType, schema, version, referencedLocalTypes);\n    }\n  }\n\n  let output = GENERATED_FILE_HEADER;\n\n  if (usedRefTypes.size > 0) {\n    const refTypesList = Array.from(usedRefTypes).sort().join(\", \");\n    output +=\n      `import type { ${refTypesList} } from \"@palantir/pack.document-schema.model-types\";\\n`;\n  }\n\n  if (referencedLocalTypes.size > 0) {\n    const localTypesList = Array.from(referencedLocalTypes).sort().join(\", \");\n    output += `import type { ${localTypesList} } from \"${typesFilePath(version)}\";\\n`;\n  }\n\n  output += \"\\n\";\n\n  // Generate record write types\n  for (const [exportName, item] of Object.entries(schema)) {\n    if (!isRecordSchema(item)) continue;\n\n    const typeName = versionedWriteTypeName(exportName, version);\n\n    output += `export type ${typeName} = {\\n`;\n\n    for (const [fieldName, fieldType] of Object.entries(item.fields)) {\n      // All fields are optional in write types\n      const tsType = convertTypeToTypeScript(fieldType, schema, version);\n      output += `  readonly ${fieldName}?: ${tsType};\\n`;\n    }\n\n    output += \"};\\n\\n\";\n  }\n\n  return output;\n}\n\n/**\n * Generate the types.ts re-export file that maps unversioned names to the latest version.\n */\nfunction generateTypesReExport({ schema, version }: VersionedSchemaEntry): string {\n  const reExports: string[] = [];\n  for (const [exportName, item] of Object.entries(schema)) {\n    if (isRecordSchema(item)) {\n      const versioned = versionedTypeName(exportName, version);\n      reExports.push(\n        `export type { ${versioned} as ${exportName} } from \"${typesFilePath(version)}\";`,\n      );\n    } else if (isUnionSchema(item)) {\n      const versioned = versionedTypeName(exportName, version);\n      reExports.push(\n        `export type { ${versioned} as ${exportName} } from \"${typesFilePath(version)}\";`,\n      );\n\n      // Also re-export union variant types\n      for (const variantName of Object.keys(item.variants)) {\n        const formattedVariant = formatVariantName(variantName);\n        const versionedVariant = `${versionedTypeName(exportName, version)}${formattedVariant}`;\n        const unversionedVariant = `${exportName}${formattedVariant}`;\n        reExports.push(\n          `export type { ${versionedVariant} as ${unversionedVariant} } from \"${\n            typesFilePath(version)\n          }\";`,\n        );\n      }\n    }\n  }\n\n  return GENERATED_FILE_HEADER + reExports.join(\"\\n\") + \"\\n\";\n}\n\n/**\n * Generate per-version public types and write types from a schema with version chain.\n *\n * @param schema - The schema, initial or versioned\n * @param minSupportedVersion - Minimum version to generate types for (defaults to latest)\n * @returns Object containing generated code for each output file\n */\nexport function generateVersionedTypesFromSchema(\n  schema: SchemaDefinition,\n  minSupportedVersion?: number,\n): VersionedTypesOutput {\n  const { chain, latestVersion, minVersion } = resolveSchemaChain(schema, minSupportedVersion);\n\n  const readTypes = new Map<number, string>();\n  const writeTypes = new Map<number, string>();\n\n  for (const { version, schema: versionSchema } of chain) {\n    if (version < minVersion) continue;\n\n    readTypes.set(version, generateReadTypesForVersion(version, versionSchema));\n    writeTypes.set(version, generateWriteTypesForVersion(version, versionSchema));\n  }\n\n  const typesReExport = generateTypesReExport(chain[chain.length - 1]!);\n\n  return { readTypes, writeTypes, typesReExport };\n}\n"],"mappings":"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","ignoreList":[]}

package/build/esm/utils/schema/generateVersionedZodFromSchema.js

@@ -0,0 +1,189 @@
+/*
+ * Copyright 2026 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { formatVariantName } from "../formatVariantName.js";
+import { GENERATED_FILE_HEADER } from "../generatedFileHeader.js";
+import { resolveSchemaChain } from "./resolveSchemaChain.js";
+import { findRecordExportName, isRecordSchema, isUnionSchema, schemaName, TypeKind, typesFilePath, versionedSchemaName, versionedTypeName } from "./runtimeSchema.js";
+function convertFieldTypeToZodSchema(fieldType, schema, version) {
+  switch (fieldType.type) {
+    case TypeKind.ANY:
+      return "z.unknown()";
+    case TypeKind.ARRAY:
+      if (fieldType.items == null) {
+        throw new Error("Array field is missing items type");
+      }
+      return `z.array(${convertFieldTypeToZodSchema(fieldType.items, schema, version)})`;
+    case TypeKind.BOOLEAN:
+      return "z.boolean()";
+    case TypeKind.DOC_REF:
+      return "z.string()";
+    case TypeKind.DOUBLE:
+      return "z.number()";
+    case TypeKind.MEDIA_REF:
+      return "z.string()";
+    case TypeKind.OBJECT_REF:
+      return "z.string()";
+    case TypeKind.OPTIONAL:
+      if (fieldType.item == null) {
+        throw new Error("Optional field is missing inner type");
+      }
+      return `${convertFieldTypeToZodSchema(fieldType.item, schema, version)}.optional()`;
+    case TypeKind.REF:
+      {
+        if (fieldType.name == null) {
+          throw new Error("Ref field is missing a name");
+        }
+        const exportName = fieldType.refType === "record" && schema ? findRecordExportName(fieldType.name, schema) ?? fieldType.name : fieldType.name;
+        const refSchemaName = version != null ? versionedSchemaName(exportName, version) : `${exportName}Schema`;
+        const refTypeName = version != null ? versionedTypeName(exportName, version) : exportName;
+        return `z.lazy((): ZodType<${refTypeName}> => ${refSchemaName})`;
+      }
+    case TypeKind.STRING:
+      return "z.string()";
+    case TypeKind.USER_REF:
+      return "z.string()";
+    default:
+      throw new Error(`Unknown schema field type: ${fieldType.type}`);
+  }
+}
+
+/**
+ * Generate Zod schemas for a specific schema version.
+ * Uses `.passthrough()` to preserve unknown fields.
+ */
+function generateZodSchemasForVersion(version, schema) {
+  let output = GENERATED_FILE_HEADER;
+
+  // Collect type names for import
+  const typeNames = [];
+  for (const [exportName, item] of Object.entries(schema)) {
+    if (isRecordSchema(item)) {
+      typeNames.push(versionedTypeName(exportName, version));
+    } else if (isUnionSchema(item)) {
+      typeNames.push(versionedTypeName(exportName, version));
+      for (const variantName of Object.keys(item.variants)) {
+        typeNames.push(`${versionedTypeName(exportName, version)}${formatVariantName(variantName)}`);
+      }
+    }
+  }
+  output += "import type { ZodType } from \"zod\";\n";
+  output += "import { z } from \"zod\";\n";
+  if (typeNames.length > 0) {
+    output += `import type { ${typeNames.sort().join(", ")} } from "${typesFilePath(version)}";\n`;
+  }
+  output += "\n";
+
+  // Generate record schemas first (unions may depend on them)
+  for (const [exportName, item] of Object.entries(schema)) {
+    if (!isRecordSchema(item)) continue;
+    const zodSchemaName = versionedSchemaName(exportName, version);
+    const typeName = versionedTypeName(exportName, version);
+    const fieldLines = [];
+    for (const [fieldName, fieldType] of Object.entries(item.fields)) {
+      const zodType = convertFieldTypeToZodSchema(fieldType, schema, version);
+      fieldLines.push(`  ${fieldName}: ${zodType}`);
+    }
+    output += `export const ${zodSchemaName} = z.object({\n${fieldLines.join(",\n")}\n}).passthrough() satisfies ZodType<${typeName}>;\n\n`;
+  }
+
+  // Generate union schemas
+  for (const [exportName, item] of Object.entries(schema)) {
+    if (!isUnionSchema(item)) continue;
+    const discriminantField = item.discriminant;
+    const variantSchemaNames = [];
+    for (const [variantName, variantType] of Object.entries(item.variants)) {
+      const formattedVariant = formatVariantName(variantName);
+      const variantZodSchemaName = `${versionedSchemaName(exportName, version)}${formattedVariant}`;
+      const variantTypeName = `${versionedTypeName(exportName, version)}${formattedVariant}`;
+      variantSchemaNames.push(variantZodSchemaName);
+      if (variantType.type === TypeKind.REF && variantType.refType === "record") {
+        const recordExport = findRecordExportName(variantType.name, schema);
+        const recordZodSchemaName = recordExport ? versionedSchemaName(recordExport, version) : `${variantType.name}Schema`;
+        output += `export const ${variantZodSchemaName} = ${recordZodSchemaName}.extend({\n`;
+        output += `  ${discriminantField}: z.literal("${variantName}")\n`;
+        output += `}) satisfies ZodType<${variantTypeName}>;\n\n`;
+      } else {
+        const zodType = convertFieldTypeToZodSchema(variantType, schema, version);
+        output += `export const ${variantZodSchemaName} = z.object({\n`;
+        output += `  ${discriminantField}: z.literal("${variantName}"),\n`;
+        output += `  value: ${zodType}\n`;
+        output += `}) satisfies ZodType<${variantTypeName}>;\n\n`;
+      }
+    }
+    const unionZodSchemaName = versionedSchemaName(exportName, version);
+    const typeName = versionedTypeName(exportName, version);
+    output += `export const ${unionZodSchemaName} = z.discriminatedUnion("${discriminantField}", [\n  ${variantSchemaNames.join(",\n  ")}\n]) satisfies ZodType<${typeName}>;\n\n`;
+  }
+  return output;
+}
+
+/**
+ * Generate the schema.ts re-export file mapping unversioned names to latest version.
+ */
+function generateSchemaReExport({
+  schema,
+  version
+}) {
+  let output = GENERATED_FILE_HEADER;
+  const reExports = [];
+  for (const [exportName, item] of Object.entries(schema)) {
+    if (isRecordSchema(item)) {
+      const versioned = versionedSchemaName(exportName, version);
+      reExports.push(`export { ${versioned} as ${schemaName(exportName)} } from "./schema_v${version}.js";`);
+    } else if (isUnionSchema(item)) {
+      const versioned = versionedSchemaName(exportName, version);
+      reExports.push(`export { ${versioned} as ${schemaName(exportName)} } from "./schema_v${version}.js";`);
+
+      // Also re-export union variant schemas
+      for (const variantName of Object.keys(item.variants)) {
+        const formattedVariant = formatVariantName(variantName);
+        const versionedVariant = `${versionedSchemaName(exportName, version)}${formattedVariant}`;
+        reExports.push(`export { ${versionedVariant} as ${`${exportName}${formattedVariant}Schema`} } from "./schema_v${version}.js";`);
+      }
+    }
+  }
+  output += reExports.join("\n") + "\n";
+  return output;
+}
+
+/**
+ * Generate per-version Zod schemas from a schema definition with version chain.
+ *
+ * @param schema - The schema definition (initial or versioned)
+ * @param minSupportedVersion - Minimum version to generate schemas for (defaults to latest)
+ * @returns Object containing generated Zod schema code for each output file
+ */
+export function generateVersionedZodFromSchema(schema, minSupportedVersion) {
+  const {
+    chain,
+    minVersion
+  } = resolveSchemaChain(schema, minSupportedVersion);
+  const zodSchemas = new Map();
+  for (const {
+    version,
+    schema: versionSchema
+  } of chain) {
+    if (version < minVersion) continue;
+    zodSchemas.set(version, generateZodSchemasForVersion(version, versionSchema));
+  }
+  const schemaReExport = generateSchemaReExport(chain[chain.length - 1]);
+  return {
+    zodSchemas,
+    schemaReExport
+  };
+}
+//# sourceMappingURL=generateVersionedZodFromSchema.js.map

package/build/esm/utils/schema/generateVersionedZodFromSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateVersionedZodFromSchema.js","names":["formatVariantName","GENERATED_FILE_HEADER","resolveSchemaChain","findRecordExportName","isRecordSchema","isUnionSchema","schemaName","TypeKind","typesFilePath","versionedSchemaName","versionedTypeName","convertFieldTypeToZodSchema","fieldType","schema","version","type","ANY","ARRAY","items","Error","BOOLEAN","DOC_REF","DOUBLE","MEDIA_REF","OBJECT_REF","OPTIONAL","item","REF","name","exportName","refType","refSchemaName","refTypeName","STRING","USER_REF","generateZodSchemasForVersion","output","typeNames","Object","entries","push","variantName","keys","variants","length","sort","join","zodSchemaName","typeName","fieldLines","fieldName","fields","zodType","discriminantField","discriminant","variantSchemaNames","variantType","formattedVariant","variantZodSchemaName","variantTypeName","recordExport","recordZodSchemaName","unionZodSchemaName","generateSchemaReExport","reExports","versioned","versionedVariant","generateVersionedZodFromSchema","minSupportedVersion","chain","minVersion","zodSchemas","Map","versionSchema","set","schemaReExport"],"sources":["generateVersionedZodFromSchema.ts"],"sourcesContent":["/*\n * Copyright 2026 Palantir Technologies, Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { SchemaDefinition } from \"@palantir/pack.schema\";\nimport { formatVariantName } from \"../formatVariantName.js\";\nimport { GENERATED_FILE_HEADER } from \"../generatedFileHeader.js\";\nimport type { VersionedSchemaEntry } from \"./resolveSchemaChain.js\";\nimport { resolveSchemaChain } from \"./resolveSchemaChain.js\";\nimport type { RuntimeSchema, SchemaField } from \"./runtimeSchema.js\";\nimport {\n  findRecordExportName,\n  isRecordSchema,\n  isUnionSchema,\n  schemaName,\n  TypeKind,\n  typesFilePath,\n  versionedSchemaName,\n  versionedTypeName,\n} from \"./runtimeSchema.js\";\n\nexport interface VersionedZodOutput {\n  /** schema_vN.ts files keyed by version number */\n  zodSchemas: Map<number, string>;\n  /** schema.ts re-export of latest version schemas under unversioned names */\n  schemaReExport: string;\n}\n\nfunction convertFieldTypeToZodSchema(\n  fieldType: SchemaField,\n  schema?: RuntimeSchema,\n  version?: number,\n): string {\n  switch (fieldType.type) {\n    case TypeKind.ANY:\n      return \"z.unknown()\";\n    case TypeKind.ARRAY:\n      if (fieldType.items == null) {\n        throw new Error(\"Array field is missing items type\");\n      }\n      return `z.array(${convertFieldTypeToZodSchema(fieldType.items, schema, version)})`;\n    case TypeKind.BOOLEAN:\n      return \"z.boolean()\";\n    case TypeKind.DOC_REF:\n      return \"z.string()\";\n    case TypeKind.DOUBLE:\n      return \"z.number()\";\n    case TypeKind.MEDIA_REF:\n      return \"z.string()\";\n    case TypeKind.OBJECT_REF:\n      return \"z.string()\";\n    case TypeKind.OPTIONAL:\n      if (fieldType.item == null) {\n        throw new Error(\"Optional field is missing inner type\");\n      }\n      return `${convertFieldTypeToZodSchema(fieldType.item, schema, version)}.optional()`;\n    case TypeKind.REF: {\n      if (fieldType.name == null) {\n        throw new Error(\"Ref field is missing a name\");\n      }\n      const exportName = fieldType.refType === \"record\" && schema\n        ? findRecordExportName(fieldType.name, schema) ?? fieldType.name\n        : fieldType.name;\n      const refSchemaName = version != null\n        ? versionedSchemaName(exportName, version)\n        : `${exportName}Schema`;\n      const refTypeName = version != null ? versionedTypeName(exportName, version) : exportName;\n      return `z.lazy((): ZodType<${refTypeName}> => ${refSchemaName})`;\n    }\n    case TypeKind.STRING:\n      return \"z.string()\";\n    case TypeKind.USER_REF:\n      return \"z.string()\";\n    default:\n      throw new Error(`Unknown schema field type: ${fieldType.type}`);\n  }\n}\n\n/**\n * Generate Zod schemas for a specific schema version.\n * Uses `.passthrough()` to preserve unknown fields.\n */\nfunction generateZodSchemasForVersion(\n  version: number,\n  schema: RuntimeSchema,\n): string {\n  let output = GENERATED_FILE_HEADER;\n\n  // Collect type names for import\n  const typeNames: string[] = [];\n  for (const [exportName, item] of Object.entries(schema)) {\n    if (isRecordSchema(item)) {\n      typeNames.push(versionedTypeName(exportName, version));\n    } else if (isUnionSchema(item)) {\n      typeNames.push(versionedTypeName(exportName, version));\n      for (const variantName of Object.keys(item.variants)) {\n        typeNames.push(\n          `${versionedTypeName(exportName, version)}${formatVariantName(variantName)}`,\n        );\n      }\n    }\n  }\n\n  output += \"import type { ZodType } from \\\"zod\\\";\\n\";\n  output += \"import { z } from \\\"zod\\\";\\n\";\n\n  if (typeNames.length > 0) {\n    output += `import type { ${typeNames.sort().join(\", \")} } from \"${typesFilePath(version)}\";\\n`;\n  }\n\n  output += \"\\n\";\n\n  // Generate record schemas first (unions may depend on them)\n  for (const [exportName, item] of Object.entries(schema)) {\n    if (!isRecordSchema(item)) continue;\n\n    const zodSchemaName = versionedSchemaName(exportName, version);\n    const typeName = versionedTypeName(exportName, version);\n    const fieldLines: string[] = [];\n\n    for (const [fieldName, fieldType] of Object.entries(item.fields)) {\n      const zodType = convertFieldTypeToZodSchema(fieldType, schema, version);\n      fieldLines.push(`  ${fieldName}: ${zodType}`);\n    }\n\n    output += `export const ${zodSchemaName} = z.object({\\n${\n      fieldLines.join(\",\\n\")\n    }\\n}).passthrough() satisfies ZodType<${typeName}>;\\n\\n`;\n  }\n\n  // Generate union schemas\n  for (const [exportName, item] of Object.entries(schema)) {\n    if (!isUnionSchema(item)) continue;\n\n    const discriminantField = item.discriminant;\n    const variantSchemaNames: string[] = [];\n\n    for (const [variantName, variantType] of Object.entries(item.variants)) {\n      const formattedVariant = formatVariantName(variantName);\n      const variantZodSchemaName = `${versionedSchemaName(exportName, version)}${formattedVariant}`;\n      const variantTypeName = `${versionedTypeName(exportName, version)}${formattedVariant}`;\n      variantSchemaNames.push(variantZodSchemaName);\n\n      if (variantType.type === TypeKind.REF && variantType.refType === \"record\") {\n        const recordExport = findRecordExportName(variantType.name!, schema);\n        const recordZodSchemaName = recordExport\n          ? versionedSchemaName(recordExport, version)\n          : `${variantType.name!}Schema`;\n        output += `export const ${variantZodSchemaName} = ${recordZodSchemaName}.extend({\\n`;\n        output += `  ${discriminantField}: z.literal(\"${variantName}\")\\n`;\n        output += `}) satisfies ZodType<${variantTypeName}>;\\n\\n`;\n      } else {\n        const zodType = convertFieldTypeToZodSchema(variantType, schema, version);\n        output += `export const ${variantZodSchemaName} = z.object({\\n`;\n        output += `  ${discriminantField}: z.literal(\"${variantName}\"),\\n`;\n        output += `  value: ${zodType}\\n`;\n        output += `}) satisfies ZodType<${variantTypeName}>;\\n\\n`;\n      }\n    }\n\n    const unionZodSchemaName = versionedSchemaName(exportName, version);\n    const typeName = versionedTypeName(exportName, version);\n    output +=\n      `export const ${unionZodSchemaName} = z.discriminatedUnion(\"${discriminantField}\", [\\n  ${\n        variantSchemaNames.join(\",\\n  \")\n      }\\n]) satisfies ZodType<${typeName}>;\\n\\n`;\n  }\n\n  return output;\n}\n\n/**\n * Generate the schema.ts re-export file mapping unversioned names to latest version.\n */\nfunction generateSchemaReExport(\n  { schema, version }: VersionedSchemaEntry,\n): string {\n  let output = GENERATED_FILE_HEADER;\n\n  const reExports: string[] = [];\n\n  for (const [exportName, item] of Object.entries(schema)) {\n    if (isRecordSchema(item)) {\n      const versioned = versionedSchemaName(exportName, version);\n      reExports.push(\n        `export { ${versioned} as ${schemaName(exportName)} } from \"./schema_v${version}.js\";`,\n      );\n    } else if (isUnionSchema(item)) {\n      const versioned = versionedSchemaName(exportName, version);\n      reExports.push(\n        `export { ${versioned} as ${schemaName(exportName)} } from \"./schema_v${version}.js\";`,\n      );\n\n      // Also re-export union variant schemas\n      for (const variantName of Object.keys(item.variants)) {\n        const formattedVariant = formatVariantName(variantName);\n        const versionedVariant = `${versionedSchemaName(exportName, version)}${formattedVariant}`;\n        const unversionedVariant = `${exportName}${formattedVariant}Schema`;\n        reExports.push(\n          `export { ${versionedVariant} as ${unversionedVariant} } from \"./schema_v${version}.js\";`,\n        );\n      }\n    }\n  }\n\n  output += reExports.join(\"\\n\") + \"\\n\";\n\n  return output;\n}\n\n/**\n * Generate per-version Zod schemas from a schema definition with version chain.\n *\n * @param schema - The schema definition (initial or versioned)\n * @param minSupportedVersion - Minimum version to generate schemas for (defaults to latest)\n * @returns Object containing generated Zod schema code for each output file\n */\nexport function generateVersionedZodFromSchema(\n  schema: SchemaDefinition,\n  minSupportedVersion?: number,\n): VersionedZodOutput {\n  const { chain, minVersion } = resolveSchemaChain(schema, minSupportedVersion);\n\n  const zodSchemas = new Map<number, string>();\n\n  for (const { version, schema: versionSchema } of chain) {\n    if (version < minVersion) continue;\n\n    zodSchemas.set(version, generateZodSchemasForVersion(version, versionSchema));\n  }\n\n  const schemaReExport = generateSchemaReExport(chain[chain.length - 1]!);\n\n  return { zodSchemas, schemaReExport };\n}\n"],"mappings":"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","ignoreList":[]}

package/build/esm/utils/schema/generateVersionsFromSchema.js

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2026 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { GENERATED_FILE_HEADER } from "../generatedFileHeader.js";
+import { resolveSchemaChain } from "./resolveSchemaChain.js";
+
+/**
+ * Generate versions.ts from a versioned schema chain.
+ *
+ * Output:
+ * ```
+ * export type SupportedVersions = 1 | 2;
+ * export type LatestVersion = 2;
+ * export type MinSupportedVersion = 1;
+ * ```
+ */
+export function generateVersionsFromSchema(schema, minSupportedVersion) {
+  const {
+    chain,
+    latestVersion,
+    minVersion
+  } = resolveSchemaChain(schema, minSupportedVersion);
+  const supportedVersions = [];
+  for (const {
+    version
+  } of chain) {
+    if (version >= minVersion) {
+      supportedVersions.push(version);
+    }
+  }
+  let output = GENERATED_FILE_HEADER;
+  output += `export type SupportedVersions = ${supportedVersions.join(" | ")};\n`;
+  output += `export type LatestVersion = ${latestVersion};\n`;
+  output += `export type MinSupportedVersion = ${minVersion};\n`;
+  return output;
+}
+//# sourceMappingURL=generateVersionsFromSchema.js.map

package/build/esm/utils/schema/generateVersionsFromSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateVersionsFromSchema.js","names":["GENERATED_FILE_HEADER","resolveSchemaChain","generateVersionsFromSchema","schema","minSupportedVersion","chain","latestVersion","minVersion","supportedVersions","version","push","output","join"],"sources":["generateVersionsFromSchema.ts"],"sourcesContent":["/*\n * Copyright 2026 Palantir Technologies, Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { SchemaDefinition } from \"@palantir/pack.schema\";\nimport { GENERATED_FILE_HEADER } from \"../generatedFileHeader.js\";\nimport { resolveSchemaChain } from \"./resolveSchemaChain.js\";\n\n/**\n * Generate versions.ts from a versioned schema chain.\n *\n * Output:\n * ```\n * export type SupportedVersions = 1 | 2;\n * export type LatestVersion = 2;\n * export type MinSupportedVersion = 1;\n * ```\n */\nexport function generateVersionsFromSchema(\n  schema: SchemaDefinition,\n  minSupportedVersion?: number,\n): string {\n  const { chain, latestVersion, minVersion } = resolveSchemaChain(schema, minSupportedVersion);\n\n  const supportedVersions: number[] = [];\n  for (const { version } of chain) {\n    if (version >= minVersion) {\n      supportedVersions.push(version);\n    }\n  }\n\n  let output = GENERATED_FILE_HEADER;\n  output += `export type SupportedVersions = ${supportedVersions.join(\" | \")};\\n`;\n  output += `export type LatestVersion = ${latestVersion};\\n`;\n  output += `export type MinSupportedVersion = ${minVersion};\\n`;\n\n  return output;\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGA,SAASA,qBAAqB,QAAQ,2BAA2B;AACjE,SAASC,kBAAkB,QAAQ,yBAAyB;;AAE5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,0BAA0BA,CACxCC,MAAwB,EACxBC,mBAA4B,EACpB;EACR,MAAM;IAAEC,KAAK;IAAEC,aAAa;IAAEC;EAAW,CAAC,GAAGN,kBAAkB,CAACE,MAAM,EAAEC,mBAAmB,CAAC;EAE5F,MAAMI,iBAA2B,GAAG,EAAE;EACtC,KAAK,MAAM;IAAEC;EAAQ,CAAC,IAAIJ,KAAK,EAAE;IAC/B,IAAII,OAAO,IAAIF,UAAU,EAAE;MACzBC,iBAAiB,CAACE,IAAI,CAACD,OAAO,CAAC;IACjC;EACF;EAEA,IAAIE,MAAM,GAAGX,qBAAqB;EAClCW,MAAM,IAAI,mCAAmCH,iBAAiB,CAACI,IAAI,CAAC,KAAK,CAAC,KAAK;EAC/ED,MAAM,IAAI,+BAA+BL,aAAa,KAAK;EAC3DK,MAAM,IAAI,qCAAqCJ,UAAU,KAAK;EAE9D,OAAOI,MAAM;AACf","ignoreList":[]}