@palantir/pack.schema 0.0.1-beta.1

package/build/cjs/index.d.cts

@@ -0,0 +1,131 @@
+declare const TypeKind: {
+    readonly ARRAY: "array";
+    readonly DOUBLE: "double";
+    readonly OPTIONAL: "optional";
+    readonly REF: "ref";
+    readonly STRING: "string";
+    readonly UNKNOWN: "unknown";
+};
+type TypeKind = typeof TypeKind[keyof typeof TypeKind];
+interface TypeBase {
+    readonly type: TypeKind;
+}
+type Ref = {
+    readonly type: typeof TypeKind.REF;
+    readonly refType: "record" | "union";
+    readonly name: string;
+};
+type Type = String | Double | Array | Ref | Optional | Unknown;
+type String = {
+    readonly type: typeof TypeKind.STRING;
+};
+declare const String: String;
+type Double = {
+    readonly type: typeof TypeKind.DOUBLE;
+};
+declare const Double: Double;
+type Unknown = {
+    readonly type: typeof TypeKind.UNKNOWN;
+};
+declare const Unknown: Unknown;
+type Array<T extends TypeBase = TypeBase> = {
+    readonly type: typeof TypeKind.ARRAY;
+    readonly items: T;
+};
+declare const Array: <T extends TypeBase>(item: T) => Array<T>;
+type Optional<T extends TypeBase = TypeBase> = {
+    readonly type: typeof TypeKind.OPTIONAL;
+    readonly item: T;
+};
+declare const Optional: <T extends TypeBase>(item: T) => Optional<T>;
+
+declare const ModelDefType: {
+    readonly RECORD: "record";
+    readonly UNION: "union";
+};
+type ModelDefType = typeof ModelDefType[keyof typeof ModelDefType];
+interface ModelDefBase {
+    readonly type: ModelDefType;
+    readonly name: string;
+    readonly docs?: string;
+}
+type RecordFields = Record<string, Type>;
+type UnionVariants = Record<string, Ref>;
+interface UnionDef<TVariants extends UnionVariants = UnionVariants> extends ModelDefBase {
+    readonly type: typeof ModelDefType.UNION;
+    readonly variants: TVariants;
+    readonly discriminant: string;
+}
+interface RecordDef<TFields extends RecordFields = RecordFields> extends ModelDefBase {
+    readonly type: typeof ModelDefType.RECORD;
+    readonly fields: TFields;
+}
+type ModelDef = RecordDef | UnionDef;
+
+type UnionVariantArgExplicit = Ref | ModelDef;
+type UnionVariantArg = UnionVariantArgExplicit | (() => UnionVariantArgExplicit);
+type UnionVariantArgs = Record<string, UnionVariantArg>;
+type ResolvedUnionVariants<T extends UnionVariantArgs> = {
+    readonly [K in keyof T]: Ref;
+};
+type UnionArgs<T extends UnionVariantArgs> = {
+    readonly docs: string;
+    readonly variants: T;
+};
+declare function defineUnion<const TVariants extends UnionVariantArgs>(name: string, union: UnionArgs<TVariants>): UnionDef<ResolvedUnionVariants<TVariants>>;
+declare function resolveUnionVariantArg(arg: UnionVariantArg): Ref;
+
+type ReturnedSchema = Record<string, RecordDef | UnionDef>;
+type Schema<T extends ReturnedSchema> = T;
+type SchemaBuilder<T extends ReturnedSchema> = {
+    [k in keyof T]: T[k] extends UnionDef<infer R> ? UnionBuilder<R> : T[k] extends RecordDef<infer R> ? RecordBuilder<R> : never;
+};
+interface RecordBuilder<T extends Record<string, Type>> {
+    addField<const K extends string, V extends Type>(name: K, type: V): RecordBuilder<T & {
+        [k in K]: V;
+    }>;
+    build(): RecordDef<T>;
+}
+interface UnionBuilder<S extends UnionVariants> {
+    addVariant<const K extends string>(name: K, modelDefOrRef: UnionVariantArg): UnionBuilder<S & {
+        [k in K]: Ref;
+    }>;
+    build(): UnionDef<S>;
+}
+declare function defineMigration<const T extends ReturnedSchema, const S extends ReturnedSchema>(previous: Schema<T>, migration: (schema: SchemaBuilder<T>) => S): Schema<T & S>;
+
+type FieldArgExplicit = Type | RecordDef | UnionDef;
+type FieldArg = FieldArgExplicit | (() => FieldArgExplicit);
+type FieldArgExplicitOf<T extends FieldArg> = T extends () => infer R ? R : T;
+type FieldArgs = Record<string, FieldArg>;
+type ResolvedFieldArgExplicit<T extends FieldArgExplicit> = T extends RecordDef | UnionDef ? Ref : T;
+type ResolvedFieldArg<T extends FieldArg> = ResolvedFieldArgExplicit<FieldArgExplicitOf<T>>;
+type ResolvedFields<T extends FieldArgs> = {
+    readonly [K in keyof T]: ResolvedFieldArg<T[K]>;
+};
+type RecordArgs<T extends FieldArgs> = {
+    readonly docs: string;
+    readonly fields: T;
+};
+declare function defineRecord<const T extends FieldArgs>(name: string, record: RecordArgs<T>): RecordDef<ResolvedFields<T>>;
+
+/**
+ * Helper function to safely transform a record definition to a reference.
+ * This function helps TypeScript track type transformations better.
+ */
+declare function modelToRef(model: ModelDef): Ref;
+/**
+ * Helper function to create a reference with proper typing.
+ * This avoids type assertions in multiple places.
+ */
+declare function createRef(name: string, refType: "record" | "union"): Ref;
+/**
+ * Type guard to check if a value is a RecordDef
+ */
+declare function isRecordDef(value: unknown): value is RecordDef;
+/**
+ * Type guard to check if a value is a UnionDef
+ */
+declare function isUnionDef(value: unknown): value is UnionDef;
+
+export { Array, Double, type FieldArg, type FieldArgExplicit, type FieldArgExplicitOf, type FieldArgs, type ModelDef, ModelDefType, Optional, type RecordArgs, type RecordBuilder, type RecordDef, type RecordFields, type Ref, type ResolvedFieldArg, type ResolvedFieldArgExplicit, type ResolvedFields, type ResolvedUnionVariants, type ReturnedSchema, type Schema, type SchemaBuilder, String, type Type, TypeKind, type UnionArgs, type UnionBuilder, type UnionDef, type UnionVariantArg, type UnionVariantArgExplicit, type UnionVariantArgs, type UnionVariants, Unknown, createRef, defineMigration, defineRecord, defineUnion, isRecordDef, isUnionDef, modelToRef, resolveUnionVariantArg };

