@palantir/pack.document-schema.type-gen 0.0.1-beta.1

package/build/esm/utils/steps/__tests__/fixtures/stepSchemas/simpleRecord.js

@@ -0,0 +1,23 @@
+const simpleRecord = {
+  "Person": {
+    "type": "record",
+    "name": "Person",
+    "docs": "A person record",
+    "fields": {
+      "name": {
+        "type": "string"
+      },
+      "age": {
+        "type": "double"
+      },
+      "email": {
+        "type": "optional",
+        "item": {
+          "type": "string"
+        }
+      }
+    }
+  }
+};
+export default simpleRecord;
+//# sourceMappingURL=simpleRecord.js.map

package/build/esm/utils/steps/__tests__/fixtures/stepSchemas/simpleRecord.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"simpleRecord.js","names":["simpleRecord"],"sources":["simpleRecord.ts"],"sourcesContent":["import { Schema } from \"@palantir/pack.schema\";\n\nconst simpleRecord = {\n  \"Person\": {\n    \"type\": \"record\",\n    \"name\": \"Person\",\n    \"docs\": \"A person record\",\n    \"fields\": {\n      \"name\": {\n        \"type\": \"string\",\n      },\n      \"age\": {\n        \"type\": \"double\",\n      },\n      \"email\": {\n        \"type\": \"optional\",\n        \"item\": {\n          \"type\": \"string\",\n        },\n      },\n    },\n  },\n} satisfies Schema<any>;\n\nexport default simpleRecord;\n"],"mappings":"AAEA,MAAMA,YAAY,GAAG;EACnB,QAAQ,EAAE;IACR,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,QAAQ;IAChB,MAAM,EAAE,iBAAiB;IACzB,QAAQ,EAAE;MACR,MAAM,EAAE;QACN,MAAM,EAAE;MACV,CAAC;MACD,KAAK,EAAE;QACL,MAAM,EAAE;MACV,CAAC;MACD,OAAO,EAAE;QACP,MAAM,EAAE,UAAU;QAClB,MAAM,EAAE;UACN,MAAM,EAAE;QACV;MACF;IACF;EACF;AACF,CAAuB;AAEvB,eAAeA,YAAY","ignoreList":[]}

package/build/esm/utils/steps/__tests__/generateTypes.test.js

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2025 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 fs from "fs";
+import path from "path";
+import { describe, expect, it } from "vitest";
+import { generateTypesFromSchema } from "../../schema/generateTypesFromSchema.js";
+describe("generateTypes", () => {
+  // TODO: Add runtime validation of schema types instead of just using type assertions
+  // The fixtures currently use the old format with 'recordName' instead of 'name'
+  // and the tests pass because of type assertions that don't validate the actual runtime types
+
+  // Use __dirname which is available in both CJS and when vitest transforms the code
+  const fixturesInputDir = path.join(__dirname, "fixtures", "stepSchemas");
+  const snapshotTypesDir = path.join(__dirname, "__snapshots__", "types");
+
+  // Check if directory exists before reading
+  if (!fs.existsSync(fixturesInputDir)) {
+    throw new Error(`Fixtures directory not found: ${fixturesInputDir}`);
+  }
+  const testFiles = fs.readdirSync(fixturesInputDir).filter(file => file.endsWith(".ts"));
+  testFiles.forEach(testFile => {
+    const testName = path.basename(testFile, ".ts");
+    it(`should handle ${testName}`, async () => {
+      const inputSchema = await import(path.join(fixturesInputDir, testFile));
+      const result = generateTypesFromSchema(inputSchema.default);
+      await expect(result).toMatchFileSnapshot(path.join(snapshotTypesDir, `${testName}.ts`));
+    });
+  });
+});
+//# sourceMappingURL=generateTypes.test.js.map

package/build/esm/utils/steps/__tests__/generateTypes.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateTypes.test.js","names":["fs","path","describe","expect","it","generateTypesFromSchema","fixturesInputDir","join","__dirname","snapshotTypesDir","existsSync","Error","testFiles","readdirSync","filter","file","endsWith","forEach","testFile","testName","basename","inputSchema","result","default","toMatchFileSnapshot"],"sources":["generateTypes.test.ts"],"sourcesContent":["/*\n * Copyright 2025 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 { ReturnedSchema, Schema } from \"@palantir/pack.schema\";\nimport fs from \"fs\";\nimport path from \"path\";\nimport { describe, expect, it } from \"vitest\";\nimport { generateTypesFromSchema } from \"../../schema/generateTypesFromSchema.js\";\n\ndescribe(\"generateTypes\", () => {\n  // TODO: Add runtime validation of schema types instead of just using type assertions\n  // The fixtures currently use the old format with 'recordName' instead of 'name'\n  // and the tests pass because of type assertions that don't validate the actual runtime types\n\n  // Use __dirname which is available in both CJS and when vitest transforms the code\n  const fixturesInputDir = path.join(__dirname, \"fixtures\", \"stepSchemas\");\n  const snapshotTypesDir = path.join(__dirname, \"__snapshots__\", \"types\");\n\n  // Check if directory exists before reading\n  if (!fs.existsSync(fixturesInputDir)) {\n    throw new Error(`Fixtures directory not found: ${fixturesInputDir}`);\n  }\n\n  const testFiles = fs\n    .readdirSync(fixturesInputDir)\n    .filter(file => file.endsWith(\".ts\"));\n\n  testFiles.forEach(testFile => {\n    const testName = path.basename(testFile, \".ts\");\n\n    it(`should handle ${testName}`, async () => {\n      const inputSchema = await import(path.join(fixturesInputDir, testFile)) as {\n        default: Schema<ReturnedSchema>;\n      };\n      const result = generateTypesFromSchema(inputSchema.default);\n\n      await expect(result).toMatchFileSnapshot(path.join(snapshotTypesDir, `${testName}.ts`));\n    });\n  });\n});\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGA,OAAOA,EAAE,MAAM,IAAI;AACnB,OAAOC,IAAI,MAAM,MAAM;AACvB,SAASC,QAAQ,EAAEC,MAAM,EAAEC,EAAE,QAAQ,QAAQ;AAC7C,SAASC,uBAAuB,QAAQ,yCAAyC;AAEjFH,QAAQ,CAAC,eAAe,EAAE,MAAM;EAC9B;EACA;EACA;;EAEA;EACA,MAAMI,gBAAgB,GAAGL,IAAI,CAACM,IAAI,CAACC,SAAS,EAAE,UAAU,EAAE,aAAa,CAAC;EACxE,MAAMC,gBAAgB,GAAGR,IAAI,CAACM,IAAI,CAACC,SAAS,EAAE,eAAe,EAAE,OAAO,CAAC;;EAEvE;EACA,IAAI,CAACR,EAAE,CAACU,UAAU,CAACJ,gBAAgB,CAAC,EAAE;IACpC,MAAM,IAAIK,KAAK,CAAC,iCAAiCL,gBAAgB,EAAE,CAAC;EACtE;EAEA,MAAMM,SAAS,GAAGZ,EAAE,CACjBa,WAAW,CAACP,gBAAgB,CAAC,CAC7BQ,MAAM,CAACC,IAAI,IAAIA,IAAI,CAACC,QAAQ,CAAC,KAAK,CAAC,CAAC;EAEvCJ,SAAS,CAACK,OAAO,CAACC,QAAQ,IAAI;IAC5B,MAAMC,QAAQ,GAAGlB,IAAI,CAACmB,QAAQ,CAACF,QAAQ,EAAE,KAAK,CAAC;IAE/Cd,EAAE,CAAC,iBAAiBe,QAAQ,EAAE,EAAE,YAAY;MAC1C,MAAME,WAAW,GAAG,MAAM,MAAM,CAACpB,IAAI,CAACM,IAAI,CAACD,gBAAgB,EAAEY,QAAQ,CAAC,CAErE;MACD,MAAMI,MAAM,GAAGjB,uBAAuB,CAACgB,WAAW,CAACE,OAAO,CAAC;MAE3D,MAAMpB,MAAM,CAACmB,MAAM,CAAC,CAACE,mBAAmB,CAACvB,IAAI,CAACM,IAAI,CAACE,gBAAgB,EAAE,GAAGU,QAAQ,KAAK,CAAC,CAAC;IACzF,CAAC,CAAC;EACJ,CAAC,CAAC;AACJ,CAAC,CAAC","ignoreList":[]}

package/build/esm/utils/steps/convertStepsToIr.js

@@ -0,0 +1,181 @@
+/*
+ * Copyright 2025 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 { IFieldTypeUnion, IFieldValueUnion, IModelDef } from "@palantir/pack-docschema-api/pack-docschema-ir";
+import invariant from "tiny-invariant";
+import { assertNever } from "../assertNever.js";
+import { convertStepsToSchema } from "./convertStepsToSchema.js";
+/**
+ * Converts migration steps to Palantir IR format
+ */
+export function convertStepsToIr(steps, metadata) {
+  // First convert steps to document-schema-api format
+  const {
+    recordDefinitions,
+    unionDefinitions
+  } = convertStepsToSchema(steps);
+  const schema = {
+    ...Object.fromEntries(recordDefinitions.map(def => [def.name, def])),
+    ...Object.fromEntries(unionDefinitions.map(def => [def.name, def]))
+  };
+  return convertSchemaToIr(schema, metadata);
+}
+
+/**
+ * Converts record and union definitions to Palantir IR format
+ */
+export function convertSchemaToIr(inputSchema, metadata) {
+  const primaryModelKeys = [];
+  const models = new Map();
+  for (const modelDef of Object.values(inputSchema)) {
+    if (collectModels(modelDef, models)) {
+      primaryModelKeys.push(modelDef.name);
+    }
+  }
+  return {
+    name: metadata?.name ?? "Generated Schema",
+    description: metadata?.description ?? "Schema generated from migration steps",
+    version: metadata?.version ?? 1,
+    primaryModelKeys,
+    models: Object.fromEntries(models)
+  };
+}
+function collectModels(modelDef, outModels) {
+  !!outModels.has(modelDef.name) ? process.env.NODE_ENV !== "production" ? invariant(false, `Duplicate model definition: ${modelDef.name}`) : invariant(false) : void 0;
+  switch (modelDef.type) {
+    case "record":
+      {
+        outModels.set(modelDef.name, IModelDef.record(convertRecordDefToIr(modelDef)));
+        return true;
+      }
+    case "union":
+      {
+        outModels.set(modelDef.name, IModelDef.union(convertUnionDefToIr(modelDef)));
+        return true;
+      }
+    default:
+      assertNever(modelDef);
+  }
+}
+export function convertRecordDefToIr(recordDef) {
+  const fields = Object.entries(recordDef.fields).map(([fieldKey, fieldType]) => ({
+    key: fieldKey,
+    name: fieldKey,
+    description: undefined,
+    value: convertTypeToFieldTypeUnion(fieldType),
+    meta: {
+      addedIn: 1
+    },
+    isOptional: fieldType.type === "optional" ? true : undefined
+  }));
+  return {
+    key: recordDef.name,
+    name: recordDef.name,
+    description: recordDef.docs || undefined,
+    fields,
+    meta: {
+      addedIn: 1
+    }
+  };
+}
+export function convertUnionDefToIr(unionDef) {
+  const variantEntries = Object.entries(unionDef.variants).map(([variantName, modelRef]) => [variantName, modelRef.name]);
+  return {
+    key: unionDef.name,
+    name: unionDef.name,
+    description: unionDef.docs,
+    discriminant: unionDef.discriminant,
+    variants: Object.fromEntries(variantEntries),
+    meta: {
+      addedIn: 1
+    }
+  };
+}
+
+// TODO: rename to convertSchemaTypeToFieldTypeUnion
+export function convertTypeToFieldTypeUnion(schemaType) {
+  switch (schemaType.type) {
+    case "array":
+      {
+        return IFieldTypeUnion.array({
+          allowNullValue: false,
+          value: convertTypeToFieldValueUnion(schemaType.items)
+        });
+      }
+    // TODO: have map/set types in document-schema-api
+
+    case "optional":
+      {
+        // Optional flag is handled at field level, but we need to unwrap the inner type
+
+        return convertTypeToFieldTypeUnion(schemaType.item);
+      }
+    case "docRef":
+    case "double":
+    case "mediaRef":
+    case "objectRef":
+    case "ref":
+    case "string":
+    case "unknown":
+    case "userRef":
+      return IFieldTypeUnion.value(convertTypeToFieldValueUnion(schemaType));
+    default:
+      assertNever(schemaType);
+  }
+}
+function convertTypeToFieldValueUnion(schemaType) {
+  switch (schemaType.type) {
+    case "array":
+      // TODO: fix the argument types so these aren't possible
+      process.env.NODE_ENV !== "production" ? invariant(false, `Collection type passed to convertTypeToFieldValueUnion: ${schemaType.type}`) : invariant(false);
+    case "docRef":
+      return IFieldValueUnion.docRef({
+        documentTypeRids: [] // FIXME: confirm whether we will use rids in the deployed schema.
+      });
+    case "double":
+      return IFieldValueUnion.double({});
+    case "mediaRef":
+      return IFieldValueUnion.mediaRef({
+        mediaTypeRids: [] // FIXME: confirm whether we will use rids in the deployed schema.
+      });
+    case "objectRef":
+      return IFieldValueUnion.object({
+        // FIXME: confirm whether we will use rids in the deployed schema.
+        interfaceTypeRids: [],
+        objectTypeRids: []
+      });
+    case "optional":
+      {
+        // If we get here, it means we have nested optionals - unwrap and continue
+        // TODO: probably warn? maybe throw
+
+        return convertTypeToFieldValueUnion(schemaType.item);
+      }
+    case "ref":
+      return IFieldValueUnion.modelRef({
+        modelTypes: [schemaType.name]
+      });
+    case "string":
+      return IFieldValueUnion.string({});
+    case "unknown":
+      return IFieldValueUnion.unmanagedJson({});
+    case "userRef":
+      return IFieldValueUnion.userRef({});
+    default:
+      assertNever(schemaType);
+  }
+}
+//# sourceMappingURL=convertStepsToIr.js.map