package/build/esm/index.js

@@ -0,0 +1,176 @@
+// src/defs.ts
+var ModelDefType = {
+  RECORD: "record",
+  UNION: "union"
+};
+
+// src/primitives.ts
+var TypeKind = {
+  ARRAY: "array",
+  DOUBLE: "double",
+  OPTIONAL: "optional",
+  REF: "ref",
+  STRING: "string",
+  UNKNOWN: "unknown"
+};
+var String = {
+  type: TypeKind.STRING
+};
+var Double = {
+  type: TypeKind.DOUBLE
+};
+var Unknown = {
+  type: TypeKind.UNKNOWN
+};
+var Array = (item) => ({
+  type: TypeKind.ARRAY,
+  items: item
+});
+var Optional = (item) => ({
+  type: TypeKind.OPTIONAL,
+  item
+});
+
+// src/utils.ts
+function modelToRef(model) {
+  return createRef(model.name, model.type);
+}
+function createRef(name, refType) {
+  return {
+    type: TypeKind.REF,
+    name,
+    refType
+  };
+}
+function isRecordDef(value) {
+  return value != null && typeof value === "object" && "type" in value && value.type === ModelDefType.RECORD && "fields" in value;
+}
+function isUnionDef(value) {
+  return value != null && typeof value === "object" && "type" in value && value.type === ModelDefType.UNION && "variants" in value;
+}
+
+// src/defineUnion.ts
+function defineUnion(name, union) {
+  const entries = Object.entries(union.variants).map(([key, value]) => [key, resolveUnionVariantArg(value)]);
+  const variants = Object.fromEntries(entries);
+  return {
+    type: ModelDefType.UNION,
+    discriminant: "type",
+    name,
+    docs: union.docs,
+    variants
+  };
+}
+function resolveUnionVariantArg(arg) {
+  const resolved = typeof arg === "function" ? arg() : arg;
+  return resolved.type === TypeKind.REF ? resolved : modelToRef(resolved);
+}
+
+// src/defineMigration.ts
+var UnionBuilderImpl = class _UnionBuilderImpl {
+  name;
+  docs;
+  variants;
+  constructor({
+    name,
+    docs,
+    variants
+  }) {
+    this.name = name;
+    this.docs = docs;
+    this.variants = {
+      ...variants
+    };
+  }
+  addVariant(variantName, modelDefOrRef) {
+    const ref = resolveUnionVariantArg(modelDefOrRef);
+    const newVariants = {
+      ...this.variants,
+      [variantName]: ref
+    };
+    return new _UnionBuilderImpl({
+      type: ModelDefType.UNION,
+      name: this.name,
+      variants: newVariants,
+      discriminant: "type"
+    });
+  }
+  build() {
+    return {
+      type: ModelDefType.UNION,
+      variants: this.variants,
+      discriminant: "type",
+      name: this.name
+    };
+  }
+};
+var RecordBuilderImpl = class _RecordBuilderImpl {
+  name;
+  fields;
+  constructor(initialRecordDef) {
+    this.name = initialRecordDef.name;
+    this.fields = {
+      ...initialRecordDef.fields
+    };
+  }
+  // TODO: resolve field value from arg instead
+  addField(name, value) {
+    return new _RecordBuilderImpl({
+      type: ModelDefType.RECORD,
+      name: this.name,
+      fields: {
+        ...this.fields,
+        [name]: value
+      },
+      docs: ""
+    });
+  }
+  build() {
+    return {
+      type: ModelDefType.RECORD,
+      name: this.name,
+      fields: this.fields,
+      docs: ""
+    };
+  }
+};
+function defineMigration(previous, migration) {
+  const builders = {};
+  for (const key in previous) {
+    const v = previous[key];
+    if (isRecordDef(v)) {
+      const recordBuilder = new RecordBuilderImpl(v);
+      builders[key] = recordBuilder;
+    } else if (isUnionDef(v)) {
+      const unionBuilder = new UnionBuilderImpl(v);
+      builders[key] = unionBuilder;
+    }
+  }
+  return {
+    ...previous,
+    ...migration(builders)
+  };
+}
+
+// src/defineRecord.ts
+function resolveFieldArg(value) {
+  const resolved = typeof value === "function" ? value() : value;
+  if (isRecordDef(resolved) || isUnionDef(resolved)) {
+    return modelToRef(resolved);
+  }
+  return resolved;
+}
+function defineRecord(name, record) {
+  const entries = Object.entries(record.fields).map(([key, value]) => [key, resolveFieldArg(value)]);
+  const fields = Object.fromEntries(entries);
+  return {
+    type: ModelDefType.RECORD,
+    name,
+    docs: record.docs,
+    fields
+  };
+}
+
+export { Array, Double, ModelDefType, Optional, String, TypeKind, Unknown, createRef, defineMigration, defineRecord, defineUnion, isRecordDef, isUnionDef, modelToRef, resolveUnionVariantArg };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/build/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/defs.ts","../../src/primitives.ts","../../src/utils.ts","../../src/defineUnion.ts","../../src/defineMigration.ts","../../src/defineRecord.ts"],"names":[],"mappings":"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","file":"index.js","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\nexport const ModelDefType = {\n  RECORD: \"record\",\n  UNION: \"union\"\n};","/*\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\nexport const TypeKind = {\n  ARRAY: \"array\",\n  DOUBLE: \"double\",\n  OPTIONAL: \"optional\",\n  REF: \"ref\",\n  STRING: \"string\",\n  UNKNOWN: \"unknown\"\n};\n\n// Forward declaration to avoid circular reference\n\n// A reference to a record or a union type\n\nexport const String = {\n  type: TypeKind.STRING\n};\nexport const Double = {\n  type: TypeKind.DOUBLE\n};\nexport const Unknown = {\n  type: TypeKind.UNKNOWN\n};\nexport const Array = item => ({\n  type: TypeKind.ARRAY,\n  items: item\n});\nexport const Optional = item => ({\n  type: TypeKind.OPTIONAL,\n  item\n});","/*\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 { ModelDefType } from \"./defs.js\";\nimport { TypeKind } from \"./primitives.js\";\n\n/**\n * Helper function to safely transform a record definition to a reference.\n * This function helps TypeScript track type transformations better.\n */\nexport function modelToRef(model) {\n  return createRef(model.name, model.type);\n}\n\n/**\n * Helper function to create a reference with proper typing.\n * This avoids type assertions in multiple places.\n */\nexport function createRef(name, refType) {\n  return {\n    type: TypeKind.REF,\n    name,\n    refType\n  };\n}\n\n/**\n * Type guard to check if a value is a RecordDef\n */\nexport function isRecordDef(value) {\n  return value != null && typeof value === \"object\" && \"type\" in value && value.type === ModelDefType.RECORD && \"fields\" in value;\n}\n\n/**\n * Type guard to check if a value is a UnionDef\n */\nexport function isUnionDef(value) {\n  return value != null && typeof value === \"object\" && \"type\" in value && value.type === ModelDefType.UNION && \"variants\" in value;\n}","/*\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 { ModelDefType } from \"./defs.js\";\nimport { TypeKind } from \"./primitives.js\";\nimport { modelToRef } from \"./utils.js\";\nexport function defineUnion(name, union) {\n  const entries = Object.entries(union.variants).map(([key, value]) => [key, resolveUnionVariantArg(value)]);\n  const variants = Object.fromEntries(entries);\n  return {\n    type: ModelDefType.UNION,\n    discriminant: \"type\",\n    name: name,\n    docs: union.docs,\n    variants\n  };\n}\nexport function resolveUnionVariantArg(arg) {\n  const resolved = typeof arg === \"function\" ? arg() : arg;\n  return resolved.type === TypeKind.REF ? resolved : modelToRef(resolved);\n}","/*\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 { resolveUnionVariantArg } from \"./defineUnion.js\";\nimport { ModelDefType } from \"./defs.js\";\nimport { isRecordDef, isUnionDef } from \"./utils.js\";\nclass UnionBuilderImpl {\n  name;\n  docs;\n  variants;\n  constructor({\n    name,\n    docs,\n    variants\n  }) {\n    this.name = name;\n    this.docs = docs;\n    this.variants = {\n      ...variants\n    };\n  }\n  addVariant(variantName, modelDefOrRef) {\n    const ref = resolveUnionVariantArg(modelDefOrRef);\n    const newVariants = {\n      ...this.variants,\n      [variantName]: ref\n    };\n    return new UnionBuilderImpl({\n      type: ModelDefType.UNION,\n      name: this.name,\n      variants: newVariants,\n      discriminant: \"type\"\n    });\n  }\n  build() {\n    return {\n      type: ModelDefType.UNION,\n      variants: this.variants,\n      discriminant: \"type\",\n      name: this.name\n    };\n  }\n}\nclass RecordBuilderImpl {\n  name;\n  fields;\n  constructor(initialRecordDef) {\n    this.name = initialRecordDef.name;\n    this.fields = {\n      ...initialRecordDef.fields\n    };\n  }\n\n  // TODO: resolve field value from arg instead\n  addField(name, value) {\n    return new RecordBuilderImpl({\n      type: ModelDefType.RECORD,\n      name: this.name,\n      fields: {\n        ...this.fields,\n        [name]: value\n      },\n      docs: \"\"\n    });\n  }\n  build() {\n    return {\n      type: ModelDefType.RECORD,\n      name: this.name,\n      fields: this.fields,\n      docs: \"\"\n    };\n  }\n}\nexport function defineMigration(previous, migration) {\n  /**\n   * Create a map of builders for the schema.\n   *\n   * Note about type assertions:\n   * We use a type assertion here (SchemaBuilder<T>) because TypeScript cannot\n   * track the relationship between the keys in the original schema and the\n   * corresponding builder types. This is a fundamental limitation of TypeScript's\n   * type system when dealing with dynamically constructed objects.\n   *\n   * The assertion is safe because:\n   * 1. We're only adding keys that exist in the original schema\n   * 2. For each key, we're creating a builder of the correct type\n   * 3. The resulting object exactly matches the SchemaBuilder<T> type\n   */\n  const builders = {};\n  for (const key in previous) {\n    const v = previous[key];\n\n    // Use our type guards for safer type narrowing\n    if (isRecordDef(v)) {\n      // This assertion is necessary because TypeScript can't track the field types\n      // through the dynamic property access and object construction\n      const recordBuilder = new RecordBuilderImpl(v);\n      builders[key] = recordBuilder;\n    } else if (isUnionDef(v)) {\n      // Similar assertion needed for union builders\n      const unionBuilder = new UnionBuilderImpl(v);\n      builders[key] = unionBuilder;\n    }\n  }\n  return {\n    ...previous,\n    ...migration(builders)\n  };\n}","/*\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 { ModelDefType } from \"./defs.js\";\nimport { isRecordDef, isUnionDef, modelToRef } from \"./utils.js\";\n/**\n * Helper function to resolve a field value, handling functions and transforming\n * types as needed.\n */\nfunction resolveFieldArg(value) {\n  // Handle function values\n  const resolved = typeof value === \"function\" ? value() : value;\n  if (isRecordDef(resolved) || isUnionDef(resolved)) {\n    return modelToRef(resolved);\n  }\n\n  // For primitive types and other Types\n  return resolved;\n}\nexport function defineRecord(name, record) {\n  const entries = Object.entries(record.fields).map(([key, value]) => [key, resolveFieldArg(value)]);\n  const fields = Object.fromEntries(entries);\n  return {\n    type: ModelDefType.RECORD,\n    name: name,\n    docs: record.docs,\n    fields\n  };\n}"]}