package/build/esm/utils/steps/convertStepsToIr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertStepsToIr.js","names":["IFieldTypeUnion","IFieldValueUnion","IModelDef","invariant","assertNever","convertStepsToSchema","convertStepsToIr","steps","metadata","recordDefinitions","unionDefinitions","schema","Object","fromEntries","map","def","name","convertSchemaToIr","inputSchema","primaryModelKeys","models","Map","modelDef","values","collectModels","push","description","version","outModels","has","process","env","NODE_ENV","type","set","record","convertRecordDefToIr","union","convertUnionDefToIr","recordDef","fields","entries","fieldKey","fieldType","key","undefined","value","convertTypeToFieldTypeUnion","meta","addedIn","isOptional","docs","unionDef","variantEntries","variants","variantName","modelRef","discriminant","schemaType","array","allowNullValue","convertTypeToFieldValueUnion","items","item","docRef","documentTypeRids","double","mediaRef","mediaTypeRids","object","interfaceTypeRids","objectTypeRids","modelTypes","string","unmanagedJson","userRef"],"sources":["convertStepsToIr.ts"],"sourcesContent":["/*\n * Copyright 2025 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 {\n  IModelTypeKey,\n  IUnionVariantKey,\n} from \"@palantir/pack-docschema-api/pack-docschema-api\";\nimport type {\n  IFieldDef,\n  IRealTimeDocumentSchema,\n  IRecordDef,\n  IUnionDef,\n} from \"@palantir/pack-docschema-api/pack-docschema-ir\";\nimport {\n  IFieldTypeUnion,\n  IFieldValueUnion,\n  IModelDef,\n} from \"@palantir/pack-docschema-api/pack-docschema-ir\";\nimport type * as P from \"@palantir/pack.schema\";\nimport invariant from \"tiny-invariant\";\nimport { assertNever } from \"../assertNever.js\";\nimport { convertStepsToSchema } from \"./convertStepsToSchema.js\";\nimport type { MigrationStep } from \"./parseMigrationSteps.js\";\n\nexport interface SchemaMetadata {\n  readonly name?: string;\n  readonly description?: string;\n  readonly version?: number;\n}\n\n/**\n * Converts migration steps to Palantir IR format\n */\nexport function convertStepsToIr(\n  steps: readonly MigrationStep[],\n  metadata?: SchemaMetadata,\n): IRealTimeDocumentSchema {\n  // First convert steps to document-schema-api format\n  const { recordDefinitions, unionDefinitions } = convertStepsToSchema(steps as MigrationStep[]);\n\n  const schema = {\n    ...Object.fromEntries(recordDefinitions.map(def => [def.name, def])),\n    ...Object.fromEntries(unionDefinitions.map(def => [def.name, def])),\n  };\n\n  return convertSchemaToIr(schema, metadata);\n}\n\n/**\n * Converts record and union definitions to Palantir IR format\n */\nexport function convertSchemaToIr(\n  inputSchema: P.Schema<P.ReturnedSchema>,\n  metadata?: SchemaMetadata,\n): IRealTimeDocumentSchema {\n  const primaryModelKeys: IModelTypeKey[] = [];\n  const models = new Map<IModelTypeKey, IModelDef>();\n\n  for (const modelDef of Object.values(inputSchema)) {\n    if (collectModels(modelDef, models)) {\n      primaryModelKeys.push(modelDef.name);\n    }\n  }\n\n  return {\n    name: metadata?.name ?? \"Generated Schema\",\n    description: metadata?.description ?? \"Schema generated from migration steps\",\n    version: metadata?.version ?? 1,\n    primaryModelKeys,\n    models: Object.fromEntries(models),\n  };\n}\n\nfunction collectModels(\n  modelDef: P.ModelDef,\n  outModels: Map<IModelTypeKey, IModelDef>,\n): boolean {\n  invariant(\n    !outModels.has(modelDef.name),\n    `Duplicate model definition: ${modelDef.name}`,\n  );\n\n  switch (modelDef.type) {\n    case \"record\": {\n      outModels.set(modelDef.name, IModelDef.record(convertRecordDefToIr(modelDef)));\n      return true;\n    }\n    case \"union\": {\n      outModels.set(modelDef.name, IModelDef.union(convertUnionDefToIr(modelDef)));\n      return true;\n    }\n    default:\n      assertNever(modelDef);\n  }\n}\n\nexport function convertRecordDefToIr(recordDef: P.RecordDef): IRecordDef {\n  const fields = Object.entries(recordDef.fields).map(([fieldKey, fieldType]): IFieldDef => ({\n    key: fieldKey,\n    name: fieldKey,\n    description: undefined,\n    value: convertTypeToFieldTypeUnion(fieldType),\n    meta: { addedIn: 1 },\n    isOptional: fieldType.type === \"optional\" ? true : undefined,\n  }));\n\n  return {\n    key: recordDef.name,\n    name: recordDef.name,\n    description: recordDef.docs || undefined,\n    fields,\n    meta: { addedIn: 1 },\n  };\n}\n\nexport function convertUnionDefToIr(unionDef: P.UnionDef): IUnionDef {\n  const variantEntries = Object.entries(unionDef.variants).map((\n    [variantName, modelRef],\n  ) =>\n    [\n      variantName as IUnionVariantKey,\n      modelRef.name as IModelTypeKey,\n    ] as const\n  );\n\n  return {\n    key: unionDef.name,\n    name: unionDef.name,\n    description: unionDef.docs,\n    discriminant: unionDef.discriminant,\n    variants: Object.fromEntries(variantEntries),\n    meta: { addedIn: 1 },\n  };\n}\n\n// TODO: rename to convertSchemaTypeToFieldTypeUnion\nexport function convertTypeToFieldTypeUnion(schemaType: P.Type): IFieldTypeUnion {\n  switch (schemaType.type) {\n    case \"array\": {\n      const arrayType = schemaType as P.Array;\n      return IFieldTypeUnion.array({\n        allowNullValue: false,\n        value: convertTypeToFieldValueUnion(arrayType.items as P.Type),\n      });\n    }\n    // TODO: have map/set types in document-schema-api\n\n    case \"optional\": {\n      // Optional flag is handled at field level, but we need to unwrap the inner type\n      const optionalType = schemaType as P.Optional;\n      return convertTypeToFieldTypeUnion(optionalType.item as P.Type);\n    }\n\n    case \"docRef\":\n    case \"double\":\n    case \"mediaRef\":\n    case \"objectRef\":\n    case \"ref\":\n    case \"string\":\n    case \"unknown\":\n    case \"userRef\":\n      return IFieldTypeUnion.value(convertTypeToFieldValueUnion(schemaType));\n\n    default:\n      assertNever(schemaType);\n  }\n}\n\nfunction convertTypeToFieldValueUnion(schemaType: P.Type): IFieldValueUnion {\n  switch (schemaType.type) {\n    case \"array\":\n      // TODO: fix the argument types so these aren't possible\n      invariant(\n        false,\n        `Collection type passed to convertTypeToFieldValueUnion: ${schemaType.type}`,\n      );\n\n    case \"docRef\":\n      return IFieldValueUnion.docRef({\n        documentTypeRids: [], // FIXME: confirm whether we will use rids in the deployed schema.\n      });\n\n    case \"double\":\n      return IFieldValueUnion.double({});\n\n    case \"mediaRef\":\n      return IFieldValueUnion.mediaRef({\n        mediaTypeRids: [], // FIXME: confirm whether we will use rids in the deployed schema.\n      });\n\n    case \"objectRef\":\n      return IFieldValueUnion.object({\n        // FIXME: confirm whether we will use rids in the deployed schema.\n        interfaceTypeRids: [],\n        objectTypeRids: [],\n      });\n\n    case \"optional\": {\n      // If we get here, it means we have nested optionals - unwrap and continue\n      // TODO: probably warn? maybe throw\n      const optionalType = schemaType as P.Optional;\n      return convertTypeToFieldValueUnion(optionalType.item as P.Type);\n    }\n\n    case \"ref\":\n      return IFieldValueUnion.modelRef({\n        modelTypes: [schemaType.name as IModelTypeKey],\n      });\n\n    case \"string\":\n      return IFieldValueUnion.string({});\n\n    case \"unknown\":\n      return IFieldValueUnion.unmanagedJson({});\n\n    case \"userRef\":\n      return IFieldValueUnion.userRef({});\n\n    default:\n      assertNever(schemaType);\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/build/esm/utils/steps/convertStepsToSchema.js

@@ -0,0 +1,156 @@
+/*
+ * Copyright 2025 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 { modelToRef } from "@palantir/pack.schema";
+export function convertStepsToSchema(steps) {
+  const localFragmentsByName = {};
+  const recordDefinitionsByName = {};
+  const unionDefinitionsByName = {};
+  for (const step of steps) {
+    if ("local-fragment" in step) {
+      const localFragment = step["local-fragment"];
+      Object.assign(localFragmentsByName, localFragment);
+    }
+    const addRecords = step["add-records"];
+    if (addRecords) {
+      for (const [recordKey, recordDef] of Object.entries(addRecords)) {
+        const recordFields = {};
+        for (const localFragmentName of recordDef.extends ?? []) {
+          const localFragment = localFragmentsByName[localFragmentName];
+          Object.assign(recordFields, localFragment);
+        }
+        for (const [fieldKey, fieldDefinition] of Object.entries(recordDef.fields)) {
+          recordFields[fieldKey] = fieldDefinition;
+        }
+        const recordFieldsAsSchemaType = {};
+        for (const [fieldKey, fieldDefinition] of Object.entries(recordFields)) {
+          recordFieldsAsSchemaType[fieldKey] = recordFieldDefinitionToSchemaType(fieldDefinition);
+        }
+        recordDefinitionsByName[recordKey] = {
+          type: "record",
+          name: recordKey,
+          fields: recordFieldsAsSchemaType,
+          docs: recordDef.docs
+        };
+      }
+    }
+    if ("add-union" in step) {
+      const addUnion = step["add-union"];
+      for (const [unionKey, unionDef] of Object.entries(addUnion)) {
+        // unionDef is a map from typeKey to recordKey (i.e. {"object" -> "ObjectNode"} implies { type: "object", ...ObjectNode })
+
+        const variants = {};
+        for (const [typeKey, recordKey] of Object.entries(unionDef)) {
+          const recordDef = recordDefinitionsByName[recordKey];
+          if (!recordDef) {
+            throw new Error(`Record ${recordKey} not found`);
+          }
+          variants[typeKey] = modelToRef(recordDef);
+        }
+        unionDefinitionsByName[unionKey] = {
+          type: "union",
+          name: unionKey,
+          docs: unionDef.docs,
+          variants,
+          discriminant: "type"
+        };
+      }
+    }
+    if ("modify-records" in step) {
+      const modifyRecords = step["modify-records"];
+      for (const [recordKey, modifyRecord] of Object.entries(modifyRecords)) {
+        const recordDef = recordDefinitionsByName[recordKey];
+        if (!recordDef) {
+          throw new Error(`Record ${recordKey} not found`);
+        }
+        for (const [fieldKey, fieldDefinition] of Object.entries(modifyRecord["add-fields"])) {
+          recordDef.fields[fieldKey] = recordFieldDefinitionToSchemaType(fieldDefinition);
+        }
+      }
+    }
+  }
+  return {
+    recordDefinitions: Object.values(recordDefinitionsByName),
+    unionDefinitions: Object.values(unionDefinitionsByName)
+  };
+}
+function recordFieldDefinitionToSchemaType(recordFieldDefinition) {
+  if (typeof recordFieldDefinition === "string") {
+    // Basic types
+    if (recordFieldDefinition === "docRef") {
+      return {
+        type: "docRef"
+      };
+    }
+    if (recordFieldDefinition === "double") {
+      return {
+        type: "double"
+      };
+    }
+    if (recordFieldDefinition === "mediaRef") {
+      return {
+        type: "mediaRef"
+      };
+    }
+    if (recordFieldDefinition === "objectRef") {
+      return {
+        type: "objectRef"
+      };
+    }
+    if (recordFieldDefinition === "string") {
+      return {
+        type: "string"
+      };
+    }
+    if (recordFieldDefinition === "userRef") {
+      return {
+        type: "userRef"
+      };
+    }
+
+    // Array types - e.g., "array<string>", "list<double>"
+    const arrayMatch = recordFieldDefinition.match(/^(?:array|list)<(.+)>$/);
+    if (arrayMatch?.[1]) {
+      const innerType = recordFieldDefinitionToSchemaType(arrayMatch[1]);
+      return {
+        type: "array",
+        items: innerType
+      };
+    }
+
+    // Optional types - e.g., "optional<string>"
+    const optionalMatch = recordFieldDefinition.match(/^optional<(.+)>$/);
+    if (optionalMatch?.[1]) {
+      const innerType = recordFieldDefinitionToSchemaType(optionalMatch[1]);
+      return {
+        type: "optional",
+        item: innerType
+      };
+    }
+
+    // Capitalized names are assumed to be references to other records or unions
+    if (recordFieldDefinition.charAt(0) === recordFieldDefinition.charAt(0).toUpperCase()) {
+      return {
+        type: "ref",
+        refType: "record",
+        // Could be union, but we assume record for now
+        name: recordFieldDefinition
+      };
+    }
+  }
+  throw new Error("Invalid record field definition " + JSON.stringify(recordFieldDefinition));
+}
+//# sourceMappingURL=convertStepsToSchema.js.map

package/build/esm/utils/steps/convertStepsToSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertStepsToSchema.js","names":["modelToRef","convertStepsToSchema","steps","localFragmentsByName","recordDefinitionsByName","unionDefinitionsByName","step","localFragment","Object","assign","addRecords","recordKey","recordDef","entries","recordFields","localFragmentName","extends","fieldKey","fieldDefinition","fields","recordFieldsAsSchemaType","recordFieldDefinitionToSchemaType","type","name","docs","addUnion","unionKey","unionDef","variants","typeKey","Error","discriminant","modifyRecords","modifyRecord","recordDefinitions","values","unionDefinitions","recordFieldDefinition","arrayMatch","match","innerType","items","optionalMatch","item","charAt","toUpperCase","refType","JSON","stringify"],"sources":["convertStepsToSchema.ts"],"sourcesContent":["/*\n * Copyright 2025 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 {\n  modelToRef,\n  type RecordDef,\n  type Ref,\n  type Type,\n  type UnionDef,\n} from \"@palantir/pack.schema\";\nimport type { MigrationStep, RecordFieldDefinition } from \"./parseMigrationSteps.js\";\n\nexport function convertStepsToSchema(steps: MigrationStep[]): {\n  recordDefinitions: RecordDef[];\n  unionDefinitions: UnionDef[];\n} {\n  const localFragmentsByName: Record<string, Record<string, string>> = {};\n  const recordDefinitionsByName: Record<string, RecordDef> = {};\n  const unionDefinitionsByName: Record<string, UnionDef> = {};\n\n  for (const step of steps) {\n    if (\"local-fragment\" in step) {\n      const localFragment = step[\"local-fragment\"]!;\n      Object.assign(localFragmentsByName, localFragment);\n    }\n\n    const addRecords = step[\"add-records\"];\n    if (addRecords) {\n      for (const [recordKey, recordDef] of Object.entries(addRecords)) {\n        const recordFields: Record<string, RecordFieldDefinition> = {};\n        for (const localFragmentName of recordDef.extends ?? []) {\n          const localFragment = localFragmentsByName[localFragmentName];\n          Object.assign(recordFields, localFragment);\n        }\n        for (const [fieldKey, fieldDefinition] of Object.entries(recordDef.fields)) {\n          recordFields[fieldKey] = fieldDefinition;\n        }\n\n        const recordFieldsAsSchemaType: Record<string, Type> = {};\n        for (const [fieldKey, fieldDefinition] of Object.entries(recordFields)) {\n          recordFieldsAsSchemaType[fieldKey] = recordFieldDefinitionToSchemaType(fieldDefinition);\n        }\n\n        recordDefinitionsByName[recordKey] = {\n          type: \"record\",\n          name: recordKey,\n          fields: recordFieldsAsSchemaType,\n          docs: recordDef.docs,\n        };\n      }\n    }\n\n    if (\"add-union\" in step) {\n      const addUnion = step[\"add-union\"]!;\n      for (const [unionKey, unionDef] of Object.entries(addUnion)) {\n        // unionDef is a map from typeKey to recordKey (i.e. {\"object\" -> \"ObjectNode\"} implies { type: \"object\", ...ObjectNode })\n\n        const variants: Record<string, Ref> = {};\n        for (const [typeKey, recordKey] of Object.entries(unionDef)) {\n          const recordDef = recordDefinitionsByName[recordKey];\n          if (!recordDef) {\n            throw new Error(`Record ${recordKey} not found`);\n          }\n          variants[typeKey] = modelToRef(recordDef);\n        }\n\n        unionDefinitionsByName[unionKey] = {\n          type: \"union\",\n          name: unionKey,\n          docs: unionDef.docs,\n          variants,\n          discriminant: \"type\",\n        };\n      }\n    }\n\n    if (\"modify-records\" in step) {\n      const modifyRecords = step[\"modify-records\"]!;\n      for (const [recordKey, modifyRecord] of Object.entries(modifyRecords)) {\n        const recordDef = recordDefinitionsByName[recordKey];\n        if (!recordDef) {\n          throw new Error(`Record ${recordKey} not found`);\n        }\n        for (const [fieldKey, fieldDefinition] of Object.entries(modifyRecord[\"add-fields\"])) {\n          recordDef.fields[fieldKey] = recordFieldDefinitionToSchemaType(fieldDefinition);\n        }\n      }\n    }\n  }\n\n  return {\n    recordDefinitions: Object.values(recordDefinitionsByName),\n    unionDefinitions: Object.values(unionDefinitionsByName),\n  };\n}\n\nfunction recordFieldDefinitionToSchemaType(\n  recordFieldDefinition: RecordFieldDefinition,\n): Type {\n  if (typeof recordFieldDefinition === \"string\") {\n    // Basic types\n    if (recordFieldDefinition === \"docRef\") {\n      return { type: \"docRef\" };\n    }\n    if (recordFieldDefinition === \"double\") {\n      return { type: \"double\" };\n    }\n    if (recordFieldDefinition === \"mediaRef\") {\n      return { type: \"mediaRef\" };\n    }\n    if (recordFieldDefinition === \"objectRef\") {\n      return { type: \"objectRef\" };\n    }\n    if (recordFieldDefinition === \"string\") {\n      return { type: \"string\" };\n    }\n    if (recordFieldDefinition === \"userRef\") {\n      return { type: \"userRef\" };\n    }\n\n    // Array types - e.g., \"array<string>\", \"list<double>\"\n    const arrayMatch = recordFieldDefinition.match(/^(?:array|list)<(.+)>$/);\n    if (arrayMatch?.[1]) {\n      const innerType = recordFieldDefinitionToSchemaType(arrayMatch[1]);\n      return { type: \"array\", items: innerType };\n    }\n\n    // Optional types - e.g., \"optional<string>\"\n    const optionalMatch = recordFieldDefinition.match(/^optional<(.+)>$/);\n    if (optionalMatch?.[1]) {\n      const innerType = recordFieldDefinitionToSchemaType(optionalMatch[1]);\n      return { type: \"optional\", item: innerType };\n    }\n\n    // Capitalized names are assumed to be references to other records or unions\n    if (\n      recordFieldDefinition.charAt(0)\n        === recordFieldDefinition.charAt(0).toUpperCase()\n    ) {\n      return {\n        type: \"ref\",\n        refType: \"record\", // Could be union, but we assume record for now\n        name: recordFieldDefinition,\n      };\n    }\n  }\n  throw new Error(\n    \"Invalid record field definition \" + JSON.stringify(recordFieldDefinition),\n  );\n}\n"],"mappings":"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","ignoreList":[]}

package/build/esm/utils/steps/generateModelsFromStepsSchema.js

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2025 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 { generateModelsFromIr } from "../ir/generateModelsFromIr.js";
+import { convertStepsToIr } from "./convertStepsToIr.js";
+/**
+ * Generates Model constants from migration steps
+ * @param steps - Array of migration steps
+ * @param metadata - Optional schema metadata overrides
+ * @param options - Optional generator options (e.g., typeImportPath, schemaImportPath)
+ * @returns Generated TypeScript code with Model constants
+ */
+export async function generateModelsFromStepsSchema(steps, metadata, options) {
+  const irSchema = convertStepsToIr(steps, metadata);
+  const generatedModelsSource = await generateModelsFromIr(irSchema, options);
+  return generatedModelsSource;
+}
+//# sourceMappingURL=generateModelsFromStepsSchema.js.map

package/build/esm/utils/steps/generateModelsFromStepsSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateModelsFromStepsSchema.js","names":["generateModelsFromIr","convertStepsToIr","generateModelsFromStepsSchema","steps","metadata","options","irSchema","generatedModelsSource"],"sources":["generateModelsFromStepsSchema.ts"],"sourcesContent":["/*\n * Copyright 2025 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 { generateModelsFromIr, type ModelGeneratorOptions } from \"../ir/generateModelsFromIr.js\";\nimport { convertStepsToIr, type SchemaMetadata } from \"./convertStepsToIr.js\";\nimport type { MigrationStep } from \"./parseMigrationSteps.js\";\n\n/**\n * Generates Model constants from migration steps\n * @param steps - Array of migration steps\n * @param metadata - Optional schema metadata overrides\n * @param options - Optional generator options (e.g., typeImportPath, schemaImportPath)\n * @returns Generated TypeScript code with Model constants\n */\nexport async function generateModelsFromStepsSchema(\n  steps: readonly MigrationStep[],\n  metadata?: SchemaMetadata,\n  options?: Pick<ModelGeneratorOptions, \"typeImportPath\" | \"schemaImportPath\">,\n): Promise<string> {\n  const irSchema = convertStepsToIr(steps, metadata);\n  const generatedModelsSource = await generateModelsFromIr(irSchema, options);\n  return generatedModelsSource;\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SAASA,oBAAoB,QAAoC,+BAA+B;AAChG,SAASC,gBAAgB,QAA6B,uBAAuB;AAG7E;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,eAAeC,6BAA6BA,CACjDC,KAA+B,EAC/BC,QAAyB,EACzBC,OAA4E,EAC3D;EACjB,MAAMC,QAAQ,GAAGL,gBAAgB,CAACE,KAAK,EAAEC,QAAQ,CAAC;EAClD,MAAMG,qBAAqB,GAAG,MAAMP,oBAAoB,CAACM,QAAQ,EAAED,OAAO,CAAC;EAC3E,OAAOE,qBAAqB;AAC9B","ignoreList":[]}

package/build/esm/utils/steps/generateZodFromStepsSchema.js

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2025 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 { generateZodSchemasFromIr } from "../ir/generateZodSchemasFromIr.js";
+import { convertStepsToIr } from "./convertStepsToIr.js";
+/**
+ * Generates Zod schemas from migration steps
+ * @param steps - Array of migration steps
+ * @param metadata - Optional schema metadata overrides
+ * @param options - Optional generator options (e.g., typeImportPath for satisfies operators)
+ * @returns Generated TypeScript code with Zod schemas
+ */
+export async function generateZodFromStepsSchema(steps, metadata, options) {
+  const irSchema = convertStepsToIr(steps, metadata);
+  const generatedZodSource = await generateZodSchemasFromIr(irSchema, options);
+  return generatedZodSource;
+}
+//# sourceMappingURL=generateZodFromStepsSchema.js.map

package/build/esm/utils/steps/generateZodFromStepsSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateZodFromStepsSchema.js","names":["generateZodSchemasFromIr","convertStepsToIr","generateZodFromStepsSchema","steps","metadata","options","irSchema","generatedZodSource"],"sources":["generateZodFromStepsSchema.ts"],"sourcesContent":["/*\n * Copyright 2025 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 {\n  generateZodSchemasFromIr,\n  type ZodGeneratorOptions,\n} from \"../ir/generateZodSchemasFromIr.js\";\nimport { convertStepsToIr, type SchemaMetadata } from \"./convertStepsToIr.js\";\nimport type { MigrationStep } from \"./parseMigrationSteps.js\";\n\n/**\n * Generates Zod schemas from migration steps\n * @param steps - Array of migration steps\n * @param metadata - Optional schema metadata overrides\n * @param options - Optional generator options (e.g., typeImportPath for satisfies operators)\n * @returns Generated TypeScript code with Zod schemas\n */\nexport async function generateZodFromStepsSchema(\n  steps: readonly MigrationStep[],\n  metadata?: SchemaMetadata,\n  options?: Pick<ZodGeneratorOptions, \"typeImportPath\">,\n): Promise<string> {\n  const irSchema = convertStepsToIr(steps, metadata);\n  const generatedZodSource = await generateZodSchemasFromIr(irSchema, options);\n  return generatedZodSource;\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SACEA,wBAAwB,QAEnB,mCAAmC;AAC1C,SAASC,gBAAgB,QAA6B,uBAAuB;AAG7E;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,eAAeC,0BAA0BA,CAC9CC,KAA+B,EAC/BC,QAAyB,EACzBC,OAAqD,EACpC;EACjB,MAAMC,QAAQ,GAAGL,gBAAgB,CAACE,KAAK,EAAEC,QAAQ,CAAC;EAClD,MAAMG,kBAAkB,GAAG,MAAMP,wBAAwB,CAACM,QAAQ,EAAED,OAAO,CAAC;EAC5E,OAAOE,kBAAkB;AAC3B","ignoreList":[]}

package/build/esm/utils/steps/parseMigrationSteps.js

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2025 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 z from "zod";
+
+// Type definitions for the migration steps
+// Note: These match the YAML syntax, not the P.Type objects
+// Only "string" and "double" are valid primitives in P.TypeKind
+
+// RecordFieldDefinition represents the YAML field values
+// Can be: "string", "double", "optional<T>", "list<T>", "ObjectNode", or a complex definition
+
+// Define allowed primitive types (matching TypeKind from document-schema-api)
+const primitiveType = z.enum(["string", "double"]);
+
+// Define generic type patterns like "optional<T>", "list<T>", "array<T>"
+const genericTypePattern = z.string().regex(/^(optional|list|array|set|map)<[^<>]+>$/, {
+  message: "Invalid generic type pattern"
+});
+
+// Reference to other record/union types (capitalized names)
+const typeReference = z.string().regex(/^[A-Z][a-zA-Z0-9]*$/, {
+  message: "Type references must be capitalized"
+});
+const basicType = z.union([primitiveType, genericTypePattern]);
+
+// Complex field definition object (for future extensibility)
+const complexFieldDefinition = z.object({
+  type: basicType,
+  docs: z.string().optional()
+  // This can be extended with e.g. constraints like min/max value or length, in the future
+});
+
+// Union of all allowed field definition types - more specific than just z.string()
+const recordFieldDefinition = z.union([primitiveType, genericTypePattern, typeReference, complexFieldDefinition]);
+
+// Keep as simple strings for now to maintain compatibility with existing code
+const recordFieldKey = z.string(); // TODO: could be improved w/ regex if we want to control format
+const fragmentKey = z.string();
+const localFragment = z.record(fragmentKey, z.record(recordFieldKey, recordFieldDefinition));
+const addRecords = z.record(z.string().regex(/^[A-Z][a-zA-Z0-9]*$/),
+// Keys must be capitalized type names
+z.object({
+  docs: z.optional(z.string()),
+  extends: z.array(z.string()).optional(),
+  fields: z.record(recordFieldKey, recordFieldDefinition)
+}));
+
+// e.g. { "Optional": { "of": "Something", "empty": "Nothing" } }
+// TODO: could have a stronger type for key here.
+const addUnion = z.record(z.string().regex(/^[A-Z][a-zA-Z0-9]*$/),
+// Union names must be capitalized
+z.record(z.string(), z.string().regex(/^[A-Z][a-zA-Z0-9]*$/)) // Values are type references
+);
+const modifyRecords = z.record(z.string().regex(/^[A-Z][a-zA-Z0-9]*$/),
+// Record names must be capitalized
+z.object({
+  "add-fields": z.record(recordFieldKey, recordFieldDefinition)
+}));
+const migrationStep = z.object({
+  "local-fragment": z.optional(localFragment),
+  "add-records": z.optional(addRecords),
+  "add-union": z.optional(addUnion),
+  "modify-records": z.optional(modifyRecords)
+});
+const migrationStepsSchema = z.array(migrationStep);
+export function parseMigrationSteps(unparsed) {
+  const parsed = migrationStepsSchema.parse(unparsed);
+  return parsed;
+}
+//# sourceMappingURL=parseMigrationSteps.js.map