package/build/types/__tests__/defineMigration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/types/__tests__/defineMigration.test.d.ts.map

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

package/build/types/__tests__/defineRecord.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/types/__tests__/defineRecord.test.d.ts.map

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

package/build/types/__tests__/defineUnion.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/types/__tests__/defineUnion.test.d.ts.map

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

package/build/types/__tests__/integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/types/__tests__/integration.test.d.ts.map

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

package/build/types/__tests__/primitives.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/types/__tests__/primitives.test.d.ts.map

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

package/build/types/__tests__/testTypeUtils.d.ts

@@ -0,0 +1,74 @@
+/**
+* Checks if two types are exactly equal
+*/
+export type Equals<
+	X,
+	Y
+> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
+/**
+* Asserts that two types are exactly equal. Causes a compile error if not.
+*
+* @example
+* // This will compile only if PersonRecord.fields.name is exactly String
+* assertTypeEquals<typeof PersonRecord.fields.name, String>();
+*/
+export declare function assertTypeEquals<
+	T,
+	U
+>(_witness?: Equals<T, U> extends true ? unknown : never): void;
+/**
+* Checks if T extends U
+*/
+export type Extends<
+	T,
+	U
+> = T extends U ? true : false;
+/**
+* Asserts that T extends U. Causes a compile error if not.
+*
+* @example
+* // This will compile only if T extends Record<string, unknown>
+* assertTypeExtends<T, Record<string, unknown>>();
+*/
+export declare function assertTypeExtends<
+	T,
+	U
+>(_witness?: Extends<T, U> extends true ? unknown : never): void;
+/**
+* Asserts that a type has the specified keys. Causes a compile error if not.
+*
+* @example
+* // This will compile only if PersonRecord.fields has exactly keys 'name' and 'age'
+* assertExactKeys<typeof PersonRecord.fields, 'name' | 'age'>();
+*/
+export declare function assertExactKeys<
+	T,
+	K extends string
+>(_witness?: Equals<keyof T, K> extends true ? unknown : never): void;
+/**
+* Asserts that a type has at least the specified keys. Causes a compile error if not.
+*
+* @example
+* // This will compile only if PersonRecord.fields has at least keys 'name' and 'age'
+* assertHasKeys<typeof PersonRecord.fields, 'name' | 'age'>();
+*/
+export declare function assertHasKeys<
+	T,
+	K extends string
+>(_witness?: K extends keyof T ? unknown : never): void;
+/**
+* Assert that a value is never. Useful for exhaustiveness checks.
+*
+* @example
+* function handleShape(shape: Shape) {
+*   if (shape.type === 'circle') {
+*     // handle circle
+*   } else if (shape.type === 'rectangle') {
+*     // handle rectangle
+*   } else {
+*     // This will cause a compile error if we forget to handle a shape type
+*     assertNever(shape);
+*   }
+* }
+*/
+export declare function assertNever(_value: never): never;

package/build/types/__tests__/testTypeUtils.d.ts.map

@@ -0,0 +1 @@
+{"mappings":";;;AAoBA,YAAY;CAAO;CAAG;MAAO,QAAQ,UAAU,IAAI,IAAI,aAAa,QAAQ,UAAU,IAAI,IAAI,KAC1F,OACA;;;;;;;;AASJ,OAAO,iBAAS;CAAiB;CAAG;EAClC,WAAW,OAAO,GAAG,WAAW;;;;AAMlC,YAAY;CAAQ;CAAG;IAAK,UAAU,IAAI,OAAO;;;;;;;;AASjD,OAAO,iBAAS;CAAkB;CAAG;EACnC,WAAW,QAAQ,GAAG,WAAW;;;;;;;;AAUnC,OAAO,iBAAS;CAAgB;CAAG;EACjC,WAAW,aAAa,GAAG,WAAW;;;;;;;;AAWxC,OAAO,iBAAS;CAAc;CAAG;EAC/B,WAAW,gBAAgB;;;;;;;;;;;;;;;;AAkB7B,OAAO,iBAAS,YAAY","names":[],"sources":["../../../src/__tests__/testTypeUtils.ts"],"version":3,"file":"testTypeUtils.d.ts"}

package/build/types/defineMigration.d.ts

@@ -0,0 +1,21 @@
+import type { UnionVariantArg } from "./defineUnion.js";
+import type { RecordDef, UnionDef, UnionVariants } from "./defs.js";
+import type { Ref, Type } from "./primitives.js";
+export type ReturnedSchema = Record<string, RecordDef | UnionDef>;
+export type Schema<T extends ReturnedSchema> = T;
+export type SchemaBuilder<T extends ReturnedSchema> = { [k in keyof T] : T[k] extends UnionDef<infer R> ? UnionBuilder<R> : T[k] extends RecordDef<infer R> ? RecordBuilder<R> : never };
+export interface RecordBuilder<T extends Record<string, Type>> {
+	addField<
+		const K extends string,
+		V extends Type
+	>(name: K, type: V): RecordBuilder<T & { [k in K] : V }>;
+	build(): RecordDef<T>;
+}
+export interface UnionBuilder<S extends UnionVariants> {
+	addVariant<const K extends string>(name: K, modelDefOrRef: UnionVariantArg): UnionBuilder<S & { [k in K] : Ref }>;
+	build(): UnionDef<S>;
+}
+export declare function defineMigration<
+	const T extends ReturnedSchema,
+	const S extends ReturnedSchema
+>(previous: Schema<T>, migration: (schema: SchemaBuilder<T>) => S): Schema<T & S>;

package/build/types/defineMigration.d.ts.map

@@ -0,0 +1 @@
+{"mappings":"AAgBA,cAAc,uBAAuB;AAErC,cAAc,WAAyB,UAAU,qBAAqB;AAEtE,cAAc,KAAK,YAAY;AAG/B,YAAY,iBAAiB,eAAe,YAAY;AAExD,YAAY,OAAO,UAAU,kBAAkB;AAE/C,YAAY,cAAc,UAAU,qBACjC,WAAW,KAAI,EAAE,WAAW,eAAe,KAAK,aAAa,KAC1D,EAAE,WAAW,gBAAgB,KAAK,cAAc;AAItD,iBAAiB,cAAc,UAAU,eAAe,OAAO;CAE7D;QAAe;EAAkB,UAAU;GACzC,MAAM,GACN,MAAM,IACL,cAAc,OAAO,KAAK,KAAI;CACjC,SAAS,UAAU;;AAGrB,iBAAiB,aAAa,UAAU,eAAe;CAErD,iBAAiB,kBACf,MAAM,GACN,eAAe,kBACd,aAAa,OAAO,KAAK,KAAI;CAChC,SAAS,SAAS;;AAmEpB,OAAO,iBAAS;OACR,UAAU;OACV,UAAU;EAEhB,UAAU,OAAO,IACjB,YAAY,QAAQ,cAAc,OAAO,IACxC,OAAO,IAAI","names":[],"sources":["../../src/defineMigration.ts"],"version":3,"file":"defineMigration.d.ts"}

package/build/types/defineRecord.d.ts

@@ -0,0 +1,14 @@
+import type { RecordDef, UnionDef } from "./defs.js";
+import type { Ref, Type } from "./primitives.js";
+export type FieldArgExplicit = Type | RecordDef | UnionDef;
+export type FieldArg = FieldArgExplicit | (() => FieldArgExplicit);
+export type FieldArgExplicitOf<T extends FieldArg> = T extends () => infer R ? R : T;
+export type FieldArgs = Record<string, FieldArg>;
+export type ResolvedFieldArgExplicit<T extends FieldArgExplicit> = T extends RecordDef | UnionDef ? Ref : T;
+export type ResolvedFieldArg<T extends FieldArg> = ResolvedFieldArgExplicit<FieldArgExplicitOf<T>>;
+export type ResolvedFields<T extends FieldArgs> = { readonly [K in keyof T] : ResolvedFieldArg<T[K]> };
+export type RecordArgs<T extends FieldArgs> = {
+	readonly docs: string;
+	readonly fields: T;
+};
+export declare function defineRecord<const T extends FieldArgs>(name: string, record: RecordArgs<T>): RecordDef<ResolvedFields<T>>;

package/build/types/defineRecord.d.ts.map

@@ -0,0 +1 @@
+{"mappings":"AAgBA,cAAc,WAAW,gBAAgB;AAEzC,cAAc,KAAK,YAAY;AAG/B,YAAY,mBACR,OACA,YACA;AAEJ,YAAY,WACR,0BACO;AAEX,YAAY,mBAAmB,UAAU,YAAY,sBAAsB,IAAI,IAC3E;AAEJ,YAAY,YAAY,eAAe;AAEvC,YAAY,yBAAyB,UAAU,oBAAoB,UAAU,YAAY,WACrF,MACA;AAEJ,YAAY,iBAAiB,UAAU,YAAY,yBAAyB,mBAAmB;AAE/F,YAAY,eAAe,UAAU,yBACzB,WAAW,KAAI,iBAAiB,EAAE;AAG9C,YAAY,WAAW,UAAU,aAAa;UACnC;UACA,QAAQ;;AAmBnB,OAAO,iBAAS,mBAAmB,UAAU,WAC3C,cACA,QAAQ,WAAW,KAClB,UAAU,eAAe","names":[],"sources":["../../src/defineRecord.ts"],"version":3,"file":"defineRecord.d.ts"}

package/build/types/defineUnion.d.ts

@@ -0,0 +1,12 @@
+import type { ModelDef, UnionDef } from "./defs.js";
+import type { Ref } from "./primitives.js";
+export type UnionVariantArgExplicit = Ref | ModelDef;
+export type UnionVariantArg = UnionVariantArgExplicit | (() => UnionVariantArgExplicit);
+export type UnionVariantArgs = Record<string, UnionVariantArg>;
+export type ResolvedUnionVariants<T extends UnionVariantArgs> = { readonly [K in keyof T] : Ref };
+export type UnionArgs<T extends UnionVariantArgs> = {
+	readonly docs: string;
+	readonly variants: T;
+};
+export declare function defineUnion<const TVariants extends UnionVariantArgs>(name: string, union: UnionArgs<TVariants>): UnionDef<ResolvedUnionVariants<TVariants>>;
+export declare function resolveUnionVariantArg(arg: UnionVariantArg): Ref;

package/build/types/defineUnion.d.ts.map

@@ -0,0 +1 @@
+{"mappings":"AAgBA,cAAc,UAAU,gBAAgB;AAExC,cAAc,WAAW;AAIzB,YAAY,0BAA0B,MAAM;AAC5C,YAAY,kBAAkB,iCAAiC;AAC/D,YAAY,mBAAmB,eAAe;AAE9C,YAAY,sBAAsB,UAAU,gCAChC,WAAW,KAAI;AAG3B,YAAY,UAAU,UAAU,oBAAoB;UACzC;UACA,UAAU;;AAGrB,OAAO,iBAAS,kBAAkB,kBAAkB,kBAClD,cACA,OAAO,UAAU,aAChB,SAAS,sBAAsB;AAgBlC,OAAO,iBAAS,uBAAuB,KAAK,kBAAkB","names":[],"sources":["../../src/defineUnion.ts"],"version":3,"file":"defineUnion.d.ts"}

package/build/types/defs.d.ts

@@ -0,0 +1,24 @@
+import type { Ref, Type } from "./primitives.js";
+export declare const ModelDefType: {
+	readonly RECORD: "record";
+	readonly UNION: "union";
+};
+export type ModelDefType = typeof ModelDefType[keyof typeof ModelDefType];
+interface ModelDefBase {
+	readonly type: ModelDefType;
+	readonly name: string;
+	readonly docs?: string;
+}
+export type RecordFields = Record<string, Type>;
+export type UnionVariants = Record<string, Ref>;
+export interface UnionDef<TVariants extends UnionVariants = UnionVariants> extends ModelDefBase {
+	readonly type: typeof ModelDefType.UNION;
+	readonly variants: TVariants;
+	readonly discriminant: string;
+}
+export interface RecordDef<TFields extends RecordFields = RecordFields> extends ModelDefBase {
+	readonly type: typeof ModelDefType.RECORD;
+	readonly fields: TFields;
+}
+export type ModelDef = RecordDef | UnionDef;
+export {};

package/build/types/defs.d.ts.map

@@ -0,0 +1 @@
+{"mappings":"AAgBA,cAAc,KAAK,YAAY;AAE/B,OAAO,cAAM;UACX,QAAQ;UACR,OAAO;;AAGT,YAAY,sBAAsB,0BAA0B;UAElD,aAAa;UACZ,MAAM;UACN;UACA;;AAGX,YAAY,eAAe,eAAe;AAC1C,YAAY,gBAAgB,eAAe;AAE3C,iBAAiB,SAAS,kBAAkB,gBAAgB,uBAAuB,aAAa;UACrF,aAAa,aAAa;UAC1B,UAAU;UACV;;AAGX,iBAAiB,UAAU,gBAAgB,eAAe,sBAAsB,aAAa;UAClF,aAAa,aAAa;UAC1B,QAAQ;;AAGnB,YAAY,WAAW,YAAY","names":[],"sources":["../../src/defs.ts"],"version":3,"file":"defs.d.ts"}

package/build/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./defineMigration.js";
+export * from "./defineRecord.js";
+export * from "./defineUnion.js";
+export * from "./defs.js";
+export * from "./primitives.js";
+export * from "./utils.js";

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

@@ -0,0 +1 @@
+{"mappings":"AAgBA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc","names":[],"sources":["../../src/index.ts"],"version":3,"file":"index.d.ts"}

package/build/types/primitives.d.ts

@@ -0,0 +1,41 @@
+export declare const TypeKind: {
+	readonly ARRAY: "array";
+	readonly DOUBLE: "double";
+	readonly OPTIONAL: "optional";
+	readonly REF: "ref";
+	readonly STRING: "string";
+	readonly UNKNOWN: "unknown";
+};
+export type TypeKind = typeof TypeKind[keyof typeof TypeKind];
+export type String = {
+	readonly type: typeof TypeKind.STRING;
+};
+export type Double = {
+	readonly type: typeof TypeKind.DOUBLE;
+};
+interface TypeBase {
+	readonly type: TypeKind;
+}
+export type Array<T extends TypeBase = TypeBase> = {
+	readonly type: typeof TypeKind.ARRAY;
+	readonly items: T;
+};
+export type Ref = {
+	readonly type: typeof TypeKind.REF;
+	readonly refType: "record" | "union";
+	readonly name: string;
+};
+export type Optional<T extends TypeBase = TypeBase> = {
+	readonly type: typeof TypeKind.OPTIONAL;
+	readonly item: T;
+};
+export type Unknown = {
+	readonly type: typeof TypeKind.UNKNOWN;
+};
+export type Type = String | Double | Array | Ref | Optional | Unknown;
+export declare const String: String;
+export declare const Double: Double;
+export declare const Unknown: Unknown;
+export declare const Array: <T extends TypeBase>(item: T) => Array<T>;
+export declare const Optional: <T extends TypeBase>(item: T) => Optional<T>;
+export {};

package/build/types/primitives.d.ts.map

@@ -0,0 +1 @@
+{"mappings":"AAgBA,OAAO,cAAM;UACX,OAAO;UACP,QAAQ;UACR,UAAU;UACV,KAAK;UACL,QAAQ;UACR,SAAS;;AAGX,YAAY,kBAAkB,sBAAsB;AAEpD,YAAY,SAAS;UACV,aAAa,SAAS;;AAGjC,YAAY,SAAS;UACV,aAAa,SAAS;;UAIvB,SAAS;UACR,MAAM;;AAGjB,YAAY,MAAM,UAAU,WAAW,YAAY;UACxC,aAAa,SAAS;UACtB,OAAO;;AAIlB,YAAY,MAAM;UACP,aAAa,SAAS;UACtB,SAAS,WAAW;UACpB;;AAGX,YAAY,SAAS,UAAU,WAAW,YAAY;UAC3C,aAAa,SAAS;UACtB,MAAM;;AAGjB,YAAY,UAAU;UACX,aAAa,SAAS;;AAGjC,YAAY,OACR,SACA,SACA,QACA,MACA,WACA;AAEJ,OAAO,cAAMA,QAAQ;AACrB,OAAO,cAAMC,QAAQ;AACrB,OAAO,cAAMC,SAAS;AACtB,OAAO,cAAM,QAAS,UAAU,UAAU,MAAM,MAAI,MAAM;AAI1D,OAAO,cAAM,WAAY,UAAU,UAAU,MAAM,MAAI,SAAS","names":["String: String","Double: Double","Unknown: Unknown"],"sources":["../../src/primitives.ts"],"version":3,"file":"primitives.d.ts"}

package/build/types/utils.d.ts

@@ -0,0 +1,20 @@
+import type { ModelDef, RecordDef, UnionDef } from "./defs.js";
+import type { Ref } from "./primitives.js";
+/**
+* Helper function to safely transform a record definition to a reference.
+* This function helps TypeScript track type transformations better.
+*/
+export declare function modelToRef(model: ModelDef): Ref;
+/**
+* Helper function to create a reference with proper typing.
+* This avoids type assertions in multiple places.
+*/
+export declare function createRef(name: string, refType: "record" | "union"): Ref;
+/**
+* Type guard to check if a value is a RecordDef
+*/
+export declare function isRecordDef(value: unknown): value is RecordDef;
+/**
+* Type guard to check if a value is a UnionDef
+*/
+export declare function isUnionDef(value: unknown): value is UnionDef;

package/build/types/utils.d.ts.map

@@ -0,0 +1 @@
+{"mappings":"AAgBA,cAAc,UAAU,WAAW,gBAAgB;AAEnD,cAAc,WAAW;;;;;AAOzB,OAAO,iBAAS,WAAW,OAAO,WAAW;;;;;AAQ7C,OAAO,iBAAS,UAAU,cAAc,SAAS,WAAW,UAAU;;;;AAWtE,OAAO,iBAAS,YAAY,iBAAiB,SAAS;;;;AAWtD,OAAO,iBAAS,WAAW,iBAAiB,SAAS","names":[],"sources":["../../src/utils.ts"],"version":3,"file":"utils.d.ts"}